✨feat(hos_client_create, hos_client_destory): 多次调用destory不会导致重复释放

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/SWFEndpoint.h

@@ -0,0 +1,21 @@
+/**
+ * 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/core/Region.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+
+namespace SWF
+{
+namespace SWFEndpoint
+{
+AWS_SWF_API Aws::String ForRegion(const Aws::String& regionName, bool useDualStack = false);
+} // namespace SWFEndpoint
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/SWFErrorMarshaller.h

@@ -0,0 +1,23 @@
+/**
+ * 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/core/client/AWSErrorMarshaller.h>
+
+namespace Aws
+{
+namespace Client
+{
+
+class AWS_SWF_API SWFErrorMarshaller : public Aws::Client::JsonErrorMarshaller
+{
+public:
+  Aws::Client::AWSError<Aws::Client::CoreErrors> FindErrorByName(const char* exceptionName) const override;
+};
+
+} // namespace Client
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/SWFErrors.h

@@ -0,0 +1,81 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+#include <aws/core/client/AWSError.h>
+#include <aws/core/client/CoreErrors.h>
+#include <aws/swf/SWF_EXPORTS.h>
+
+namespace Aws
+{
+namespace SWF
+{
+enum class SWFErrors
+{
+  //From Core//
+  //////////////////////////////////////////////////////////////////////////////////////////
+  INCOMPLETE_SIGNATURE = 0,
+  INTERNAL_FAILURE = 1,
+  INVALID_ACTION = 2,
+  INVALID_CLIENT_TOKEN_ID = 3,
+  INVALID_PARAMETER_COMBINATION = 4,
+  INVALID_QUERY_PARAMETER = 5,
+  INVALID_PARAMETER_VALUE = 6,
+  MISSING_ACTION = 7, // SDK should never allow
+  MISSING_AUTHENTICATION_TOKEN = 8, // SDK should never allow
+  MISSING_PARAMETER = 9, // SDK should never allow
+  OPT_IN_REQUIRED = 10,
+  REQUEST_EXPIRED = 11,
+  SERVICE_UNAVAILABLE = 12,
+  THROTTLING = 13,
+  VALIDATION = 14,
+  ACCESS_DENIED = 15,
+  RESOURCE_NOT_FOUND = 16,
+  UNRECOGNIZED_CLIENT = 17,
+  MALFORMED_QUERY_STRING = 18,
+  SLOW_DOWN = 19,
+  REQUEST_TIME_TOO_SKEWED = 20,
+  INVALID_SIGNATURE = 21,
+  SIGNATURE_DOES_NOT_MATCH = 22,
+  INVALID_ACCESS_KEY_ID = 23,
+  REQUEST_TIMEOUT = 24,
+  NETWORK_CONNECTION = 99,
+
+  UNKNOWN = 100,
+  ///////////////////////////////////////////////////////////////////////////////////////////
+
+  DEFAULT_UNDEFINED_FAULT= static_cast<int>(Aws::Client::CoreErrors::SERVICE_EXTENSION_START_RANGE) + 1,
+  DOMAIN_ALREADY_EXISTS_FAULT,
+  DOMAIN_DEPRECATED_FAULT,
+  LIMIT_EXCEEDED_FAULT,
+  OPERATION_NOT_PERMITTED_FAULT,
+  TOO_MANY_TAGS_FAULT,
+  TYPE_ALREADY_EXISTS_FAULT,
+  TYPE_DEPRECATED_FAULT,
+  UNKNOWN_RESOURCE_FAULT,
+  WORKFLOW_EXECUTION_ALREADY_STARTED_FAULT
+};
+
+class AWS_SWF_API SWFError : public Aws::Client::AWSError<SWFErrors>
+{
+public:
+  SWFError() {}
+  SWFError(const Aws::Client::AWSError<Aws::Client::CoreErrors>& rhs) : Aws::Client::AWSError<SWFErrors>(rhs) {}
+  SWFError(Aws::Client::AWSError<Aws::Client::CoreErrors>&& rhs) : Aws::Client::AWSError<SWFErrors>(rhs) {}
+  SWFError(const Aws::Client::AWSError<SWFErrors>& rhs) : Aws::Client::AWSError<SWFErrors>(rhs) {}
+  SWFError(Aws::Client::AWSError<SWFErrors>&& rhs) : Aws::Client::AWSError<SWFErrors>(rhs) {}
+
+  template <typename T>
+  T GetModeledError();
+};
+
+namespace SWFErrorMapper
+{
+  AWS_SWF_API Aws::Client::AWSError<Aws::Client::CoreErrors> GetErrorForName(const char* errorName);
+}
+
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/SWFRequest.h

@@ -0,0 +1,42 @@
+/**
+ * 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/core/AmazonSerializableWebServiceRequest.h>
+#include <aws/core/utils/UnreferencedParam.h>
+#include <aws/core/http/HttpRequest.h>
+
+namespace Aws
+{
+namespace SWF
+{
+  class AWS_SWF_API SWFRequest : public Aws::AmazonSerializableWebServiceRequest
+  {
+  public:
+    virtual ~SWFRequest () {}
+
+    void AddParametersToRequest(Aws::Http::HttpRequest& httpRequest) const { AWS_UNREFERENCED_PARAM(httpRequest); }
+
+    inline Aws::Http::HeaderValueCollection GetHeaders() const override
+    {
+      auto headers = GetRequestSpecificHeaders();
+
+      if(headers.size() == 0 || (headers.size() > 0 && headers.count(Aws::Http::CONTENT_TYPE_HEADER) == 0))
+      {
+        headers.emplace(Aws::Http::HeaderValuePair(Aws::Http::CONTENT_TYPE_HEADER, Aws::AMZN_JSON_CONTENT_TYPE_1_0 ));
+      }
+      headers.emplace(Aws::Http::HeaderValuePair(Aws::Http::API_VERSION_HEADER, "2012-01-25"));
+      return headers;
+    }
+
+  protected:
+    virtual Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const { return Aws::Http::HeaderValueCollection(); }
+
+  };
+
+
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/SWF_EXPORTS.h

@@ -0,0 +1,29 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+#ifdef _MSC_VER
+    //disable windows complaining about max template size.
+    #pragma warning (disable : 4503)
+#endif // _MSC_VER
+
+#if defined (USE_WINDOWS_DLL_SEMANTICS) || defined (_WIN32)
+    #ifdef _MSC_VER
+        #pragma warning(disable : 4251)
+    #endif // _MSC_VER
+
+    #ifdef USE_IMPORT_EXPORT
+        #ifdef AWS_SWF_EXPORTS
+            #define AWS_SWF_API __declspec(dllexport)
+        #else
+            #define AWS_SWF_API __declspec(dllimport)
+        #endif /* AWS_SWF_EXPORTS */
+    #else
+        #define AWS_SWF_API
+    #endif // USE_IMPORT_EXPORT
+#else // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)
+    #define AWS_SWF_API
+#endif // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ActivityTaskCancelRequestedEventAttributes.h

@@ -0,0 +1,129 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>ActivityTaskCancelRequested</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ActivityTaskCancelRequestedEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ActivityTaskCancelRequestedEventAttributes
+  {
+  public:
+    ActivityTaskCancelRequestedEventAttributes();
+    ActivityTaskCancelRequestedEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    ActivityTaskCancelRequestedEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>RequestCancelActivityTask</code>
+     * decision for this cancellation request. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline long long GetDecisionTaskCompletedEventId() const{ return m_decisionTaskCompletedEventId; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>RequestCancelActivityTask</code>
+     * decision for this cancellation request. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline bool DecisionTaskCompletedEventIdHasBeenSet() const { return m_decisionTaskCompletedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>RequestCancelActivityTask</code>
+     * decision for this cancellation request. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline void SetDecisionTaskCompletedEventId(long long value) { m_decisionTaskCompletedEventIdHasBeenSet = true; m_decisionTaskCompletedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>RequestCancelActivityTask</code>
+     * decision for this cancellation request. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline ActivityTaskCancelRequestedEventAttributes& WithDecisionTaskCompletedEventId(long long value) { SetDecisionTaskCompletedEventId(value); return *this;}
+
+
+    /**
+     * <p>The unique ID of the task.</p>
+     */
+    inline const Aws::String& GetActivityId() const{ return m_activityId; }
+
+    /**
+     * <p>The unique ID of the task.</p>
+     */
+    inline bool ActivityIdHasBeenSet() const { return m_activityIdHasBeenSet; }
+
+    /**
+     * <p>The unique ID of the task.</p>
+     */
+    inline void SetActivityId(const Aws::String& value) { m_activityIdHasBeenSet = true; m_activityId = value; }
+
+    /**
+     * <p>The unique ID of the task.</p>
+     */
+    inline void SetActivityId(Aws::String&& value) { m_activityIdHasBeenSet = true; m_activityId = std::move(value); }
+
+    /**
+     * <p>The unique ID of the task.</p>
+     */
+    inline void SetActivityId(const char* value) { m_activityIdHasBeenSet = true; m_activityId.assign(value); }
+
+    /**
+     * <p>The unique ID of the task.</p>
+     */
+    inline ActivityTaskCancelRequestedEventAttributes& WithActivityId(const Aws::String& value) { SetActivityId(value); return *this;}
+
+    /**
+     * <p>The unique ID of the task.</p>
+     */
+    inline ActivityTaskCancelRequestedEventAttributes& WithActivityId(Aws::String&& value) { SetActivityId(std::move(value)); return *this;}
+
+    /**
+     * <p>The unique ID of the task.</p>
+     */
+    inline ActivityTaskCancelRequestedEventAttributes& WithActivityId(const char* value) { SetActivityId(value); return *this;}
+
+  private:
+
+    long long m_decisionTaskCompletedEventId;
+    bool m_decisionTaskCompletedEventIdHasBeenSet;
+
+    Aws::String m_activityId;
+    bool m_activityIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ActivityTaskCanceledEventAttributes.h

@@ -0,0 +1,189 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>ActivityTaskCanceled</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ActivityTaskCanceledEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ActivityTaskCanceledEventAttributes
+  {
+  public:
+    ActivityTaskCanceledEventAttributes();
+    ActivityTaskCanceledEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    ActivityTaskCanceledEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Details of the cancellation.</p>
+     */
+    inline const Aws::String& GetDetails() const{ return m_details; }
+
+    /**
+     * <p>Details of the cancellation.</p>
+     */
+    inline bool DetailsHasBeenSet() const { return m_detailsHasBeenSet; }
+
+    /**
+     * <p>Details of the cancellation.</p>
+     */
+    inline void SetDetails(const Aws::String& value) { m_detailsHasBeenSet = true; m_details = value; }
+
+    /**
+     * <p>Details of the cancellation.</p>
+     */
+    inline void SetDetails(Aws::String&& value) { m_detailsHasBeenSet = true; m_details = std::move(value); }
+
+    /**
+     * <p>Details of the cancellation.</p>
+     */
+    inline void SetDetails(const char* value) { m_detailsHasBeenSet = true; m_details.assign(value); }
+
+    /**
+     * <p>Details of the cancellation.</p>
+     */
+    inline ActivityTaskCanceledEventAttributes& WithDetails(const Aws::String& value) { SetDetails(value); return *this;}
+
+    /**
+     * <p>Details of the cancellation.</p>
+     */
+    inline ActivityTaskCanceledEventAttributes& WithDetails(Aws::String&& value) { SetDetails(std::move(value)); return *this;}
+
+    /**
+     * <p>Details of the cancellation.</p>
+     */
+    inline ActivityTaskCanceledEventAttributes& WithDetails(const char* value) { SetDetails(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>ActivityTaskScheduled</code> event that was recorded when
+     * this activity task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline long long GetScheduledEventId() const{ return m_scheduledEventId; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskScheduled</code> event that was recorded when
+     * this activity task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline bool ScheduledEventIdHasBeenSet() const { return m_scheduledEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskScheduled</code> event that was recorded when
+     * this activity task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline void SetScheduledEventId(long long value) { m_scheduledEventIdHasBeenSet = true; m_scheduledEventId = value; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskScheduled</code> event that was recorded when
+     * this activity task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline ActivityTaskCanceledEventAttributes& WithScheduledEventId(long long value) { SetScheduledEventId(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event recorded when this
+     * activity task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline long long GetStartedEventId() const{ return m_startedEventId; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event recorded when this
+     * activity task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline bool StartedEventIdHasBeenSet() const { return m_startedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event recorded when this
+     * activity task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline void SetStartedEventId(long long value) { m_startedEventIdHasBeenSet = true; m_startedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event recorded when this
+     * activity task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline ActivityTaskCanceledEventAttributes& WithStartedEventId(long long value) { SetStartedEventId(value); return *this;}
+
+
+    /**
+     * <p>If set, contains the ID of the last <code>ActivityTaskCancelRequested</code>
+     * event recorded for this activity task. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline long long GetLatestCancelRequestedEventId() const{ return m_latestCancelRequestedEventId; }
+
+    /**
+     * <p>If set, contains the ID of the last <code>ActivityTaskCancelRequested</code>
+     * event recorded for this activity task. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline bool LatestCancelRequestedEventIdHasBeenSet() const { return m_latestCancelRequestedEventIdHasBeenSet; }
+
+    /**
+     * <p>If set, contains the ID of the last <code>ActivityTaskCancelRequested</code>
+     * event recorded for this activity task. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline void SetLatestCancelRequestedEventId(long long value) { m_latestCancelRequestedEventIdHasBeenSet = true; m_latestCancelRequestedEventId = value; }
+
+    /**
+     * <p>If set, contains the ID of the last <code>ActivityTaskCancelRequested</code>
+     * event recorded for this activity task. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline ActivityTaskCanceledEventAttributes& WithLatestCancelRequestedEventId(long long value) { SetLatestCancelRequestedEventId(value); return *this;}
+
+  private:
+
+    Aws::String m_details;
+    bool m_detailsHasBeenSet;
+
+    long long m_scheduledEventId;
+    bool m_scheduledEventIdHasBeenSet;
+
+    long long m_startedEventId;
+    bool m_startedEventIdHasBeenSet;
+
+    long long m_latestCancelRequestedEventId;
+    bool m_latestCancelRequestedEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ActivityTaskCompletedEventAttributes.h

@@ -0,0 +1,153 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>ActivityTaskCompleted</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ActivityTaskCompletedEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ActivityTaskCompletedEventAttributes
+  {
+  public:
+    ActivityTaskCompletedEventAttributes();
+    ActivityTaskCompletedEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    ActivityTaskCompletedEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The results of the activity task.</p>
+     */
+    inline const Aws::String& GetResult() const{ return m_result; }
+
+    /**
+     * <p>The results of the activity task.</p>
+     */
+    inline bool ResultHasBeenSet() const { return m_resultHasBeenSet; }
+
+    /**
+     * <p>The results of the activity task.</p>
+     */
+    inline void SetResult(const Aws::String& value) { m_resultHasBeenSet = true; m_result = value; }
+
+    /**
+     * <p>The results of the activity task.</p>
+     */
+    inline void SetResult(Aws::String&& value) { m_resultHasBeenSet = true; m_result = std::move(value); }
+
+    /**
+     * <p>The results of the activity task.</p>
+     */
+    inline void SetResult(const char* value) { m_resultHasBeenSet = true; m_result.assign(value); }
+
+    /**
+     * <p>The results of the activity task.</p>
+     */
+    inline ActivityTaskCompletedEventAttributes& WithResult(const Aws::String& value) { SetResult(value); return *this;}
+
+    /**
+     * <p>The results of the activity task.</p>
+     */
+    inline ActivityTaskCompletedEventAttributes& WithResult(Aws::String&& value) { SetResult(std::move(value)); return *this;}
+
+    /**
+     * <p>The results of the activity task.</p>
+     */
+    inline ActivityTaskCompletedEventAttributes& WithResult(const char* value) { SetResult(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>ActivityTaskScheduled</code> event that was recorded when
+     * this activity task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline long long GetScheduledEventId() const{ return m_scheduledEventId; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskScheduled</code> event that was recorded when
+     * this activity task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline bool ScheduledEventIdHasBeenSet() const { return m_scheduledEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskScheduled</code> event that was recorded when
+     * this activity task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline void SetScheduledEventId(long long value) { m_scheduledEventIdHasBeenSet = true; m_scheduledEventId = value; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskScheduled</code> event that was recorded when
+     * this activity task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline ActivityTaskCompletedEventAttributes& WithScheduledEventId(long long value) { SetScheduledEventId(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event recorded when this
+     * activity task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline long long GetStartedEventId() const{ return m_startedEventId; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event recorded when this
+     * activity task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline bool StartedEventIdHasBeenSet() const { return m_startedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event recorded when this
+     * activity task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline void SetStartedEventId(long long value) { m_startedEventIdHasBeenSet = true; m_startedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event recorded when this
+     * activity task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline ActivityTaskCompletedEventAttributes& WithStartedEventId(long long value) { SetStartedEventId(value); return *this;}
+
+  private:
+
+    Aws::String m_result;
+    bool m_resultHasBeenSet;
+
+    long long m_scheduledEventId;
+    bool m_scheduledEventIdHasBeenSet;
+
+    long long m_startedEventId;
+    bool m_startedEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ActivityTaskFailedEventAttributes.h

@@ -0,0 +1,197 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>ActivityTaskFailed</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ActivityTaskFailedEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ActivityTaskFailedEventAttributes
+  {
+  public:
+    ActivityTaskFailedEventAttributes();
+    ActivityTaskFailedEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    ActivityTaskFailedEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The reason provided for the failure.</p>
+     */
+    inline const Aws::String& GetReason() const{ return m_reason; }
+
+    /**
+     * <p>The reason provided for the failure.</p>
+     */
+    inline bool ReasonHasBeenSet() const { return m_reasonHasBeenSet; }
+
+    /**
+     * <p>The reason provided for the failure.</p>
+     */
+    inline void SetReason(const Aws::String& value) { m_reasonHasBeenSet = true; m_reason = value; }
+
+    /**
+     * <p>The reason provided for the failure.</p>
+     */
+    inline void SetReason(Aws::String&& value) { m_reasonHasBeenSet = true; m_reason = std::move(value); }
+
+    /**
+     * <p>The reason provided for the failure.</p>
+     */
+    inline void SetReason(const char* value) { m_reasonHasBeenSet = true; m_reason.assign(value); }
+
+    /**
+     * <p>The reason provided for the failure.</p>
+     */
+    inline ActivityTaskFailedEventAttributes& WithReason(const Aws::String& value) { SetReason(value); return *this;}
+
+    /**
+     * <p>The reason provided for the failure.</p>
+     */
+    inline ActivityTaskFailedEventAttributes& WithReason(Aws::String&& value) { SetReason(std::move(value)); return *this;}
+
+    /**
+     * <p>The reason provided for the failure.</p>
+     */
+    inline ActivityTaskFailedEventAttributes& WithReason(const char* value) { SetReason(value); return *this;}
+
+
+    /**
+     * <p>The details of the failure.</p>
+     */
+    inline const Aws::String& GetDetails() const{ return m_details; }
+
+    /**
+     * <p>The details of the failure.</p>
+     */
+    inline bool DetailsHasBeenSet() const { return m_detailsHasBeenSet; }
+
+    /**
+     * <p>The details of the failure.</p>
+     */
+    inline void SetDetails(const Aws::String& value) { m_detailsHasBeenSet = true; m_details = value; }
+
+    /**
+     * <p>The details of the failure.</p>
+     */
+    inline void SetDetails(Aws::String&& value) { m_detailsHasBeenSet = true; m_details = std::move(value); }
+
+    /**
+     * <p>The details of the failure.</p>
+     */
+    inline void SetDetails(const char* value) { m_detailsHasBeenSet = true; m_details.assign(value); }
+
+    /**
+     * <p>The details of the failure.</p>
+     */
+    inline ActivityTaskFailedEventAttributes& WithDetails(const Aws::String& value) { SetDetails(value); return *this;}
+
+    /**
+     * <p>The details of the failure.</p>
+     */
+    inline ActivityTaskFailedEventAttributes& WithDetails(Aws::String&& value) { SetDetails(std::move(value)); return *this;}
+
+    /**
+     * <p>The details of the failure.</p>
+     */
+    inline ActivityTaskFailedEventAttributes& WithDetails(const char* value) { SetDetails(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>ActivityTaskScheduled</code> event that was recorded when
+     * this activity task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline long long GetScheduledEventId() const{ return m_scheduledEventId; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskScheduled</code> event that was recorded when
+     * this activity task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline bool ScheduledEventIdHasBeenSet() const { return m_scheduledEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskScheduled</code> event that was recorded when
+     * this activity task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline void SetScheduledEventId(long long value) { m_scheduledEventIdHasBeenSet = true; m_scheduledEventId = value; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskScheduled</code> event that was recorded when
+     * this activity task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline ActivityTaskFailedEventAttributes& WithScheduledEventId(long long value) { SetScheduledEventId(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event recorded when this
+     * activity task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline long long GetStartedEventId() const{ return m_startedEventId; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event recorded when this
+     * activity task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline bool StartedEventIdHasBeenSet() const { return m_startedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event recorded when this
+     * activity task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline void SetStartedEventId(long long value) { m_startedEventIdHasBeenSet = true; m_startedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event recorded when this
+     * activity task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline ActivityTaskFailedEventAttributes& WithStartedEventId(long long value) { SetStartedEventId(value); return *this;}
+
+  private:
+
+    Aws::String m_reason;
+    bool m_reasonHasBeenSet;
+
+    Aws::String m_details;
+    bool m_detailsHasBeenSet;
+
+    long long m_scheduledEventId;
+    bool m_scheduledEventIdHasBeenSet;
+
+    long long m_startedEventId;
+    bool m_startedEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ActivityTaskScheduledEventAttributes.h

@@ -0,0 +1,615 @@
+/**
+ * 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/model/ActivityType.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/TaskList.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>ActivityTaskScheduled</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ActivityTaskScheduledEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ActivityTaskScheduledEventAttributes
+  {
+  public:
+    ActivityTaskScheduledEventAttributes();
+    ActivityTaskScheduledEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    ActivityTaskScheduledEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The type of the activity task.</p>
+     */
+    inline const ActivityType& GetActivityType() const{ return m_activityType; }
+
+    /**
+     * <p>The type of the activity task.</p>
+     */
+    inline bool ActivityTypeHasBeenSet() const { return m_activityTypeHasBeenSet; }
+
+    /**
+     * <p>The type of the activity task.</p>
+     */
+    inline void SetActivityType(const ActivityType& value) { m_activityTypeHasBeenSet = true; m_activityType = value; }
+
+    /**
+     * <p>The type of the activity task.</p>
+     */
+    inline void SetActivityType(ActivityType&& value) { m_activityTypeHasBeenSet = true; m_activityType = std::move(value); }
+
+    /**
+     * <p>The type of the activity task.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithActivityType(const ActivityType& value) { SetActivityType(value); return *this;}
+
+    /**
+     * <p>The type of the activity task.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithActivityType(ActivityType&& value) { SetActivityType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The unique ID of the activity task.</p>
+     */
+    inline const Aws::String& GetActivityId() const{ return m_activityId; }
+
+    /**
+     * <p>The unique ID of the activity task.</p>
+     */
+    inline bool ActivityIdHasBeenSet() const { return m_activityIdHasBeenSet; }
+
+    /**
+     * <p>The unique ID of the activity task.</p>
+     */
+    inline void SetActivityId(const Aws::String& value) { m_activityIdHasBeenSet = true; m_activityId = value; }
+
+    /**
+     * <p>The unique ID of the activity task.</p>
+     */
+    inline void SetActivityId(Aws::String&& value) { m_activityIdHasBeenSet = true; m_activityId = std::move(value); }
+
+    /**
+     * <p>The unique ID of the activity task.</p>
+     */
+    inline void SetActivityId(const char* value) { m_activityIdHasBeenSet = true; m_activityId.assign(value); }
+
+    /**
+     * <p>The unique ID of the activity task.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithActivityId(const Aws::String& value) { SetActivityId(value); return *this;}
+
+    /**
+     * <p>The unique ID of the activity task.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithActivityId(Aws::String&& value) { SetActivityId(std::move(value)); return *this;}
+
+    /**
+     * <p>The unique ID of the activity task.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithActivityId(const char* value) { SetActivityId(value); return *this;}
+
+
+    /**
+     * <p>The input provided to the activity task.</p>
+     */
+    inline const Aws::String& GetInput() const{ return m_input; }
+
+    /**
+     * <p>The input provided to the activity task.</p>
+     */
+    inline bool InputHasBeenSet() const { return m_inputHasBeenSet; }
+
+    /**
+     * <p>The input provided to the activity task.</p>
+     */
+    inline void SetInput(const Aws::String& value) { m_inputHasBeenSet = true; m_input = value; }
+
+    /**
+     * <p>The input provided to the activity task.</p>
+     */
+    inline void SetInput(Aws::String&& value) { m_inputHasBeenSet = true; m_input = std::move(value); }
+
+    /**
+     * <p>The input provided to the activity task.</p>
+     */
+    inline void SetInput(const char* value) { m_inputHasBeenSet = true; m_input.assign(value); }
+
+    /**
+     * <p>The input provided to the activity task.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithInput(const Aws::String& value) { SetInput(value); return *this;}
+
+    /**
+     * <p>The input provided to the activity task.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithInput(Aws::String&& value) { SetInput(std::move(value)); return *this;}
+
+    /**
+     * <p>The input provided to the activity task.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithInput(const char* value) { SetInput(value); return *this;}
+
+
+    /**
+     * <p>Data attached to the event that can be used by the decider in subsequent
+     * workflow tasks. This data isn't sent to the activity.</p>
+     */
+    inline const Aws::String& GetControl() const{ return m_control; }
+
+    /**
+     * <p>Data attached to the event that can be used by the decider in subsequent
+     * workflow tasks. This data isn't sent to the activity.</p>
+     */
+    inline bool ControlHasBeenSet() const { return m_controlHasBeenSet; }
+
+    /**
+     * <p>Data attached to the event that can be used by the decider in subsequent
+     * workflow tasks. This data isn't sent to the activity.</p>
+     */
+    inline void SetControl(const Aws::String& value) { m_controlHasBeenSet = true; m_control = value; }
+
+    /**
+     * <p>Data attached to the event that can be used by the decider in subsequent
+     * workflow tasks. This data isn't sent to the activity.</p>
+     */
+    inline void SetControl(Aws::String&& value) { m_controlHasBeenSet = true; m_control = std::move(value); }
+
+    /**
+     * <p>Data attached to the event that can be used by the decider in subsequent
+     * workflow tasks. This data isn't sent to the activity.</p>
+     */
+    inline void SetControl(const char* value) { m_controlHasBeenSet = true; m_control.assign(value); }
+
+    /**
+     * <p>Data attached to the event that can be used by the decider in subsequent
+     * workflow tasks. This data isn't sent to the activity.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithControl(const Aws::String& value) { SetControl(value); return *this;}
+
+    /**
+     * <p>Data attached to the event that can be used by the decider in subsequent
+     * workflow tasks. This data isn't sent to the activity.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithControl(Aws::String&& value) { SetControl(std::move(value)); return *this;}
+
+    /**
+     * <p>Data attached to the event that can be used by the decider in subsequent
+     * workflow tasks. This data isn't sent to the activity.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithControl(const char* value) { SetControl(value); return *this;}
+
+
+    /**
+     * <p>The maximum amount of time the activity task can wait to be assigned to a
+     * worker.</p>
+     */
+    inline const Aws::String& GetScheduleToStartTimeout() const{ return m_scheduleToStartTimeout; }
+
+    /**
+     * <p>The maximum amount of time the activity task can wait to be assigned to a
+     * worker.</p>
+     */
+    inline bool ScheduleToStartTimeoutHasBeenSet() const { return m_scheduleToStartTimeoutHasBeenSet; }
+
+    /**
+     * <p>The maximum amount of time the activity task can wait to be assigned to a
+     * worker.</p>
+     */
+    inline void SetScheduleToStartTimeout(const Aws::String& value) { m_scheduleToStartTimeoutHasBeenSet = true; m_scheduleToStartTimeout = value; }
+
+    /**
+     * <p>The maximum amount of time the activity task can wait to be assigned to a
+     * worker.</p>
+     */
+    inline void SetScheduleToStartTimeout(Aws::String&& value) { m_scheduleToStartTimeoutHasBeenSet = true; m_scheduleToStartTimeout = std::move(value); }
+
+    /**
+     * <p>The maximum amount of time the activity task can wait to be assigned to a
+     * worker.</p>
+     */
+    inline void SetScheduleToStartTimeout(const char* value) { m_scheduleToStartTimeoutHasBeenSet = true; m_scheduleToStartTimeout.assign(value); }
+
+    /**
+     * <p>The maximum amount of time the activity task can wait to be assigned to a
+     * worker.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithScheduleToStartTimeout(const Aws::String& value) { SetScheduleToStartTimeout(value); return *this;}
+
+    /**
+     * <p>The maximum amount of time the activity task can wait to be assigned to a
+     * worker.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithScheduleToStartTimeout(Aws::String&& value) { SetScheduleToStartTimeout(std::move(value)); return *this;}
+
+    /**
+     * <p>The maximum amount of time the activity task can wait to be assigned to a
+     * worker.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithScheduleToStartTimeout(const char* value) { SetScheduleToStartTimeout(value); return *this;}
+
+
+    /**
+     * <p>The maximum amount of time for this activity task.</p>
+     */
+    inline const Aws::String& GetScheduleToCloseTimeout() const{ return m_scheduleToCloseTimeout; }
+
+    /**
+     * <p>The maximum amount of time for this activity task.</p>
+     */
+    inline bool ScheduleToCloseTimeoutHasBeenSet() const { return m_scheduleToCloseTimeoutHasBeenSet; }
+
+    /**
+     * <p>The maximum amount of time for this activity task.</p>
+     */
+    inline void SetScheduleToCloseTimeout(const Aws::String& value) { m_scheduleToCloseTimeoutHasBeenSet = true; m_scheduleToCloseTimeout = value; }
+
+    /**
+     * <p>The maximum amount of time for this activity task.</p>
+     */
+    inline void SetScheduleToCloseTimeout(Aws::String&& value) { m_scheduleToCloseTimeoutHasBeenSet = true; m_scheduleToCloseTimeout = std::move(value); }
+
+    /**
+     * <p>The maximum amount of time for this activity task.</p>
+     */
+    inline void SetScheduleToCloseTimeout(const char* value) { m_scheduleToCloseTimeoutHasBeenSet = true; m_scheduleToCloseTimeout.assign(value); }
+
+    /**
+     * <p>The maximum amount of time for this activity task.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithScheduleToCloseTimeout(const Aws::String& value) { SetScheduleToCloseTimeout(value); return *this;}
+
+    /**
+     * <p>The maximum amount of time for this activity task.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithScheduleToCloseTimeout(Aws::String&& value) { SetScheduleToCloseTimeout(std::move(value)); return *this;}
+
+    /**
+     * <p>The maximum amount of time for this activity task.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithScheduleToCloseTimeout(const char* value) { SetScheduleToCloseTimeout(value); return *this;}
+
+
+    /**
+     * <p>The maximum amount of time a worker may take to process the activity
+     * task.</p>
+     */
+    inline const Aws::String& GetStartToCloseTimeout() const{ return m_startToCloseTimeout; }
+
+    /**
+     * <p>The maximum amount of time a worker may take to process the activity
+     * task.</p>
+     */
+    inline bool StartToCloseTimeoutHasBeenSet() const { return m_startToCloseTimeoutHasBeenSet; }
+
+    /**
+     * <p>The maximum amount of time a worker may take to process the activity
+     * task.</p>
+     */
+    inline void SetStartToCloseTimeout(const Aws::String& value) { m_startToCloseTimeoutHasBeenSet = true; m_startToCloseTimeout = value; }
+
+    /**
+     * <p>The maximum amount of time a worker may take to process the activity
+     * task.</p>
+     */
+    inline void SetStartToCloseTimeout(Aws::String&& value) { m_startToCloseTimeoutHasBeenSet = true; m_startToCloseTimeout = std::move(value); }
+
+    /**
+     * <p>The maximum amount of time a worker may take to process the activity
+     * task.</p>
+     */
+    inline void SetStartToCloseTimeout(const char* value) { m_startToCloseTimeoutHasBeenSet = true; m_startToCloseTimeout.assign(value); }
+
+    /**
+     * <p>The maximum amount of time a worker may take to process the activity
+     * task.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithStartToCloseTimeout(const Aws::String& value) { SetStartToCloseTimeout(value); return *this;}
+
+    /**
+     * <p>The maximum amount of time a worker may take to process the activity
+     * task.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithStartToCloseTimeout(Aws::String&& value) { SetStartToCloseTimeout(std::move(value)); return *this;}
+
+    /**
+     * <p>The maximum amount of time a worker may take to process the activity
+     * task.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithStartToCloseTimeout(const char* value) { SetStartToCloseTimeout(value); return *this;}
+
+
+    /**
+     * <p>The task list in which the activity task has been scheduled.</p>
+     */
+    inline const TaskList& GetTaskList() const{ return m_taskList; }
+
+    /**
+     * <p>The task list in which the activity task has been scheduled.</p>
+     */
+    inline bool TaskListHasBeenSet() const { return m_taskListHasBeenSet; }
+
+    /**
+     * <p>The task list in which the activity task has been scheduled.</p>
+     */
+    inline void SetTaskList(const TaskList& value) { m_taskListHasBeenSet = true; m_taskList = value; }
+
+    /**
+     * <p>The task list in which the activity task has been scheduled.</p>
+     */
+    inline void SetTaskList(TaskList&& value) { m_taskListHasBeenSet = true; m_taskList = std::move(value); }
+
+    /**
+     * <p>The task list in which the activity task has been scheduled.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithTaskList(const TaskList& value) { SetTaskList(value); return *this;}
+
+    /**
+     * <p>The task list in which the activity task has been scheduled.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithTaskList(TaskList&& value) { SetTaskList(std::move(value)); return *this;}
+
+
+    /**
+     * <p> The priority to assign to the scheduled activity task. If set, this
+     * overrides any default priority value that was assigned when the activity type
+     * was registered.</p> <p>Valid values are integers that range from Java's
+     * <code>Integer.MIN_VALUE</code> (-2147483648) to <code>Integer.MAX_VALUE</code>
+     * (2147483647). Higher numbers indicate higher priority.</p> <p>For more
+     * information about setting task priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline const Aws::String& GetTaskPriority() const{ return m_taskPriority; }
+
+    /**
+     * <p> The priority to assign to the scheduled activity task. If set, this
+     * overrides any default priority value that was assigned when the activity type
+     * was registered.</p> <p>Valid values are integers that range from Java's
+     * <code>Integer.MIN_VALUE</code> (-2147483648) to <code>Integer.MAX_VALUE</code>
+     * (2147483647). Higher numbers indicate higher priority.</p> <p>For more
+     * information about setting task priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline bool TaskPriorityHasBeenSet() const { return m_taskPriorityHasBeenSet; }
+
+    /**
+     * <p> The priority to assign to the scheduled activity task. If set, this
+     * overrides any default priority value that was assigned when the activity type
+     * was registered.</p> <p>Valid values are integers that range from Java's
+     * <code>Integer.MIN_VALUE</code> (-2147483648) to <code>Integer.MAX_VALUE</code>
+     * (2147483647). Higher numbers indicate higher priority.</p> <p>For more
+     * information about setting task priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline void SetTaskPriority(const Aws::String& value) { m_taskPriorityHasBeenSet = true; m_taskPriority = value; }
+
+    /**
+     * <p> The priority to assign to the scheduled activity task. If set, this
+     * overrides any default priority value that was assigned when the activity type
+     * was registered.</p> <p>Valid values are integers that range from Java's
+     * <code>Integer.MIN_VALUE</code> (-2147483648) to <code>Integer.MAX_VALUE</code>
+     * (2147483647). Higher numbers indicate higher priority.</p> <p>For more
+     * information about setting task priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline void SetTaskPriority(Aws::String&& value) { m_taskPriorityHasBeenSet = true; m_taskPriority = std::move(value); }
+
+    /**
+     * <p> The priority to assign to the scheduled activity task. If set, this
+     * overrides any default priority value that was assigned when the activity type
+     * was registered.</p> <p>Valid values are integers that range from Java's
+     * <code>Integer.MIN_VALUE</code> (-2147483648) to <code>Integer.MAX_VALUE</code>
+     * (2147483647). Higher numbers indicate higher priority.</p> <p>For more
+     * information about setting task priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline void SetTaskPriority(const char* value) { m_taskPriorityHasBeenSet = true; m_taskPriority.assign(value); }
+
+    /**
+     * <p> The priority to assign to the scheduled activity task. If set, this
+     * overrides any default priority value that was assigned when the activity type
+     * was registered.</p> <p>Valid values are integers that range from Java's
+     * <code>Integer.MIN_VALUE</code> (-2147483648) to <code>Integer.MAX_VALUE</code>
+     * (2147483647). Higher numbers indicate higher priority.</p> <p>For more
+     * information about setting task priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithTaskPriority(const Aws::String& value) { SetTaskPriority(value); return *this;}
+
+    /**
+     * <p> The priority to assign to the scheduled activity task. If set, this
+     * overrides any default priority value that was assigned when the activity type
+     * was registered.</p> <p>Valid values are integers that range from Java's
+     * <code>Integer.MIN_VALUE</code> (-2147483648) to <code>Integer.MAX_VALUE</code>
+     * (2147483647). Higher numbers indicate higher priority.</p> <p>For more
+     * information about setting task priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithTaskPriority(Aws::String&& value) { SetTaskPriority(std::move(value)); return *this;}
+
+    /**
+     * <p> The priority to assign to the scheduled activity task. If set, this
+     * overrides any default priority value that was assigned when the activity type
+     * was registered.</p> <p>Valid values are integers that range from Java's
+     * <code>Integer.MIN_VALUE</code> (-2147483648) to <code>Integer.MAX_VALUE</code>
+     * (2147483647). Higher numbers indicate higher priority.</p> <p>For more
+     * information about setting task priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithTaskPriority(const char* value) { SetTaskPriority(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision that resulted in the scheduling of this activity task. This information
+     * can be useful for diagnosing problems by tracing back the chain of events
+     * leading up to this event.</p>
+     */
+    inline long long GetDecisionTaskCompletedEventId() const{ return m_decisionTaskCompletedEventId; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision that resulted in the scheduling of this activity task. This information
+     * can be useful for diagnosing problems by tracing back the chain of events
+     * leading up to this event.</p>
+     */
+    inline bool DecisionTaskCompletedEventIdHasBeenSet() const { return m_decisionTaskCompletedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision that resulted in the scheduling of this activity task. This information
+     * can be useful for diagnosing problems by tracing back the chain of events
+     * leading up to this event.</p>
+     */
+    inline void SetDecisionTaskCompletedEventId(long long value) { m_decisionTaskCompletedEventIdHasBeenSet = true; m_decisionTaskCompletedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision that resulted in the scheduling of this activity task. This information
+     * can be useful for diagnosing problems by tracing back the chain of events
+     * leading up to this event.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithDecisionTaskCompletedEventId(long long value) { SetDecisionTaskCompletedEventId(value); return *this;}
+
+
+    /**
+     * <p>The maximum time before which the worker processing this task must report
+     * progress by calling <a>RecordActivityTaskHeartbeat</a>. If the timeout is
+     * exceeded, the activity task is automatically timed out. If the worker
+     * subsequently attempts to record a heartbeat or return a result, it is
+     * ignored.</p>
+     */
+    inline const Aws::String& GetHeartbeatTimeout() const{ return m_heartbeatTimeout; }
+
+    /**
+     * <p>The maximum time before which the worker processing this task must report
+     * progress by calling <a>RecordActivityTaskHeartbeat</a>. If the timeout is
+     * exceeded, the activity task is automatically timed out. If the worker
+     * subsequently attempts to record a heartbeat or return a result, it is
+     * ignored.</p>
+     */
+    inline bool HeartbeatTimeoutHasBeenSet() const { return m_heartbeatTimeoutHasBeenSet; }
+
+    /**
+     * <p>The maximum time before which the worker processing this task must report
+     * progress by calling <a>RecordActivityTaskHeartbeat</a>. If the timeout is
+     * exceeded, the activity task is automatically timed out. If the worker
+     * subsequently attempts to record a heartbeat or return a result, it is
+     * ignored.</p>
+     */
+    inline void SetHeartbeatTimeout(const Aws::String& value) { m_heartbeatTimeoutHasBeenSet = true; m_heartbeatTimeout = value; }
+
+    /**
+     * <p>The maximum time before which the worker processing this task must report
+     * progress by calling <a>RecordActivityTaskHeartbeat</a>. If the timeout is
+     * exceeded, the activity task is automatically timed out. If the worker
+     * subsequently attempts to record a heartbeat or return a result, it is
+     * ignored.</p>
+     */
+    inline void SetHeartbeatTimeout(Aws::String&& value) { m_heartbeatTimeoutHasBeenSet = true; m_heartbeatTimeout = std::move(value); }
+
+    /**
+     * <p>The maximum time before which the worker processing this task must report
+     * progress by calling <a>RecordActivityTaskHeartbeat</a>. If the timeout is
+     * exceeded, the activity task is automatically timed out. If the worker
+     * subsequently attempts to record a heartbeat or return a result, it is
+     * ignored.</p>
+     */
+    inline void SetHeartbeatTimeout(const char* value) { m_heartbeatTimeoutHasBeenSet = true; m_heartbeatTimeout.assign(value); }
+
+    /**
+     * <p>The maximum time before which the worker processing this task must report
+     * progress by calling <a>RecordActivityTaskHeartbeat</a>. If the timeout is
+     * exceeded, the activity task is automatically timed out. If the worker
+     * subsequently attempts to record a heartbeat or return a result, it is
+     * ignored.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithHeartbeatTimeout(const Aws::String& value) { SetHeartbeatTimeout(value); return *this;}
+
+    /**
+     * <p>The maximum time before which the worker processing this task must report
+     * progress by calling <a>RecordActivityTaskHeartbeat</a>. If the timeout is
+     * exceeded, the activity task is automatically timed out. If the worker
+     * subsequently attempts to record a heartbeat or return a result, it is
+     * ignored.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithHeartbeatTimeout(Aws::String&& value) { SetHeartbeatTimeout(std::move(value)); return *this;}
+
+    /**
+     * <p>The maximum time before which the worker processing this task must report
+     * progress by calling <a>RecordActivityTaskHeartbeat</a>. If the timeout is
+     * exceeded, the activity task is automatically timed out. If the worker
+     * subsequently attempts to record a heartbeat or return a result, it is
+     * ignored.</p>
+     */
+    inline ActivityTaskScheduledEventAttributes& WithHeartbeatTimeout(const char* value) { SetHeartbeatTimeout(value); return *this;}
+
+  private:
+
+    ActivityType m_activityType;
+    bool m_activityTypeHasBeenSet;
+
+    Aws::String m_activityId;
+    bool m_activityIdHasBeenSet;
+
+    Aws::String m_input;
+    bool m_inputHasBeenSet;
+
+    Aws::String m_control;
+    bool m_controlHasBeenSet;
+
+    Aws::String m_scheduleToStartTimeout;
+    bool m_scheduleToStartTimeoutHasBeenSet;
+
+    Aws::String m_scheduleToCloseTimeout;
+    bool m_scheduleToCloseTimeoutHasBeenSet;
+
+    Aws::String m_startToCloseTimeout;
+    bool m_startToCloseTimeoutHasBeenSet;
+
+    TaskList m_taskList;
+    bool m_taskListHasBeenSet;
+
+    Aws::String m_taskPriority;
+    bool m_taskPriorityHasBeenSet;
+
+    long long m_decisionTaskCompletedEventId;
+    bool m_decisionTaskCompletedEventIdHasBeenSet;
+
+    Aws::String m_heartbeatTimeout;
+    bool m_heartbeatTimeoutHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ActivityTaskStartedEventAttributes.h

@@ -0,0 +1,129 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>ActivityTaskStarted</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ActivityTaskStartedEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ActivityTaskStartedEventAttributes
+  {
+  public:
+    ActivityTaskStartedEventAttributes();
+    ActivityTaskStartedEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    ActivityTaskStartedEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Identity of the worker that was assigned this task. This aids diagnostics
+     * when problems arise. The form of this identity is user defined.</p>
+     */
+    inline const Aws::String& GetIdentity() const{ return m_identity; }
+
+    /**
+     * <p>Identity of the worker that was assigned this task. This aids diagnostics
+     * when problems arise. The form of this identity is user defined.</p>
+     */
+    inline bool IdentityHasBeenSet() const { return m_identityHasBeenSet; }
+
+    /**
+     * <p>Identity of the worker that was assigned this task. This aids diagnostics
+     * when problems arise. The form of this identity is user defined.</p>
+     */
+    inline void SetIdentity(const Aws::String& value) { m_identityHasBeenSet = true; m_identity = value; }
+
+    /**
+     * <p>Identity of the worker that was assigned this task. This aids diagnostics
+     * when problems arise. The form of this identity is user defined.</p>
+     */
+    inline void SetIdentity(Aws::String&& value) { m_identityHasBeenSet = true; m_identity = std::move(value); }
+
+    /**
+     * <p>Identity of the worker that was assigned this task. This aids diagnostics
+     * when problems arise. The form of this identity is user defined.</p>
+     */
+    inline void SetIdentity(const char* value) { m_identityHasBeenSet = true; m_identity.assign(value); }
+
+    /**
+     * <p>Identity of the worker that was assigned this task. This aids diagnostics
+     * when problems arise. The form of this identity is user defined.</p>
+     */
+    inline ActivityTaskStartedEventAttributes& WithIdentity(const Aws::String& value) { SetIdentity(value); return *this;}
+
+    /**
+     * <p>Identity of the worker that was assigned this task. This aids diagnostics
+     * when problems arise. The form of this identity is user defined.</p>
+     */
+    inline ActivityTaskStartedEventAttributes& WithIdentity(Aws::String&& value) { SetIdentity(std::move(value)); return *this;}
+
+    /**
+     * <p>Identity of the worker that was assigned this task. This aids diagnostics
+     * when problems arise. The form of this identity is user defined.</p>
+     */
+    inline ActivityTaskStartedEventAttributes& WithIdentity(const char* value) { SetIdentity(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>ActivityTaskScheduled</code> event that was recorded when
+     * this activity task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline long long GetScheduledEventId() const{ return m_scheduledEventId; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskScheduled</code> event that was recorded when
+     * this activity task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline bool ScheduledEventIdHasBeenSet() const { return m_scheduledEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskScheduled</code> event that was recorded when
+     * this activity task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline void SetScheduledEventId(long long value) { m_scheduledEventIdHasBeenSet = true; m_scheduledEventId = value; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskScheduled</code> event that was recorded when
+     * this activity task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline ActivityTaskStartedEventAttributes& WithScheduledEventId(long long value) { SetScheduledEventId(value); return *this;}
+
+  private:
+
+    Aws::String m_identity;
+    bool m_identityHasBeenSet;
+
+    long long m_scheduledEventId;
+    bool m_scheduledEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ActivityTaskTimedOutEventAttributes.h

@@ -0,0 +1,196 @@
+/**
+ * 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/model/ActivityTaskTimeoutType.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>ActivityTaskTimedOut</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ActivityTaskTimedOutEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ActivityTaskTimedOutEventAttributes
+  {
+  public:
+    ActivityTaskTimedOutEventAttributes();
+    ActivityTaskTimedOutEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    ActivityTaskTimedOutEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The type of the timeout that caused this event.</p>
+     */
+    inline const ActivityTaskTimeoutType& GetTimeoutType() const{ return m_timeoutType; }
+
+    /**
+     * <p>The type of the timeout that caused this event.</p>
+     */
+    inline bool TimeoutTypeHasBeenSet() const { return m_timeoutTypeHasBeenSet; }
+
+    /**
+     * <p>The type of the timeout that caused this event.</p>
+     */
+    inline void SetTimeoutType(const ActivityTaskTimeoutType& value) { m_timeoutTypeHasBeenSet = true; m_timeoutType = value; }
+
+    /**
+     * <p>The type of the timeout that caused this event.</p>
+     */
+    inline void SetTimeoutType(ActivityTaskTimeoutType&& value) { m_timeoutTypeHasBeenSet = true; m_timeoutType = std::move(value); }
+
+    /**
+     * <p>The type of the timeout that caused this event.</p>
+     */
+    inline ActivityTaskTimedOutEventAttributes& WithTimeoutType(const ActivityTaskTimeoutType& value) { SetTimeoutType(value); return *this;}
+
+    /**
+     * <p>The type of the timeout that caused this event.</p>
+     */
+    inline ActivityTaskTimedOutEventAttributes& WithTimeoutType(ActivityTaskTimeoutType&& value) { SetTimeoutType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>ActivityTaskScheduled</code> event that was recorded when
+     * this activity task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline long long GetScheduledEventId() const{ return m_scheduledEventId; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskScheduled</code> event that was recorded when
+     * this activity task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline bool ScheduledEventIdHasBeenSet() const { return m_scheduledEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskScheduled</code> event that was recorded when
+     * this activity task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline void SetScheduledEventId(long long value) { m_scheduledEventIdHasBeenSet = true; m_scheduledEventId = value; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskScheduled</code> event that was recorded when
+     * this activity task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline ActivityTaskTimedOutEventAttributes& WithScheduledEventId(long long value) { SetScheduledEventId(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event recorded when this
+     * activity task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline long long GetStartedEventId() const{ return m_startedEventId; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event recorded when this
+     * activity task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline bool StartedEventIdHasBeenSet() const { return m_startedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event recorded when this
+     * activity task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline void SetStartedEventId(long long value) { m_startedEventIdHasBeenSet = true; m_startedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event recorded when this
+     * activity task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline ActivityTaskTimedOutEventAttributes& WithStartedEventId(long long value) { SetStartedEventId(value); return *this;}
+
+
+    /**
+     * <p>Contains the content of the <code>details</code> parameter for the last call
+     * made by the activity to <code>RecordActivityTaskHeartbeat</code>.</p>
+     */
+    inline const Aws::String& GetDetails() const{ return m_details; }
+
+    /**
+     * <p>Contains the content of the <code>details</code> parameter for the last call
+     * made by the activity to <code>RecordActivityTaskHeartbeat</code>.</p>
+     */
+    inline bool DetailsHasBeenSet() const { return m_detailsHasBeenSet; }
+
+    /**
+     * <p>Contains the content of the <code>details</code> parameter for the last call
+     * made by the activity to <code>RecordActivityTaskHeartbeat</code>.</p>
+     */
+    inline void SetDetails(const Aws::String& value) { m_detailsHasBeenSet = true; m_details = value; }
+
+    /**
+     * <p>Contains the content of the <code>details</code> parameter for the last call
+     * made by the activity to <code>RecordActivityTaskHeartbeat</code>.</p>
+     */
+    inline void SetDetails(Aws::String&& value) { m_detailsHasBeenSet = true; m_details = std::move(value); }
+
+    /**
+     * <p>Contains the content of the <code>details</code> parameter for the last call
+     * made by the activity to <code>RecordActivityTaskHeartbeat</code>.</p>
+     */
+    inline void SetDetails(const char* value) { m_detailsHasBeenSet = true; m_details.assign(value); }
+
+    /**
+     * <p>Contains the content of the <code>details</code> parameter for the last call
+     * made by the activity to <code>RecordActivityTaskHeartbeat</code>.</p>
+     */
+    inline ActivityTaskTimedOutEventAttributes& WithDetails(const Aws::String& value) { SetDetails(value); return *this;}
+
+    /**
+     * <p>Contains the content of the <code>details</code> parameter for the last call
+     * made by the activity to <code>RecordActivityTaskHeartbeat</code>.</p>
+     */
+    inline ActivityTaskTimedOutEventAttributes& WithDetails(Aws::String&& value) { SetDetails(std::move(value)); return *this;}
+
+    /**
+     * <p>Contains the content of the <code>details</code> parameter for the last call
+     * made by the activity to <code>RecordActivityTaskHeartbeat</code>.</p>
+     */
+    inline ActivityTaskTimedOutEventAttributes& WithDetails(const char* value) { SetDetails(value); return *this;}
+
+  private:
+
+    ActivityTaskTimeoutType m_timeoutType;
+    bool m_timeoutTypeHasBeenSet;
+
+    long long m_scheduledEventId;
+    bool m_scheduledEventIdHasBeenSet;
+
+    long long m_startedEventId;
+    bool m_startedEventIdHasBeenSet;
+
+    Aws::String m_details;
+    bool m_detailsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ActivityTaskTimeoutType.h

@@ -0,0 +1,33 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+  enum class ActivityTaskTimeoutType
+  {
+    NOT_SET,
+    START_TO_CLOSE,
+    SCHEDULE_TO_START,
+    SCHEDULE_TO_CLOSE,
+    HEARTBEAT
+  };
+
+namespace ActivityTaskTimeoutTypeMapper
+{
+AWS_SWF_API ActivityTaskTimeoutType GetActivityTaskTimeoutTypeForName(const Aws::String& name);
+
+AWS_SWF_API Aws::String GetNameForActivityTaskTimeoutType(ActivityTaskTimeoutType value);
+} // namespace ActivityTaskTimeoutTypeMapper
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ActivityType.h

@@ -0,0 +1,148 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents an activity type.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ActivityType">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ActivityType
+  {
+  public:
+    ActivityType();
+    ActivityType(Aws::Utils::Json::JsonView jsonValue);
+    ActivityType& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of this activity.</p>  <p>The combination of activity type
+     * name and version must be unique within a domain.</p> 
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>The name of this activity.</p>  <p>The combination of activity type
+     * name and version must be unique within a domain.</p> 
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>The name of this activity.</p>  <p>The combination of activity type
+     * name and version must be unique within a domain.</p> 
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>The name of this activity.</p>  <p>The combination of activity type
+     * name and version must be unique within a domain.</p> 
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>The name of this activity.</p>  <p>The combination of activity type
+     * name and version must be unique within a domain.</p> 
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>The name of this activity.</p>  <p>The combination of activity type
+     * name and version must be unique within a domain.</p> 
+     */
+    inline ActivityType& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>The name of this activity.</p>  <p>The combination of activity type
+     * name and version must be unique within a domain.</p> 
+     */
+    inline ActivityType& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of this activity.</p>  <p>The combination of activity type
+     * name and version must be unique within a domain.</p> 
+     */
+    inline ActivityType& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>The version of this activity.</p>  <p>The combination of activity type
+     * name and version must be unique with in a domain.</p> 
+     */
+    inline const Aws::String& GetVersion() const{ return m_version; }
+
+    /**
+     * <p>The version of this activity.</p>  <p>The combination of activity type
+     * name and version must be unique with in a domain.</p> 
+     */
+    inline bool VersionHasBeenSet() const { return m_versionHasBeenSet; }
+
+    /**
+     * <p>The version of this activity.</p>  <p>The combination of activity type
+     * name and version must be unique with in a domain.</p> 
+     */
+    inline void SetVersion(const Aws::String& value) { m_versionHasBeenSet = true; m_version = value; }
+
+    /**
+     * <p>The version of this activity.</p>  <p>The combination of activity type
+     * name and version must be unique with in a domain.</p> 
+     */
+    inline void SetVersion(Aws::String&& value) { m_versionHasBeenSet = true; m_version = std::move(value); }
+
+    /**
+     * <p>The version of this activity.</p>  <p>The combination of activity type
+     * name and version must be unique with in a domain.</p> 
+     */
+    inline void SetVersion(const char* value) { m_versionHasBeenSet = true; m_version.assign(value); }
+
+    /**
+     * <p>The version of this activity.</p>  <p>The combination of activity type
+     * name and version must be unique with in a domain.</p> 
+     */
+    inline ActivityType& WithVersion(const Aws::String& value) { SetVersion(value); return *this;}
+
+    /**
+     * <p>The version of this activity.</p>  <p>The combination of activity type
+     * name and version must be unique with in a domain.</p> 
+     */
+    inline ActivityType& WithVersion(Aws::String&& value) { SetVersion(std::move(value)); return *this;}
+
+    /**
+     * <p>The version of this activity.</p>  <p>The combination of activity type
+     * name and version must be unique with in a domain.</p> 
+     */
+    inline ActivityType& WithVersion(const char* value) { SetVersion(value); return *this;}
+
+  private:
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::String m_version;
+    bool m_versionHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ActivityTypeConfiguration.h

@@ -0,0 +1,572 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/TaskList.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Configuration settings registered with the activity type.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ActivityTypeConfiguration">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ActivityTypeConfiguration
+  {
+  public:
+    ActivityTypeConfiguration();
+    ActivityTypeConfiguration(Aws::Utils::Json::JsonView jsonValue);
+    ActivityTypeConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p> The default maximum duration for tasks of an activity type specified when
+     * registering the activity type. You can override this default when scheduling a
+     * task through the <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The
+     * duration is specified in seconds, an integer greater than or equal to
+     * <code>0</code>. You can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline const Aws::String& GetDefaultTaskStartToCloseTimeout() const{ return m_defaultTaskStartToCloseTimeout; }
+
+    /**
+     * <p> The default maximum duration for tasks of an activity type specified when
+     * registering the activity type. You can override this default when scheduling a
+     * task through the <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The
+     * duration is specified in seconds, an integer greater than or equal to
+     * <code>0</code>. You can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline bool DefaultTaskStartToCloseTimeoutHasBeenSet() const { return m_defaultTaskStartToCloseTimeoutHasBeenSet; }
+
+    /**
+     * <p> The default maximum duration for tasks of an activity type specified when
+     * registering the activity type. You can override this default when scheduling a
+     * task through the <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The
+     * duration is specified in seconds, an integer greater than or equal to
+     * <code>0</code>. You can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline void SetDefaultTaskStartToCloseTimeout(const Aws::String& value) { m_defaultTaskStartToCloseTimeoutHasBeenSet = true; m_defaultTaskStartToCloseTimeout = value; }
+
+    /**
+     * <p> The default maximum duration for tasks of an activity type specified when
+     * registering the activity type. You can override this default when scheduling a
+     * task through the <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The
+     * duration is specified in seconds, an integer greater than or equal to
+     * <code>0</code>. You can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline void SetDefaultTaskStartToCloseTimeout(Aws::String&& value) { m_defaultTaskStartToCloseTimeoutHasBeenSet = true; m_defaultTaskStartToCloseTimeout = std::move(value); }
+
+    /**
+     * <p> The default maximum duration for tasks of an activity type specified when
+     * registering the activity type. You can override this default when scheduling a
+     * task through the <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The
+     * duration is specified in seconds, an integer greater than or equal to
+     * <code>0</code>. You can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline void SetDefaultTaskStartToCloseTimeout(const char* value) { m_defaultTaskStartToCloseTimeoutHasBeenSet = true; m_defaultTaskStartToCloseTimeout.assign(value); }
+
+    /**
+     * <p> The default maximum duration for tasks of an activity type specified when
+     * registering the activity type. You can override this default when scheduling a
+     * task through the <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The
+     * duration is specified in seconds, an integer greater than or equal to
+     * <code>0</code>. You can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline ActivityTypeConfiguration& WithDefaultTaskStartToCloseTimeout(const Aws::String& value) { SetDefaultTaskStartToCloseTimeout(value); return *this;}
+
+    /**
+     * <p> The default maximum duration for tasks of an activity type specified when
+     * registering the activity type. You can override this default when scheduling a
+     * task through the <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The
+     * duration is specified in seconds, an integer greater than or equal to
+     * <code>0</code>. You can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline ActivityTypeConfiguration& WithDefaultTaskStartToCloseTimeout(Aws::String&& value) { SetDefaultTaskStartToCloseTimeout(std::move(value)); return *this;}
+
+    /**
+     * <p> The default maximum duration for tasks of an activity type specified when
+     * registering the activity type. You can override this default when scheduling a
+     * task through the <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The
+     * duration is specified in seconds, an integer greater than or equal to
+     * <code>0</code>. You can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline ActivityTypeConfiguration& WithDefaultTaskStartToCloseTimeout(const char* value) { SetDefaultTaskStartToCloseTimeout(value); return *this;}
+
+
+    /**
+     * <p> The default maximum time, in seconds, before which a worker processing a
+     * task must report progress by calling <a>RecordActivityTaskHeartbeat</a>.</p>
+     * <p>You can specify this value only when <i>registering</i> an activity type. The
+     * registered default value can be overridden when you schedule a task through the
+     * <code>ScheduleActivityTask</code> <a>Decision</a>. If the activity worker
+     * subsequently attempts to record a heartbeat or returns a result, the activity
+     * worker receives an <code>UnknownResource</code> fault. In this case, Amazon SWF
+     * no longer considers the activity task to be valid; the activity worker should
+     * clean up the activity task.</p> <p>The duration is specified in seconds, an
+     * integer greater than or equal to <code>0</code>. You can use <code>NONE</code>
+     * to specify unlimited duration.</p>
+     */
+    inline const Aws::String& GetDefaultTaskHeartbeatTimeout() const{ return m_defaultTaskHeartbeatTimeout; }
+
+    /**
+     * <p> The default maximum time, in seconds, before which a worker processing a
+     * task must report progress by calling <a>RecordActivityTaskHeartbeat</a>.</p>
+     * <p>You can specify this value only when <i>registering</i> an activity type. The
+     * registered default value can be overridden when you schedule a task through the
+     * <code>ScheduleActivityTask</code> <a>Decision</a>. If the activity worker
+     * subsequently attempts to record a heartbeat or returns a result, the activity
+     * worker receives an <code>UnknownResource</code> fault. In this case, Amazon SWF
+     * no longer considers the activity task to be valid; the activity worker should
+     * clean up the activity task.</p> <p>The duration is specified in seconds, an
+     * integer greater than or equal to <code>0</code>. You can use <code>NONE</code>
+     * to specify unlimited duration.</p>
+     */
+    inline bool DefaultTaskHeartbeatTimeoutHasBeenSet() const { return m_defaultTaskHeartbeatTimeoutHasBeenSet; }
+
+    /**
+     * <p> The default maximum time, in seconds, before which a worker processing a
+     * task must report progress by calling <a>RecordActivityTaskHeartbeat</a>.</p>
+     * <p>You can specify this value only when <i>registering</i> an activity type. The
+     * registered default value can be overridden when you schedule a task through the
+     * <code>ScheduleActivityTask</code> <a>Decision</a>. If the activity worker
+     * subsequently attempts to record a heartbeat or returns a result, the activity
+     * worker receives an <code>UnknownResource</code> fault. In this case, Amazon SWF
+     * no longer considers the activity task to be valid; the activity worker should
+     * clean up the activity task.</p> <p>The duration is specified in seconds, an
+     * integer greater than or equal to <code>0</code>. You can use <code>NONE</code>
+     * to specify unlimited duration.</p>
+     */
+    inline void SetDefaultTaskHeartbeatTimeout(const Aws::String& value) { m_defaultTaskHeartbeatTimeoutHasBeenSet = true; m_defaultTaskHeartbeatTimeout = value; }
+
+    /**
+     * <p> The default maximum time, in seconds, before which a worker processing a
+     * task must report progress by calling <a>RecordActivityTaskHeartbeat</a>.</p>
+     * <p>You can specify this value only when <i>registering</i> an activity type. The
+     * registered default value can be overridden when you schedule a task through the
+     * <code>ScheduleActivityTask</code> <a>Decision</a>. If the activity worker
+     * subsequently attempts to record a heartbeat or returns a result, the activity
+     * worker receives an <code>UnknownResource</code> fault. In this case, Amazon SWF
+     * no longer considers the activity task to be valid; the activity worker should
+     * clean up the activity task.</p> <p>The duration is specified in seconds, an
+     * integer greater than or equal to <code>0</code>. You can use <code>NONE</code>
+     * to specify unlimited duration.</p>
+     */
+    inline void SetDefaultTaskHeartbeatTimeout(Aws::String&& value) { m_defaultTaskHeartbeatTimeoutHasBeenSet = true; m_defaultTaskHeartbeatTimeout = std::move(value); }
+
+    /**
+     * <p> The default maximum time, in seconds, before which a worker processing a
+     * task must report progress by calling <a>RecordActivityTaskHeartbeat</a>.</p>
+     * <p>You can specify this value only when <i>registering</i> an activity type. The
+     * registered default value can be overridden when you schedule a task through the
+     * <code>ScheduleActivityTask</code> <a>Decision</a>. If the activity worker
+     * subsequently attempts to record a heartbeat or returns a result, the activity
+     * worker receives an <code>UnknownResource</code> fault. In this case, Amazon SWF
+     * no longer considers the activity task to be valid; the activity worker should
+     * clean up the activity task.</p> <p>The duration is specified in seconds, an
+     * integer greater than or equal to <code>0</code>. You can use <code>NONE</code>
+     * to specify unlimited duration.</p>
+     */
+    inline void SetDefaultTaskHeartbeatTimeout(const char* value) { m_defaultTaskHeartbeatTimeoutHasBeenSet = true; m_defaultTaskHeartbeatTimeout.assign(value); }
+
+    /**
+     * <p> The default maximum time, in seconds, before which a worker processing a
+     * task must report progress by calling <a>RecordActivityTaskHeartbeat</a>.</p>
+     * <p>You can specify this value only when <i>registering</i> an activity type. The
+     * registered default value can be overridden when you schedule a task through the
+     * <code>ScheduleActivityTask</code> <a>Decision</a>. If the activity worker
+     * subsequently attempts to record a heartbeat or returns a result, the activity
+     * worker receives an <code>UnknownResource</code> fault. In this case, Amazon SWF
+     * no longer considers the activity task to be valid; the activity worker should
+     * clean up the activity task.</p> <p>The duration is specified in seconds, an
+     * integer greater than or equal to <code>0</code>. You can use <code>NONE</code>
+     * to specify unlimited duration.</p>
+     */
+    inline ActivityTypeConfiguration& WithDefaultTaskHeartbeatTimeout(const Aws::String& value) { SetDefaultTaskHeartbeatTimeout(value); return *this;}
+
+    /**
+     * <p> The default maximum time, in seconds, before which a worker processing a
+     * task must report progress by calling <a>RecordActivityTaskHeartbeat</a>.</p>
+     * <p>You can specify this value only when <i>registering</i> an activity type. The
+     * registered default value can be overridden when you schedule a task through the
+     * <code>ScheduleActivityTask</code> <a>Decision</a>. If the activity worker
+     * subsequently attempts to record a heartbeat or returns a result, the activity
+     * worker receives an <code>UnknownResource</code> fault. In this case, Amazon SWF
+     * no longer considers the activity task to be valid; the activity worker should
+     * clean up the activity task.</p> <p>The duration is specified in seconds, an
+     * integer greater than or equal to <code>0</code>. You can use <code>NONE</code>
+     * to specify unlimited duration.</p>
+     */
+    inline ActivityTypeConfiguration& WithDefaultTaskHeartbeatTimeout(Aws::String&& value) { SetDefaultTaskHeartbeatTimeout(std::move(value)); return *this;}
+
+    /**
+     * <p> The default maximum time, in seconds, before which a worker processing a
+     * task must report progress by calling <a>RecordActivityTaskHeartbeat</a>.</p>
+     * <p>You can specify this value only when <i>registering</i> an activity type. The
+     * registered default value can be overridden when you schedule a task through the
+     * <code>ScheduleActivityTask</code> <a>Decision</a>. If the activity worker
+     * subsequently attempts to record a heartbeat or returns a result, the activity
+     * worker receives an <code>UnknownResource</code> fault. In this case, Amazon SWF
+     * no longer considers the activity task to be valid; the activity worker should
+     * clean up the activity task.</p> <p>The duration is specified in seconds, an
+     * integer greater than or equal to <code>0</code>. You can use <code>NONE</code>
+     * to specify unlimited duration.</p>
+     */
+    inline ActivityTypeConfiguration& WithDefaultTaskHeartbeatTimeout(const char* value) { SetDefaultTaskHeartbeatTimeout(value); return *this;}
+
+
+    /**
+     * <p> The default task list specified for this activity type at registration. This
+     * default is used if a task list isn't provided when a task is scheduled through
+     * the <code>ScheduleActivityTask</code> <a>Decision</a>. You can override the
+     * default registered task list when scheduling a task through the
+     * <code>ScheduleActivityTask</code> <a>Decision</a>.</p>
+     */
+    inline const TaskList& GetDefaultTaskList() const{ return m_defaultTaskList; }
+
+    /**
+     * <p> The default task list specified for this activity type at registration. This
+     * default is used if a task list isn't provided when a task is scheduled through
+     * the <code>ScheduleActivityTask</code> <a>Decision</a>. You can override the
+     * default registered task list when scheduling a task through the
+     * <code>ScheduleActivityTask</code> <a>Decision</a>.</p>
+     */
+    inline bool DefaultTaskListHasBeenSet() const { return m_defaultTaskListHasBeenSet; }
+
+    /**
+     * <p> The default task list specified for this activity type at registration. This
+     * default is used if a task list isn't provided when a task is scheduled through
+     * the <code>ScheduleActivityTask</code> <a>Decision</a>. You can override the
+     * default registered task list when scheduling a task through the
+     * <code>ScheduleActivityTask</code> <a>Decision</a>.</p>
+     */
+    inline void SetDefaultTaskList(const TaskList& value) { m_defaultTaskListHasBeenSet = true; m_defaultTaskList = value; }
+
+    /**
+     * <p> The default task list specified for this activity type at registration. This
+     * default is used if a task list isn't provided when a task is scheduled through
+     * the <code>ScheduleActivityTask</code> <a>Decision</a>. You can override the
+     * default registered task list when scheduling a task through the
+     * <code>ScheduleActivityTask</code> <a>Decision</a>.</p>
+     */
+    inline void SetDefaultTaskList(TaskList&& value) { m_defaultTaskListHasBeenSet = true; m_defaultTaskList = std::move(value); }
+
+    /**
+     * <p> The default task list specified for this activity type at registration. This
+     * default is used if a task list isn't provided when a task is scheduled through
+     * the <code>ScheduleActivityTask</code> <a>Decision</a>. You can override the
+     * default registered task list when scheduling a task through the
+     * <code>ScheduleActivityTask</code> <a>Decision</a>.</p>
+     */
+    inline ActivityTypeConfiguration& WithDefaultTaskList(const TaskList& value) { SetDefaultTaskList(value); return *this;}
+
+    /**
+     * <p> The default task list specified for this activity type at registration. This
+     * default is used if a task list isn't provided when a task is scheduled through
+     * the <code>ScheduleActivityTask</code> <a>Decision</a>. You can override the
+     * default registered task list when scheduling a task through the
+     * <code>ScheduleActivityTask</code> <a>Decision</a>.</p>
+     */
+    inline ActivityTypeConfiguration& WithDefaultTaskList(TaskList&& value) { SetDefaultTaskList(std::move(value)); return *this;}
+
+
+    /**
+     * <p> The default task priority for tasks of this activity type, specified at
+     * registration. If not set, then <code>0</code> is used as the default priority.
+     * This default can be overridden when scheduling an activity task.</p> <p>Valid
+     * values are integers that range from Java's <code>Integer.MIN_VALUE</code>
+     * (-2147483648) to <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers
+     * indicate higher priority.</p> <p>For more information about setting task
+     * priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline const Aws::String& GetDefaultTaskPriority() const{ return m_defaultTaskPriority; }
+
+    /**
+     * <p> The default task priority for tasks of this activity type, specified at
+     * registration. If not set, then <code>0</code> is used as the default priority.
+     * This default can be overridden when scheduling an activity task.</p> <p>Valid
+     * values are integers that range from Java's <code>Integer.MIN_VALUE</code>
+     * (-2147483648) to <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers
+     * indicate higher priority.</p> <p>For more information about setting task
+     * priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline bool DefaultTaskPriorityHasBeenSet() const { return m_defaultTaskPriorityHasBeenSet; }
+
+    /**
+     * <p> The default task priority for tasks of this activity type, specified at
+     * registration. If not set, then <code>0</code> is used as the default priority.
+     * This default can be overridden when scheduling an activity task.</p> <p>Valid
+     * values are integers that range from Java's <code>Integer.MIN_VALUE</code>
+     * (-2147483648) to <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers
+     * indicate higher priority.</p> <p>For more information about setting task
+     * priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline void SetDefaultTaskPriority(const Aws::String& value) { m_defaultTaskPriorityHasBeenSet = true; m_defaultTaskPriority = value; }
+
+    /**
+     * <p> The default task priority for tasks of this activity type, specified at
+     * registration. If not set, then <code>0</code> is used as the default priority.
+     * This default can be overridden when scheduling an activity task.</p> <p>Valid
+     * values are integers that range from Java's <code>Integer.MIN_VALUE</code>
+     * (-2147483648) to <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers
+     * indicate higher priority.</p> <p>For more information about setting task
+     * priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline void SetDefaultTaskPriority(Aws::String&& value) { m_defaultTaskPriorityHasBeenSet = true; m_defaultTaskPriority = std::move(value); }
+
+    /**
+     * <p> The default task priority for tasks of this activity type, specified at
+     * registration. If not set, then <code>0</code> is used as the default priority.
+     * This default can be overridden when scheduling an activity task.</p> <p>Valid
+     * values are integers that range from Java's <code>Integer.MIN_VALUE</code>
+     * (-2147483648) to <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers
+     * indicate higher priority.</p> <p>For more information about setting task
+     * priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline void SetDefaultTaskPriority(const char* value) { m_defaultTaskPriorityHasBeenSet = true; m_defaultTaskPriority.assign(value); }
+
+    /**
+     * <p> The default task priority for tasks of this activity type, specified at
+     * registration. If not set, then <code>0</code> is used as the default priority.
+     * This default can be overridden when scheduling an activity task.</p> <p>Valid
+     * values are integers that range from Java's <code>Integer.MIN_VALUE</code>
+     * (-2147483648) to <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers
+     * indicate higher priority.</p> <p>For more information about setting task
+     * priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline ActivityTypeConfiguration& WithDefaultTaskPriority(const Aws::String& value) { SetDefaultTaskPriority(value); return *this;}
+
+    /**
+     * <p> The default task priority for tasks of this activity type, specified at
+     * registration. If not set, then <code>0</code> is used as the default priority.
+     * This default can be overridden when scheduling an activity task.</p> <p>Valid
+     * values are integers that range from Java's <code>Integer.MIN_VALUE</code>
+     * (-2147483648) to <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers
+     * indicate higher priority.</p> <p>For more information about setting task
+     * priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline ActivityTypeConfiguration& WithDefaultTaskPriority(Aws::String&& value) { SetDefaultTaskPriority(std::move(value)); return *this;}
+
+    /**
+     * <p> The default task priority for tasks of this activity type, specified at
+     * registration. If not set, then <code>0</code> is used as the default priority.
+     * This default can be overridden when scheduling an activity task.</p> <p>Valid
+     * values are integers that range from Java's <code>Integer.MIN_VALUE</code>
+     * (-2147483648) to <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers
+     * indicate higher priority.</p> <p>For more information about setting task
+     * priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline ActivityTypeConfiguration& WithDefaultTaskPriority(const char* value) { SetDefaultTaskPriority(value); return *this;}
+
+
+    /**
+     * <p> The default maximum duration, specified when registering the activity type,
+     * that a task of an activity type can wait before being assigned to a worker. You
+     * can override this default when scheduling a task through the
+     * <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The duration is
+     * specified in seconds, an integer greater than or equal to <code>0</code>. You
+     * can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline const Aws::String& GetDefaultTaskScheduleToStartTimeout() const{ return m_defaultTaskScheduleToStartTimeout; }
+
+    /**
+     * <p> The default maximum duration, specified when registering the activity type,
+     * that a task of an activity type can wait before being assigned to a worker. You
+     * can override this default when scheduling a task through the
+     * <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The duration is
+     * specified in seconds, an integer greater than or equal to <code>0</code>. You
+     * can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline bool DefaultTaskScheduleToStartTimeoutHasBeenSet() const { return m_defaultTaskScheduleToStartTimeoutHasBeenSet; }
+
+    /**
+     * <p> The default maximum duration, specified when registering the activity type,
+     * that a task of an activity type can wait before being assigned to a worker. You
+     * can override this default when scheduling a task through the
+     * <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The duration is
+     * specified in seconds, an integer greater than or equal to <code>0</code>. You
+     * can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline void SetDefaultTaskScheduleToStartTimeout(const Aws::String& value) { m_defaultTaskScheduleToStartTimeoutHasBeenSet = true; m_defaultTaskScheduleToStartTimeout = value; }
+
+    /**
+     * <p> The default maximum duration, specified when registering the activity type,
+     * that a task of an activity type can wait before being assigned to a worker. You
+     * can override this default when scheduling a task through the
+     * <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The duration is
+     * specified in seconds, an integer greater than or equal to <code>0</code>. You
+     * can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline void SetDefaultTaskScheduleToStartTimeout(Aws::String&& value) { m_defaultTaskScheduleToStartTimeoutHasBeenSet = true; m_defaultTaskScheduleToStartTimeout = std::move(value); }
+
+    /**
+     * <p> The default maximum duration, specified when registering the activity type,
+     * that a task of an activity type can wait before being assigned to a worker. You
+     * can override this default when scheduling a task through the
+     * <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The duration is
+     * specified in seconds, an integer greater than or equal to <code>0</code>. You
+     * can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline void SetDefaultTaskScheduleToStartTimeout(const char* value) { m_defaultTaskScheduleToStartTimeoutHasBeenSet = true; m_defaultTaskScheduleToStartTimeout.assign(value); }
+
+    /**
+     * <p> The default maximum duration, specified when registering the activity type,
+     * that a task of an activity type can wait before being assigned to a worker. You
+     * can override this default when scheduling a task through the
+     * <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The duration is
+     * specified in seconds, an integer greater than or equal to <code>0</code>. You
+     * can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline ActivityTypeConfiguration& WithDefaultTaskScheduleToStartTimeout(const Aws::String& value) { SetDefaultTaskScheduleToStartTimeout(value); return *this;}
+
+    /**
+     * <p> The default maximum duration, specified when registering the activity type,
+     * that a task of an activity type can wait before being assigned to a worker. You
+     * can override this default when scheduling a task through the
+     * <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The duration is
+     * specified in seconds, an integer greater than or equal to <code>0</code>. You
+     * can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline ActivityTypeConfiguration& WithDefaultTaskScheduleToStartTimeout(Aws::String&& value) { SetDefaultTaskScheduleToStartTimeout(std::move(value)); return *this;}
+
+    /**
+     * <p> The default maximum duration, specified when registering the activity type,
+     * that a task of an activity type can wait before being assigned to a worker. You
+     * can override this default when scheduling a task through the
+     * <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The duration is
+     * specified in seconds, an integer greater than or equal to <code>0</code>. You
+     * can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline ActivityTypeConfiguration& WithDefaultTaskScheduleToStartTimeout(const char* value) { SetDefaultTaskScheduleToStartTimeout(value); return *this;}
+
+
+    /**
+     * <p> The default maximum duration, specified when registering the activity type,
+     * for tasks of this activity type. You can override this default when scheduling a
+     * task through the <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The
+     * duration is specified in seconds, an integer greater than or equal to
+     * <code>0</code>. You can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline const Aws::String& GetDefaultTaskScheduleToCloseTimeout() const{ return m_defaultTaskScheduleToCloseTimeout; }
+
+    /**
+     * <p> The default maximum duration, specified when registering the activity type,
+     * for tasks of this activity type. You can override this default when scheduling a
+     * task through the <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The
+     * duration is specified in seconds, an integer greater than or equal to
+     * <code>0</code>. You can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline bool DefaultTaskScheduleToCloseTimeoutHasBeenSet() const { return m_defaultTaskScheduleToCloseTimeoutHasBeenSet; }
+
+    /**
+     * <p> The default maximum duration, specified when registering the activity type,
+     * for tasks of this activity type. You can override this default when scheduling a
+     * task through the <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The
+     * duration is specified in seconds, an integer greater than or equal to
+     * <code>0</code>. You can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline void SetDefaultTaskScheduleToCloseTimeout(const Aws::String& value) { m_defaultTaskScheduleToCloseTimeoutHasBeenSet = true; m_defaultTaskScheduleToCloseTimeout = value; }
+
+    /**
+     * <p> The default maximum duration, specified when registering the activity type,
+     * for tasks of this activity type. You can override this default when scheduling a
+     * task through the <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The
+     * duration is specified in seconds, an integer greater than or equal to
+     * <code>0</code>. You can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline void SetDefaultTaskScheduleToCloseTimeout(Aws::String&& value) { m_defaultTaskScheduleToCloseTimeoutHasBeenSet = true; m_defaultTaskScheduleToCloseTimeout = std::move(value); }
+
+    /**
+     * <p> The default maximum duration, specified when registering the activity type,
+     * for tasks of this activity type. You can override this default when scheduling a
+     * task through the <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The
+     * duration is specified in seconds, an integer greater than or equal to
+     * <code>0</code>. You can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline void SetDefaultTaskScheduleToCloseTimeout(const char* value) { m_defaultTaskScheduleToCloseTimeoutHasBeenSet = true; m_defaultTaskScheduleToCloseTimeout.assign(value); }
+
+    /**
+     * <p> The default maximum duration, specified when registering the activity type,
+     * for tasks of this activity type. You can override this default when scheduling a
+     * task through the <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The
+     * duration is specified in seconds, an integer greater than or equal to
+     * <code>0</code>. You can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline ActivityTypeConfiguration& WithDefaultTaskScheduleToCloseTimeout(const Aws::String& value) { SetDefaultTaskScheduleToCloseTimeout(value); return *this;}
+
+    /**
+     * <p> The default maximum duration, specified when registering the activity type,
+     * for tasks of this activity type. You can override this default when scheduling a
+     * task through the <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The
+     * duration is specified in seconds, an integer greater than or equal to
+     * <code>0</code>. You can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline ActivityTypeConfiguration& WithDefaultTaskScheduleToCloseTimeout(Aws::String&& value) { SetDefaultTaskScheduleToCloseTimeout(std::move(value)); return *this;}
+
+    /**
+     * <p> The default maximum duration, specified when registering the activity type,
+     * for tasks of this activity type. You can override this default when scheduling a
+     * task through the <code>ScheduleActivityTask</code> <a>Decision</a>.</p> <p>The
+     * duration is specified in seconds, an integer greater than or equal to
+     * <code>0</code>. You can use <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline ActivityTypeConfiguration& WithDefaultTaskScheduleToCloseTimeout(const char* value) { SetDefaultTaskScheduleToCloseTimeout(value); return *this;}
+
+  private:
+
+    Aws::String m_defaultTaskStartToCloseTimeout;
+    bool m_defaultTaskStartToCloseTimeoutHasBeenSet;
+
+    Aws::String m_defaultTaskHeartbeatTimeout;
+    bool m_defaultTaskHeartbeatTimeoutHasBeenSet;
+
+    TaskList m_defaultTaskList;
+    bool m_defaultTaskListHasBeenSet;
+
+    Aws::String m_defaultTaskPriority;
+    bool m_defaultTaskPriorityHasBeenSet;
+
+    Aws::String m_defaultTaskScheduleToStartTimeout;
+    bool m_defaultTaskScheduleToStartTimeoutHasBeenSet;
+
+    Aws::String m_defaultTaskScheduleToCloseTimeout;
+    bool m_defaultTaskScheduleToCloseTimeoutHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ActivityTypeInfo.h

@@ -0,0 +1,241 @@
+/**
+ * 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/model/ActivityType.h>
+#include <aws/swf/model/RegistrationStatus.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/DateTime.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Detailed information about an activity type.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ActivityTypeInfo">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ActivityTypeInfo
+  {
+  public:
+    ActivityTypeInfo();
+    ActivityTypeInfo(Aws::Utils::Json::JsonView jsonValue);
+    ActivityTypeInfo& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The <a>ActivityType</a> type structure representing the activity type.</p>
+     */
+    inline const ActivityType& GetActivityType() const{ return m_activityType; }
+
+    /**
+     * <p>The <a>ActivityType</a> type structure representing the activity type.</p>
+     */
+    inline bool ActivityTypeHasBeenSet() const { return m_activityTypeHasBeenSet; }
+
+    /**
+     * <p>The <a>ActivityType</a> type structure representing the activity type.</p>
+     */
+    inline void SetActivityType(const ActivityType& value) { m_activityTypeHasBeenSet = true; m_activityType = value; }
+
+    /**
+     * <p>The <a>ActivityType</a> type structure representing the activity type.</p>
+     */
+    inline void SetActivityType(ActivityType&& value) { m_activityTypeHasBeenSet = true; m_activityType = std::move(value); }
+
+    /**
+     * <p>The <a>ActivityType</a> type structure representing the activity type.</p>
+     */
+    inline ActivityTypeInfo& WithActivityType(const ActivityType& value) { SetActivityType(value); return *this;}
+
+    /**
+     * <p>The <a>ActivityType</a> type structure representing the activity type.</p>
+     */
+    inline ActivityTypeInfo& WithActivityType(ActivityType&& value) { SetActivityType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The current status of the activity type.</p>
+     */
+    inline const RegistrationStatus& GetStatus() const{ return m_status; }
+
+    /**
+     * <p>The current status of the activity type.</p>
+     */
+    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
+
+    /**
+     * <p>The current status of the activity type.</p>
+     */
+    inline void SetStatus(const RegistrationStatus& value) { m_statusHasBeenSet = true; m_status = value; }
+
+    /**
+     * <p>The current status of the activity type.</p>
+     */
+    inline void SetStatus(RegistrationStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
+
+    /**
+     * <p>The current status of the activity type.</p>
+     */
+    inline ActivityTypeInfo& WithStatus(const RegistrationStatus& value) { SetStatus(value); return *this;}
+
+    /**
+     * <p>The current status of the activity type.</p>
+     */
+    inline ActivityTypeInfo& WithStatus(RegistrationStatus&& value) { SetStatus(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The description of the activity type provided in
+     * <a>RegisterActivityType</a>.</p>
+     */
+    inline const Aws::String& GetDescription() const{ return m_description; }
+
+    /**
+     * <p>The description of the activity type provided in
+     * <a>RegisterActivityType</a>.</p>
+     */
+    inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
+
+    /**
+     * <p>The description of the activity type provided in
+     * <a>RegisterActivityType</a>.</p>
+     */
+    inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
+
+    /**
+     * <p>The description of the activity type provided in
+     * <a>RegisterActivityType</a>.</p>
+     */
+    inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
+
+    /**
+     * <p>The description of the activity type provided in
+     * <a>RegisterActivityType</a>.</p>
+     */
+    inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
+
+    /**
+     * <p>The description of the activity type provided in
+     * <a>RegisterActivityType</a>.</p>
+     */
+    inline ActivityTypeInfo& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
+
+    /**
+     * <p>The description of the activity type provided in
+     * <a>RegisterActivityType</a>.</p>
+     */
+    inline ActivityTypeInfo& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>The description of the activity type provided in
+     * <a>RegisterActivityType</a>.</p>
+     */
+    inline ActivityTypeInfo& WithDescription(const char* value) { SetDescription(value); return *this;}
+
+
+    /**
+     * <p>The date and time this activity type was created through
+     * <a>RegisterActivityType</a>.</p>
+     */
+    inline const Aws::Utils::DateTime& GetCreationDate() const{ return m_creationDate; }
+
+    /**
+     * <p>The date and time this activity type was created through
+     * <a>RegisterActivityType</a>.</p>
+     */
+    inline bool CreationDateHasBeenSet() const { return m_creationDateHasBeenSet; }
+
+    /**
+     * <p>The date and time this activity type was created through
+     * <a>RegisterActivityType</a>.</p>
+     */
+    inline void SetCreationDate(const Aws::Utils::DateTime& value) { m_creationDateHasBeenSet = true; m_creationDate = value; }
+
+    /**
+     * <p>The date and time this activity type was created through
+     * <a>RegisterActivityType</a>.</p>
+     */
+    inline void SetCreationDate(Aws::Utils::DateTime&& value) { m_creationDateHasBeenSet = true; m_creationDate = std::move(value); }
+
+    /**
+     * <p>The date and time this activity type was created through
+     * <a>RegisterActivityType</a>.</p>
+     */
+    inline ActivityTypeInfo& WithCreationDate(const Aws::Utils::DateTime& value) { SetCreationDate(value); return *this;}
+
+    /**
+     * <p>The date and time this activity type was created through
+     * <a>RegisterActivityType</a>.</p>
+     */
+    inline ActivityTypeInfo& WithCreationDate(Aws::Utils::DateTime&& value) { SetCreationDate(std::move(value)); return *this;}
+
+
+    /**
+     * <p>If DEPRECATED, the date and time <a>DeprecateActivityType</a> was called.</p>
+     */
+    inline const Aws::Utils::DateTime& GetDeprecationDate() const{ return m_deprecationDate; }
+
+    /**
+     * <p>If DEPRECATED, the date and time <a>DeprecateActivityType</a> was called.</p>
+     */
+    inline bool DeprecationDateHasBeenSet() const { return m_deprecationDateHasBeenSet; }
+
+    /**
+     * <p>If DEPRECATED, the date and time <a>DeprecateActivityType</a> was called.</p>
+     */
+    inline void SetDeprecationDate(const Aws::Utils::DateTime& value) { m_deprecationDateHasBeenSet = true; m_deprecationDate = value; }
+
+    /**
+     * <p>If DEPRECATED, the date and time <a>DeprecateActivityType</a> was called.</p>
+     */
+    inline void SetDeprecationDate(Aws::Utils::DateTime&& value) { m_deprecationDateHasBeenSet = true; m_deprecationDate = std::move(value); }
+
+    /**
+     * <p>If DEPRECATED, the date and time <a>DeprecateActivityType</a> was called.</p>
+     */
+    inline ActivityTypeInfo& WithDeprecationDate(const Aws::Utils::DateTime& value) { SetDeprecationDate(value); return *this;}
+
+    /**
+     * <p>If DEPRECATED, the date and time <a>DeprecateActivityType</a> was called.</p>
+     */
+    inline ActivityTypeInfo& WithDeprecationDate(Aws::Utils::DateTime&& value) { SetDeprecationDate(std::move(value)); return *this;}
+
+  private:
+
+    ActivityType m_activityType;
+    bool m_activityTypeHasBeenSet;
+
+    RegistrationStatus m_status;
+    bool m_statusHasBeenSet;
+
+    Aws::String m_description;
+    bool m_descriptionHasBeenSet;
+
+    Aws::Utils::DateTime m_creationDate;
+    bool m_creationDateHasBeenSet;
+
+    Aws::Utils::DateTime m_deprecationDate;
+    bool m_deprecationDateHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/CancelTimerDecisionAttributes.h

@@ -0,0 +1,102 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>CancelTimer</code> decision.</p> <p>
+   * <b>Access Control</b> </p> <p>You can use IAM policies to control this
+   * decision'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/CancelTimerDecisionAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API CancelTimerDecisionAttributes
+  {
+  public:
+    CancelTimerDecisionAttributes();
+    CancelTimerDecisionAttributes(Aws::Utils::Json::JsonView jsonValue);
+    CancelTimerDecisionAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p> The unique ID of the timer to cancel.</p>
+     */
+    inline const Aws::String& GetTimerId() const{ return m_timerId; }
+
+    /**
+     * <p> The unique ID of the timer to cancel.</p>
+     */
+    inline bool TimerIdHasBeenSet() const { return m_timerIdHasBeenSet; }
+
+    /**
+     * <p> The unique ID of the timer to cancel.</p>
+     */
+    inline void SetTimerId(const Aws::String& value) { m_timerIdHasBeenSet = true; m_timerId = value; }
+
+    /**
+     * <p> The unique ID of the timer to cancel.</p>
+     */
+    inline void SetTimerId(Aws::String&& value) { m_timerIdHasBeenSet = true; m_timerId = std::move(value); }
+
+    /**
+     * <p> The unique ID of the timer to cancel.</p>
+     */
+    inline void SetTimerId(const char* value) { m_timerIdHasBeenSet = true; m_timerId.assign(value); }
+
+    /**
+     * <p> The unique ID of the timer to cancel.</p>
+     */
+    inline CancelTimerDecisionAttributes& WithTimerId(const Aws::String& value) { SetTimerId(value); return *this;}
+
+    /**
+     * <p> The unique ID of the timer to cancel.</p>
+     */
+    inline CancelTimerDecisionAttributes& WithTimerId(Aws::String&& value) { SetTimerId(std::move(value)); return *this;}
+
+    /**
+     * <p> The unique ID of the timer to cancel.</p>
+     */
+    inline CancelTimerDecisionAttributes& WithTimerId(const char* value) { SetTimerId(value); return *this;}
+
+  private:
+
+    Aws::String m_timerId;
+    bool m_timerIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/CancelTimerFailedCause.h

@@ -0,0 +1,31 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+  enum class CancelTimerFailedCause
+  {
+    NOT_SET,
+    TIMER_ID_UNKNOWN,
+    OPERATION_NOT_PERMITTED
+  };
+
+namespace CancelTimerFailedCauseMapper
+{
+AWS_SWF_API CancelTimerFailedCause GetCancelTimerFailedCauseForName(const Aws::String& name);
+
+AWS_SWF_API Aws::String GetNameForCancelTimerFailedCause(CancelTimerFailedCause value);
+} // namespace CancelTimerFailedCauseMapper
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/CancelTimerFailedEventAttributes.h

@@ -0,0 +1,204 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/CancelTimerFailedCause.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>CancelTimerFailed</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/CancelTimerFailedEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API CancelTimerFailedEventAttributes
+  {
+  public:
+    CancelTimerFailedEventAttributes();
+    CancelTimerFailedEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    CancelTimerFailedEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The timerId provided in the <code>CancelTimer</code> decision that
+     * failed.</p>
+     */
+    inline const Aws::String& GetTimerId() const{ return m_timerId; }
+
+    /**
+     * <p>The timerId provided in the <code>CancelTimer</code> decision that
+     * failed.</p>
+     */
+    inline bool TimerIdHasBeenSet() const { return m_timerIdHasBeenSet; }
+
+    /**
+     * <p>The timerId provided in the <code>CancelTimer</code> decision that
+     * failed.</p>
+     */
+    inline void SetTimerId(const Aws::String& value) { m_timerIdHasBeenSet = true; m_timerId = value; }
+
+    /**
+     * <p>The timerId provided in the <code>CancelTimer</code> decision that
+     * failed.</p>
+     */
+    inline void SetTimerId(Aws::String&& value) { m_timerIdHasBeenSet = true; m_timerId = std::move(value); }
+
+    /**
+     * <p>The timerId provided in the <code>CancelTimer</code> decision that
+     * failed.</p>
+     */
+    inline void SetTimerId(const char* value) { m_timerIdHasBeenSet = true; m_timerId.assign(value); }
+
+    /**
+     * <p>The timerId provided in the <code>CancelTimer</code> decision that
+     * failed.</p>
+     */
+    inline CancelTimerFailedEventAttributes& WithTimerId(const Aws::String& value) { SetTimerId(value); return *this;}
+
+    /**
+     * <p>The timerId provided in the <code>CancelTimer</code> decision that
+     * failed.</p>
+     */
+    inline CancelTimerFailedEventAttributes& WithTimerId(Aws::String&& value) { SetTimerId(std::move(value)); return *this;}
+
+    /**
+     * <p>The timerId provided in the <code>CancelTimer</code> decision that
+     * failed.</p>
+     */
+    inline CancelTimerFailedEventAttributes& WithTimerId(const char* value) { SetTimerId(value); return *this;}
+
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline const CancelTimerFailedCause& GetCause() const{ return m_cause; }
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline bool CauseHasBeenSet() const { return m_causeHasBeenSet; }
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline void SetCause(const CancelTimerFailedCause& value) { m_causeHasBeenSet = true; m_cause = value; }
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline void SetCause(CancelTimerFailedCause&& value) { m_causeHasBeenSet = true; m_cause = std::move(value); }
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline CancelTimerFailedEventAttributes& WithCause(const CancelTimerFailedCause& value) { SetCause(value); return *this;}
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline CancelTimerFailedEventAttributes& WithCause(CancelTimerFailedCause&& value) { SetCause(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>CancelTimer</code> decision to cancel
+     * this timer. This information can be useful for diagnosing problems by tracing
+     * back the chain of events leading up to this event.</p>
+     */
+    inline long long GetDecisionTaskCompletedEventId() const{ return m_decisionTaskCompletedEventId; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>CancelTimer</code> decision to cancel
+     * this timer. This information can be useful for diagnosing problems by tracing
+     * back the chain of events leading up to this event.</p>
+     */
+    inline bool DecisionTaskCompletedEventIdHasBeenSet() const { return m_decisionTaskCompletedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>CancelTimer</code> decision to cancel
+     * this timer. This information can be useful for diagnosing problems by tracing
+     * back the chain of events leading up to this event.</p>
+     */
+    inline void SetDecisionTaskCompletedEventId(long long value) { m_decisionTaskCompletedEventIdHasBeenSet = true; m_decisionTaskCompletedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>CancelTimer</code> decision to cancel
+     * this timer. This information can be useful for diagnosing problems by tracing
+     * back the chain of events leading up to this event.</p>
+     */
+    inline CancelTimerFailedEventAttributes& WithDecisionTaskCompletedEventId(long long value) { SetDecisionTaskCompletedEventId(value); return *this;}
+
+  private:
+
+    Aws::String m_timerId;
+    bool m_timerIdHasBeenSet;
+
+    CancelTimerFailedCause m_cause;
+    bool m_causeHasBeenSet;
+
+    long long m_decisionTaskCompletedEventId;
+    bool m_decisionTaskCompletedEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/CancelWorkflowExecutionDecisionAttributes.h

@@ -0,0 +1,102 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>CancelWorkflowExecution</code>
+   * decision.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies to
+   * control this decision'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/CancelWorkflowExecutionDecisionAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API CancelWorkflowExecutionDecisionAttributes
+  {
+  public:
+    CancelWorkflowExecutionDecisionAttributes();
+    CancelWorkflowExecutionDecisionAttributes(Aws::Utils::Json::JsonView jsonValue);
+    CancelWorkflowExecutionDecisionAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p> Details of the cancellation.</p>
+     */
+    inline const Aws::String& GetDetails() const{ return m_details; }
+
+    /**
+     * <p> Details of the cancellation.</p>
+     */
+    inline bool DetailsHasBeenSet() const { return m_detailsHasBeenSet; }
+
+    /**
+     * <p> Details of the cancellation.</p>
+     */
+    inline void SetDetails(const Aws::String& value) { m_detailsHasBeenSet = true; m_details = value; }
+
+    /**
+     * <p> Details of the cancellation.</p>
+     */
+    inline void SetDetails(Aws::String&& value) { m_detailsHasBeenSet = true; m_details = std::move(value); }
+
+    /**
+     * <p> Details of the cancellation.</p>
+     */
+    inline void SetDetails(const char* value) { m_detailsHasBeenSet = true; m_details.assign(value); }
+
+    /**
+     * <p> Details of the cancellation.</p>
+     */
+    inline CancelWorkflowExecutionDecisionAttributes& WithDetails(const Aws::String& value) { SetDetails(value); return *this;}
+
+    /**
+     * <p> Details of the cancellation.</p>
+     */
+    inline CancelWorkflowExecutionDecisionAttributes& WithDetails(Aws::String&& value) { SetDetails(std::move(value)); return *this;}
+
+    /**
+     * <p> Details of the cancellation.</p>
+     */
+    inline CancelWorkflowExecutionDecisionAttributes& WithDetails(const char* value) { SetDetails(value); return *this;}
+
+  private:
+
+    Aws::String m_details;
+    bool m_detailsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/CancelWorkflowExecutionFailedCause.h

@@ -0,0 +1,31 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+  enum class CancelWorkflowExecutionFailedCause
+  {
+    NOT_SET,
+    UNHANDLED_DECISION,
+    OPERATION_NOT_PERMITTED
+  };
+
+namespace CancelWorkflowExecutionFailedCauseMapper
+{
+AWS_SWF_API CancelWorkflowExecutionFailedCause GetCancelWorkflowExecutionFailedCauseForName(const Aws::String& name);
+
+AWS_SWF_API Aws::String GetNameForCancelWorkflowExecutionFailedCause(CancelWorkflowExecutionFailedCause value);
+} // namespace CancelWorkflowExecutionFailedCauseMapper
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/CancelWorkflowExecutionFailedEventAttributes.h

@@ -0,0 +1,151 @@
+/**
+ * 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/model/CancelWorkflowExecutionFailedCause.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>CancelWorkflowExecutionFailed</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/CancelWorkflowExecutionFailedEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API CancelWorkflowExecutionFailedEventAttributes
+  {
+  public:
+    CancelWorkflowExecutionFailedEventAttributes();
+    CancelWorkflowExecutionFailedEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    CancelWorkflowExecutionFailedEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline const CancelWorkflowExecutionFailedCause& GetCause() const{ return m_cause; }
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline bool CauseHasBeenSet() const { return m_causeHasBeenSet; }
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline void SetCause(const CancelWorkflowExecutionFailedCause& value) { m_causeHasBeenSet = true; m_cause = value; }
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline void SetCause(CancelWorkflowExecutionFailedCause&& value) { m_causeHasBeenSet = true; m_cause = std::move(value); }
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline CancelWorkflowExecutionFailedEventAttributes& WithCause(const CancelWorkflowExecutionFailedCause& value) { SetCause(value); return *this;}
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline CancelWorkflowExecutionFailedEventAttributes& WithCause(CancelWorkflowExecutionFailedCause&& value) { SetCause(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>CancelWorkflowExecution</code> decision
+     * for this cancellation request. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline long long GetDecisionTaskCompletedEventId() const{ return m_decisionTaskCompletedEventId; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>CancelWorkflowExecution</code> decision
+     * for this cancellation request. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline bool DecisionTaskCompletedEventIdHasBeenSet() const { return m_decisionTaskCompletedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>CancelWorkflowExecution</code> decision
+     * for this cancellation request. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline void SetDecisionTaskCompletedEventId(long long value) { m_decisionTaskCompletedEventIdHasBeenSet = true; m_decisionTaskCompletedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>CancelWorkflowExecution</code> decision
+     * for this cancellation request. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline CancelWorkflowExecutionFailedEventAttributes& WithDecisionTaskCompletedEventId(long long value) { SetDecisionTaskCompletedEventId(value); return *this;}
+
+  private:
+
+    CancelWorkflowExecutionFailedCause m_cause;
+    bool m_causeHasBeenSet;
+
+    long long m_decisionTaskCompletedEventId;
+    bool m_decisionTaskCompletedEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ChildPolicy.h

@@ -0,0 +1,32 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+  enum class ChildPolicy
+  {
+    NOT_SET,
+    TERMINATE,
+    REQUEST_CANCEL,
+    ABANDON
+  };
+
+namespace ChildPolicyMapper
+{
+AWS_SWF_API ChildPolicy GetChildPolicyForName(const Aws::String& name);
+
+AWS_SWF_API Aws::String GetNameForChildPolicy(ChildPolicy value);
+} // namespace ChildPolicyMapper
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ChildWorkflowExecutionCanceledEventAttributes.h

@@ -0,0 +1,235 @@
+/**
+ * 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/model/WorkflowExecution.h>
+#include <aws/swf/model/WorkflowType.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provide details of the <code>ChildWorkflowExecutionCanceled</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ChildWorkflowExecutionCanceledEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ChildWorkflowExecutionCanceledEventAttributes
+  {
+  public:
+    ChildWorkflowExecutionCanceledEventAttributes();
+    ChildWorkflowExecutionCanceledEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    ChildWorkflowExecutionCanceledEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The child workflow execution that was canceled.</p>
+     */
+    inline const WorkflowExecution& GetWorkflowExecution() const{ return m_workflowExecution; }
+
+    /**
+     * <p>The child workflow execution that was canceled.</p>
+     */
+    inline bool WorkflowExecutionHasBeenSet() const { return m_workflowExecutionHasBeenSet; }
+
+    /**
+     * <p>The child workflow execution that was canceled.</p>
+     */
+    inline void SetWorkflowExecution(const WorkflowExecution& value) { m_workflowExecutionHasBeenSet = true; m_workflowExecution = value; }
+
+    /**
+     * <p>The child workflow execution that was canceled.</p>
+     */
+    inline void SetWorkflowExecution(WorkflowExecution&& value) { m_workflowExecutionHasBeenSet = true; m_workflowExecution = std::move(value); }
+
+    /**
+     * <p>The child workflow execution that was canceled.</p>
+     */
+    inline ChildWorkflowExecutionCanceledEventAttributes& WithWorkflowExecution(const WorkflowExecution& value) { SetWorkflowExecution(value); return *this;}
+
+    /**
+     * <p>The child workflow execution that was canceled.</p>
+     */
+    inline ChildWorkflowExecutionCanceledEventAttributes& WithWorkflowExecution(WorkflowExecution&& value) { SetWorkflowExecution(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline const WorkflowType& GetWorkflowType() const{ return m_workflowType; }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline bool WorkflowTypeHasBeenSet() const { return m_workflowTypeHasBeenSet; }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline void SetWorkflowType(const WorkflowType& value) { m_workflowTypeHasBeenSet = true; m_workflowType = value; }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline void SetWorkflowType(WorkflowType&& value) { m_workflowTypeHasBeenSet = true; m_workflowType = std::move(value); }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline ChildWorkflowExecutionCanceledEventAttributes& WithWorkflowType(const WorkflowType& value) { SetWorkflowType(value); return *this;}
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline ChildWorkflowExecutionCanceledEventAttributes& WithWorkflowType(WorkflowType&& value) { SetWorkflowType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Details of the cancellation (if provided).</p>
+     */
+    inline const Aws::String& GetDetails() const{ return m_details; }
+
+    /**
+     * <p>Details of the cancellation (if provided).</p>
+     */
+    inline bool DetailsHasBeenSet() const { return m_detailsHasBeenSet; }
+
+    /**
+     * <p>Details of the cancellation (if provided).</p>
+     */
+    inline void SetDetails(const Aws::String& value) { m_detailsHasBeenSet = true; m_details = value; }
+
+    /**
+     * <p>Details of the cancellation (if provided).</p>
+     */
+    inline void SetDetails(Aws::String&& value) { m_detailsHasBeenSet = true; m_details = std::move(value); }
+
+    /**
+     * <p>Details of the cancellation (if provided).</p>
+     */
+    inline void SetDetails(const char* value) { m_detailsHasBeenSet = true; m_details.assign(value); }
+
+    /**
+     * <p>Details of the cancellation (if provided).</p>
+     */
+    inline ChildWorkflowExecutionCanceledEventAttributes& WithDetails(const Aws::String& value) { SetDetails(value); return *this;}
+
+    /**
+     * <p>Details of the cancellation (if provided).</p>
+     */
+    inline ChildWorkflowExecutionCanceledEventAttributes& WithDetails(Aws::String&& value) { SetDetails(std::move(value)); return *this;}
+
+    /**
+     * <p>Details of the cancellation (if provided).</p>
+     */
+    inline ChildWorkflowExecutionCanceledEventAttributes& WithDetails(const char* value) { SetDetails(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline long long GetInitiatedEventId() const{ return m_initiatedEventId; }
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline bool InitiatedEventIdHasBeenSet() const { return m_initiatedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline void SetInitiatedEventId(long long value) { m_initiatedEventIdHasBeenSet = true; m_initiatedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline ChildWorkflowExecutionCanceledEventAttributes& WithInitiatedEventId(long long value) { SetInitiatedEventId(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>ChildWorkflowExecutionStarted</code> event recorded when
+     * this child workflow execution was started. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline long long GetStartedEventId() const{ return m_startedEventId; }
+
+    /**
+     * <p>The ID of the <code>ChildWorkflowExecutionStarted</code> event recorded when
+     * this child workflow execution was started. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline bool StartedEventIdHasBeenSet() const { return m_startedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>ChildWorkflowExecutionStarted</code> event recorded when
+     * this child workflow execution was started. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline void SetStartedEventId(long long value) { m_startedEventIdHasBeenSet = true; m_startedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>ChildWorkflowExecutionStarted</code> event recorded when
+     * this child workflow execution was started. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline ChildWorkflowExecutionCanceledEventAttributes& WithStartedEventId(long long value) { SetStartedEventId(value); return *this;}
+
+  private:
+
+    WorkflowExecution m_workflowExecution;
+    bool m_workflowExecutionHasBeenSet;
+
+    WorkflowType m_workflowType;
+    bool m_workflowTypeHasBeenSet;
+
+    Aws::String m_details;
+    bool m_detailsHasBeenSet;
+
+    long long m_initiatedEventId;
+    bool m_initiatedEventIdHasBeenSet;
+
+    long long m_startedEventId;
+    bool m_startedEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ChildWorkflowExecutionCompletedEventAttributes.h

@@ -0,0 +1,235 @@
+/**
+ * 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/model/WorkflowExecution.h>
+#include <aws/swf/model/WorkflowType.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>ChildWorkflowExecutionCompleted</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ChildWorkflowExecutionCompletedEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ChildWorkflowExecutionCompletedEventAttributes
+  {
+  public:
+    ChildWorkflowExecutionCompletedEventAttributes();
+    ChildWorkflowExecutionCompletedEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    ChildWorkflowExecutionCompletedEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The child workflow execution that was completed.</p>
+     */
+    inline const WorkflowExecution& GetWorkflowExecution() const{ return m_workflowExecution; }
+
+    /**
+     * <p>The child workflow execution that was completed.</p>
+     */
+    inline bool WorkflowExecutionHasBeenSet() const { return m_workflowExecutionHasBeenSet; }
+
+    /**
+     * <p>The child workflow execution that was completed.</p>
+     */
+    inline void SetWorkflowExecution(const WorkflowExecution& value) { m_workflowExecutionHasBeenSet = true; m_workflowExecution = value; }
+
+    /**
+     * <p>The child workflow execution that was completed.</p>
+     */
+    inline void SetWorkflowExecution(WorkflowExecution&& value) { m_workflowExecutionHasBeenSet = true; m_workflowExecution = std::move(value); }
+
+    /**
+     * <p>The child workflow execution that was completed.</p>
+     */
+    inline ChildWorkflowExecutionCompletedEventAttributes& WithWorkflowExecution(const WorkflowExecution& value) { SetWorkflowExecution(value); return *this;}
+
+    /**
+     * <p>The child workflow execution that was completed.</p>
+     */
+    inline ChildWorkflowExecutionCompletedEventAttributes& WithWorkflowExecution(WorkflowExecution&& value) { SetWorkflowExecution(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline const WorkflowType& GetWorkflowType() const{ return m_workflowType; }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline bool WorkflowTypeHasBeenSet() const { return m_workflowTypeHasBeenSet; }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline void SetWorkflowType(const WorkflowType& value) { m_workflowTypeHasBeenSet = true; m_workflowType = value; }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline void SetWorkflowType(WorkflowType&& value) { m_workflowTypeHasBeenSet = true; m_workflowType = std::move(value); }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline ChildWorkflowExecutionCompletedEventAttributes& WithWorkflowType(const WorkflowType& value) { SetWorkflowType(value); return *this;}
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline ChildWorkflowExecutionCompletedEventAttributes& WithWorkflowType(WorkflowType&& value) { SetWorkflowType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The result of the child workflow execution.</p>
+     */
+    inline const Aws::String& GetResult() const{ return m_result; }
+
+    /**
+     * <p>The result of the child workflow execution.</p>
+     */
+    inline bool ResultHasBeenSet() const { return m_resultHasBeenSet; }
+
+    /**
+     * <p>The result of the child workflow execution.</p>
+     */
+    inline void SetResult(const Aws::String& value) { m_resultHasBeenSet = true; m_result = value; }
+
+    /**
+     * <p>The result of the child workflow execution.</p>
+     */
+    inline void SetResult(Aws::String&& value) { m_resultHasBeenSet = true; m_result = std::move(value); }
+
+    /**
+     * <p>The result of the child workflow execution.</p>
+     */
+    inline void SetResult(const char* value) { m_resultHasBeenSet = true; m_result.assign(value); }
+
+    /**
+     * <p>The result of the child workflow execution.</p>
+     */
+    inline ChildWorkflowExecutionCompletedEventAttributes& WithResult(const Aws::String& value) { SetResult(value); return *this;}
+
+    /**
+     * <p>The result of the child workflow execution.</p>
+     */
+    inline ChildWorkflowExecutionCompletedEventAttributes& WithResult(Aws::String&& value) { SetResult(std::move(value)); return *this;}
+
+    /**
+     * <p>The result of the child workflow execution.</p>
+     */
+    inline ChildWorkflowExecutionCompletedEventAttributes& WithResult(const char* value) { SetResult(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline long long GetInitiatedEventId() const{ return m_initiatedEventId; }
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline bool InitiatedEventIdHasBeenSet() const { return m_initiatedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline void SetInitiatedEventId(long long value) { m_initiatedEventIdHasBeenSet = true; m_initiatedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline ChildWorkflowExecutionCompletedEventAttributes& WithInitiatedEventId(long long value) { SetInitiatedEventId(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>ChildWorkflowExecutionStarted</code> event recorded when
+     * this child workflow execution was started. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline long long GetStartedEventId() const{ return m_startedEventId; }
+
+    /**
+     * <p>The ID of the <code>ChildWorkflowExecutionStarted</code> event recorded when
+     * this child workflow execution was started. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline bool StartedEventIdHasBeenSet() const { return m_startedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>ChildWorkflowExecutionStarted</code> event recorded when
+     * this child workflow execution was started. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline void SetStartedEventId(long long value) { m_startedEventIdHasBeenSet = true; m_startedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>ChildWorkflowExecutionStarted</code> event recorded when
+     * this child workflow execution was started. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline ChildWorkflowExecutionCompletedEventAttributes& WithStartedEventId(long long value) { SetStartedEventId(value); return *this;}
+
+  private:
+
+    WorkflowExecution m_workflowExecution;
+    bool m_workflowExecutionHasBeenSet;
+
+    WorkflowType m_workflowType;
+    bool m_workflowTypeHasBeenSet;
+
+    Aws::String m_result;
+    bool m_resultHasBeenSet;
+
+    long long m_initiatedEventId;
+    bool m_initiatedEventIdHasBeenSet;
+
+    long long m_startedEventId;
+    bool m_startedEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ChildWorkflowExecutionFailedEventAttributes.h

@@ -0,0 +1,279 @@
+/**
+ * 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/model/WorkflowExecution.h>
+#include <aws/swf/model/WorkflowType.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>ChildWorkflowExecutionFailed</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ChildWorkflowExecutionFailedEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ChildWorkflowExecutionFailedEventAttributes
+  {
+  public:
+    ChildWorkflowExecutionFailedEventAttributes();
+    ChildWorkflowExecutionFailedEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    ChildWorkflowExecutionFailedEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The child workflow execution that failed.</p>
+     */
+    inline const WorkflowExecution& GetWorkflowExecution() const{ return m_workflowExecution; }
+
+    /**
+     * <p>The child workflow execution that failed.</p>
+     */
+    inline bool WorkflowExecutionHasBeenSet() const { return m_workflowExecutionHasBeenSet; }
+
+    /**
+     * <p>The child workflow execution that failed.</p>
+     */
+    inline void SetWorkflowExecution(const WorkflowExecution& value) { m_workflowExecutionHasBeenSet = true; m_workflowExecution = value; }
+
+    /**
+     * <p>The child workflow execution that failed.</p>
+     */
+    inline void SetWorkflowExecution(WorkflowExecution&& value) { m_workflowExecutionHasBeenSet = true; m_workflowExecution = std::move(value); }
+
+    /**
+     * <p>The child workflow execution that failed.</p>
+     */
+    inline ChildWorkflowExecutionFailedEventAttributes& WithWorkflowExecution(const WorkflowExecution& value) { SetWorkflowExecution(value); return *this;}
+
+    /**
+     * <p>The child workflow execution that failed.</p>
+     */
+    inline ChildWorkflowExecutionFailedEventAttributes& WithWorkflowExecution(WorkflowExecution&& value) { SetWorkflowExecution(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline const WorkflowType& GetWorkflowType() const{ return m_workflowType; }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline bool WorkflowTypeHasBeenSet() const { return m_workflowTypeHasBeenSet; }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline void SetWorkflowType(const WorkflowType& value) { m_workflowTypeHasBeenSet = true; m_workflowType = value; }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline void SetWorkflowType(WorkflowType&& value) { m_workflowTypeHasBeenSet = true; m_workflowType = std::move(value); }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline ChildWorkflowExecutionFailedEventAttributes& WithWorkflowType(const WorkflowType& value) { SetWorkflowType(value); return *this;}
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline ChildWorkflowExecutionFailedEventAttributes& WithWorkflowType(WorkflowType&& value) { SetWorkflowType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The reason for the failure (if provided).</p>
+     */
+    inline const Aws::String& GetReason() const{ return m_reason; }
+
+    /**
+     * <p>The reason for the failure (if provided).</p>
+     */
+    inline bool ReasonHasBeenSet() const { return m_reasonHasBeenSet; }
+
+    /**
+     * <p>The reason for the failure (if provided).</p>
+     */
+    inline void SetReason(const Aws::String& value) { m_reasonHasBeenSet = true; m_reason = value; }
+
+    /**
+     * <p>The reason for the failure (if provided).</p>
+     */
+    inline void SetReason(Aws::String&& value) { m_reasonHasBeenSet = true; m_reason = std::move(value); }
+
+    /**
+     * <p>The reason for the failure (if provided).</p>
+     */
+    inline void SetReason(const char* value) { m_reasonHasBeenSet = true; m_reason.assign(value); }
+
+    /**
+     * <p>The reason for the failure (if provided).</p>
+     */
+    inline ChildWorkflowExecutionFailedEventAttributes& WithReason(const Aws::String& value) { SetReason(value); return *this;}
+
+    /**
+     * <p>The reason for the failure (if provided).</p>
+     */
+    inline ChildWorkflowExecutionFailedEventAttributes& WithReason(Aws::String&& value) { SetReason(std::move(value)); return *this;}
+
+    /**
+     * <p>The reason for the failure (if provided).</p>
+     */
+    inline ChildWorkflowExecutionFailedEventAttributes& WithReason(const char* value) { SetReason(value); return *this;}
+
+
+    /**
+     * <p>The details of the failure (if provided).</p>
+     */
+    inline const Aws::String& GetDetails() const{ return m_details; }
+
+    /**
+     * <p>The details of the failure (if provided).</p>
+     */
+    inline bool DetailsHasBeenSet() const { return m_detailsHasBeenSet; }
+
+    /**
+     * <p>The details of the failure (if provided).</p>
+     */
+    inline void SetDetails(const Aws::String& value) { m_detailsHasBeenSet = true; m_details = value; }
+
+    /**
+     * <p>The details of the failure (if provided).</p>
+     */
+    inline void SetDetails(Aws::String&& value) { m_detailsHasBeenSet = true; m_details = std::move(value); }
+
+    /**
+     * <p>The details of the failure (if provided).</p>
+     */
+    inline void SetDetails(const char* value) { m_detailsHasBeenSet = true; m_details.assign(value); }
+
+    /**
+     * <p>The details of the failure (if provided).</p>
+     */
+    inline ChildWorkflowExecutionFailedEventAttributes& WithDetails(const Aws::String& value) { SetDetails(value); return *this;}
+
+    /**
+     * <p>The details of the failure (if provided).</p>
+     */
+    inline ChildWorkflowExecutionFailedEventAttributes& WithDetails(Aws::String&& value) { SetDetails(std::move(value)); return *this;}
+
+    /**
+     * <p>The details of the failure (if provided).</p>
+     */
+    inline ChildWorkflowExecutionFailedEventAttributes& WithDetails(const char* value) { SetDetails(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline long long GetInitiatedEventId() const{ return m_initiatedEventId; }
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline bool InitiatedEventIdHasBeenSet() const { return m_initiatedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline void SetInitiatedEventId(long long value) { m_initiatedEventIdHasBeenSet = true; m_initiatedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline ChildWorkflowExecutionFailedEventAttributes& WithInitiatedEventId(long long value) { SetInitiatedEventId(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>ChildWorkflowExecutionStarted</code> event recorded when
+     * this child workflow execution was started. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline long long GetStartedEventId() const{ return m_startedEventId; }
+
+    /**
+     * <p>The ID of the <code>ChildWorkflowExecutionStarted</code> event recorded when
+     * this child workflow execution was started. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline bool StartedEventIdHasBeenSet() const { return m_startedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>ChildWorkflowExecutionStarted</code> event recorded when
+     * this child workflow execution was started. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline void SetStartedEventId(long long value) { m_startedEventIdHasBeenSet = true; m_startedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>ChildWorkflowExecutionStarted</code> event recorded when
+     * this child workflow execution was started. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline ChildWorkflowExecutionFailedEventAttributes& WithStartedEventId(long long value) { SetStartedEventId(value); return *this;}
+
+  private:
+
+    WorkflowExecution m_workflowExecution;
+    bool m_workflowExecutionHasBeenSet;
+
+    WorkflowType m_workflowType;
+    bool m_workflowTypeHasBeenSet;
+
+    Aws::String m_reason;
+    bool m_reasonHasBeenSet;
+
+    Aws::String m_details;
+    bool m_detailsHasBeenSet;
+
+    long long m_initiatedEventId;
+    bool m_initiatedEventIdHasBeenSet;
+
+    long long m_startedEventId;
+    bool m_startedEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ChildWorkflowExecutionStartedEventAttributes.h

@@ -0,0 +1,154 @@
+/**
+ * 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/model/WorkflowExecution.h>
+#include <aws/swf/model/WorkflowType.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>ChildWorkflowExecutionStarted</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ChildWorkflowExecutionStartedEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ChildWorkflowExecutionStartedEventAttributes
+  {
+  public:
+    ChildWorkflowExecutionStartedEventAttributes();
+    ChildWorkflowExecutionStartedEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    ChildWorkflowExecutionStartedEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The child workflow execution that was started.</p>
+     */
+    inline const WorkflowExecution& GetWorkflowExecution() const{ return m_workflowExecution; }
+
+    /**
+     * <p>The child workflow execution that was started.</p>
+     */
+    inline bool WorkflowExecutionHasBeenSet() const { return m_workflowExecutionHasBeenSet; }
+
+    /**
+     * <p>The child workflow execution that was started.</p>
+     */
+    inline void SetWorkflowExecution(const WorkflowExecution& value) { m_workflowExecutionHasBeenSet = true; m_workflowExecution = value; }
+
+    /**
+     * <p>The child workflow execution that was started.</p>
+     */
+    inline void SetWorkflowExecution(WorkflowExecution&& value) { m_workflowExecutionHasBeenSet = true; m_workflowExecution = std::move(value); }
+
+    /**
+     * <p>The child workflow execution that was started.</p>
+     */
+    inline ChildWorkflowExecutionStartedEventAttributes& WithWorkflowExecution(const WorkflowExecution& value) { SetWorkflowExecution(value); return *this;}
+
+    /**
+     * <p>The child workflow execution that was started.</p>
+     */
+    inline ChildWorkflowExecutionStartedEventAttributes& WithWorkflowExecution(WorkflowExecution&& value) { SetWorkflowExecution(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline const WorkflowType& GetWorkflowType() const{ return m_workflowType; }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline bool WorkflowTypeHasBeenSet() const { return m_workflowTypeHasBeenSet; }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline void SetWorkflowType(const WorkflowType& value) { m_workflowTypeHasBeenSet = true; m_workflowType = value; }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline void SetWorkflowType(WorkflowType&& value) { m_workflowTypeHasBeenSet = true; m_workflowType = std::move(value); }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline ChildWorkflowExecutionStartedEventAttributes& WithWorkflowType(const WorkflowType& value) { SetWorkflowType(value); return *this;}
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline ChildWorkflowExecutionStartedEventAttributes& WithWorkflowType(WorkflowType&& value) { SetWorkflowType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline long long GetInitiatedEventId() const{ return m_initiatedEventId; }
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline bool InitiatedEventIdHasBeenSet() const { return m_initiatedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline void SetInitiatedEventId(long long value) { m_initiatedEventIdHasBeenSet = true; m_initiatedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline ChildWorkflowExecutionStartedEventAttributes& WithInitiatedEventId(long long value) { SetInitiatedEventId(value); return *this;}
+
+  private:
+
+    WorkflowExecution m_workflowExecution;
+    bool m_workflowExecutionHasBeenSet;
+
+    WorkflowType m_workflowType;
+    bool m_workflowTypeHasBeenSet;
+
+    long long m_initiatedEventId;
+    bool m_initiatedEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ChildWorkflowExecutionTerminatedEventAttributes.h

@@ -0,0 +1,190 @@
+/**
+ * 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/model/WorkflowExecution.h>
+#include <aws/swf/model/WorkflowType.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>ChildWorkflowExecutionTerminated</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ChildWorkflowExecutionTerminatedEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ChildWorkflowExecutionTerminatedEventAttributes
+  {
+  public:
+    ChildWorkflowExecutionTerminatedEventAttributes();
+    ChildWorkflowExecutionTerminatedEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    ChildWorkflowExecutionTerminatedEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The child workflow execution that was terminated.</p>
+     */
+    inline const WorkflowExecution& GetWorkflowExecution() const{ return m_workflowExecution; }
+
+    /**
+     * <p>The child workflow execution that was terminated.</p>
+     */
+    inline bool WorkflowExecutionHasBeenSet() const { return m_workflowExecutionHasBeenSet; }
+
+    /**
+     * <p>The child workflow execution that was terminated.</p>
+     */
+    inline void SetWorkflowExecution(const WorkflowExecution& value) { m_workflowExecutionHasBeenSet = true; m_workflowExecution = value; }
+
+    /**
+     * <p>The child workflow execution that was terminated.</p>
+     */
+    inline void SetWorkflowExecution(WorkflowExecution&& value) { m_workflowExecutionHasBeenSet = true; m_workflowExecution = std::move(value); }
+
+    /**
+     * <p>The child workflow execution that was terminated.</p>
+     */
+    inline ChildWorkflowExecutionTerminatedEventAttributes& WithWorkflowExecution(const WorkflowExecution& value) { SetWorkflowExecution(value); return *this;}
+
+    /**
+     * <p>The child workflow execution that was terminated.</p>
+     */
+    inline ChildWorkflowExecutionTerminatedEventAttributes& WithWorkflowExecution(WorkflowExecution&& value) { SetWorkflowExecution(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline const WorkflowType& GetWorkflowType() const{ return m_workflowType; }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline bool WorkflowTypeHasBeenSet() const { return m_workflowTypeHasBeenSet; }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline void SetWorkflowType(const WorkflowType& value) { m_workflowTypeHasBeenSet = true; m_workflowType = value; }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline void SetWorkflowType(WorkflowType&& value) { m_workflowTypeHasBeenSet = true; m_workflowType = std::move(value); }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline ChildWorkflowExecutionTerminatedEventAttributes& WithWorkflowType(const WorkflowType& value) { SetWorkflowType(value); return *this;}
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline ChildWorkflowExecutionTerminatedEventAttributes& WithWorkflowType(WorkflowType&& value) { SetWorkflowType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline long long GetInitiatedEventId() const{ return m_initiatedEventId; }
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline bool InitiatedEventIdHasBeenSet() const { return m_initiatedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline void SetInitiatedEventId(long long value) { m_initiatedEventIdHasBeenSet = true; m_initiatedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline ChildWorkflowExecutionTerminatedEventAttributes& WithInitiatedEventId(long long value) { SetInitiatedEventId(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>ChildWorkflowExecutionStarted</code> event recorded when
+     * this child workflow execution was started. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline long long GetStartedEventId() const{ return m_startedEventId; }
+
+    /**
+     * <p>The ID of the <code>ChildWorkflowExecutionStarted</code> event recorded when
+     * this child workflow execution was started. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline bool StartedEventIdHasBeenSet() const { return m_startedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>ChildWorkflowExecutionStarted</code> event recorded when
+     * this child workflow execution was started. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline void SetStartedEventId(long long value) { m_startedEventIdHasBeenSet = true; m_startedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>ChildWorkflowExecutionStarted</code> event recorded when
+     * this child workflow execution was started. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline ChildWorkflowExecutionTerminatedEventAttributes& WithStartedEventId(long long value) { SetStartedEventId(value); return *this;}
+
+  private:
+
+    WorkflowExecution m_workflowExecution;
+    bool m_workflowExecutionHasBeenSet;
+
+    WorkflowType m_workflowType;
+    bool m_workflowTypeHasBeenSet;
+
+    long long m_initiatedEventId;
+    bool m_initiatedEventIdHasBeenSet;
+
+    long long m_startedEventId;
+    bool m_startedEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ChildWorkflowExecutionTimedOutEventAttributes.h

@@ -0,0 +1,231 @@
+/**
+ * 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/model/WorkflowExecution.h>
+#include <aws/swf/model/WorkflowType.h>
+#include <aws/swf/model/WorkflowExecutionTimeoutType.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>ChildWorkflowExecutionTimedOut</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ChildWorkflowExecutionTimedOutEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ChildWorkflowExecutionTimedOutEventAttributes
+  {
+  public:
+    ChildWorkflowExecutionTimedOutEventAttributes();
+    ChildWorkflowExecutionTimedOutEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    ChildWorkflowExecutionTimedOutEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The child workflow execution that timed out.</p>
+     */
+    inline const WorkflowExecution& GetWorkflowExecution() const{ return m_workflowExecution; }
+
+    /**
+     * <p>The child workflow execution that timed out.</p>
+     */
+    inline bool WorkflowExecutionHasBeenSet() const { return m_workflowExecutionHasBeenSet; }
+
+    /**
+     * <p>The child workflow execution that timed out.</p>
+     */
+    inline void SetWorkflowExecution(const WorkflowExecution& value) { m_workflowExecutionHasBeenSet = true; m_workflowExecution = value; }
+
+    /**
+     * <p>The child workflow execution that timed out.</p>
+     */
+    inline void SetWorkflowExecution(WorkflowExecution&& value) { m_workflowExecutionHasBeenSet = true; m_workflowExecution = std::move(value); }
+
+    /**
+     * <p>The child workflow execution that timed out.</p>
+     */
+    inline ChildWorkflowExecutionTimedOutEventAttributes& WithWorkflowExecution(const WorkflowExecution& value) { SetWorkflowExecution(value); return *this;}
+
+    /**
+     * <p>The child workflow execution that timed out.</p>
+     */
+    inline ChildWorkflowExecutionTimedOutEventAttributes& WithWorkflowExecution(WorkflowExecution&& value) { SetWorkflowExecution(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline const WorkflowType& GetWorkflowType() const{ return m_workflowType; }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline bool WorkflowTypeHasBeenSet() const { return m_workflowTypeHasBeenSet; }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline void SetWorkflowType(const WorkflowType& value) { m_workflowTypeHasBeenSet = true; m_workflowType = value; }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline void SetWorkflowType(WorkflowType&& value) { m_workflowTypeHasBeenSet = true; m_workflowType = std::move(value); }
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline ChildWorkflowExecutionTimedOutEventAttributes& WithWorkflowType(const WorkflowType& value) { SetWorkflowType(value); return *this;}
+
+    /**
+     * <p>The type of the child workflow execution.</p>
+     */
+    inline ChildWorkflowExecutionTimedOutEventAttributes& WithWorkflowType(WorkflowType&& value) { SetWorkflowType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The type of the timeout that caused the child workflow execution to time
+     * out.</p>
+     */
+    inline const WorkflowExecutionTimeoutType& GetTimeoutType() const{ return m_timeoutType; }
+
+    /**
+     * <p>The type of the timeout that caused the child workflow execution to time
+     * out.</p>
+     */
+    inline bool TimeoutTypeHasBeenSet() const { return m_timeoutTypeHasBeenSet; }
+
+    /**
+     * <p>The type of the timeout that caused the child workflow execution to time
+     * out.</p>
+     */
+    inline void SetTimeoutType(const WorkflowExecutionTimeoutType& value) { m_timeoutTypeHasBeenSet = true; m_timeoutType = value; }
+
+    /**
+     * <p>The type of the timeout that caused the child workflow execution to time
+     * out.</p>
+     */
+    inline void SetTimeoutType(WorkflowExecutionTimeoutType&& value) { m_timeoutTypeHasBeenSet = true; m_timeoutType = std::move(value); }
+
+    /**
+     * <p>The type of the timeout that caused the child workflow execution to time
+     * out.</p>
+     */
+    inline ChildWorkflowExecutionTimedOutEventAttributes& WithTimeoutType(const WorkflowExecutionTimeoutType& value) { SetTimeoutType(value); return *this;}
+
+    /**
+     * <p>The type of the timeout that caused the child workflow execution to time
+     * out.</p>
+     */
+    inline ChildWorkflowExecutionTimedOutEventAttributes& WithTimeoutType(WorkflowExecutionTimeoutType&& value) { SetTimeoutType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline long long GetInitiatedEventId() const{ return m_initiatedEventId; }
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline bool InitiatedEventIdHasBeenSet() const { return m_initiatedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline void SetInitiatedEventId(long long value) { m_initiatedEventIdHasBeenSet = true; m_initiatedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>StartChildWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>StartChildWorkflowExecution</code> <a>Decision</a> to
+     * start this child workflow execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline ChildWorkflowExecutionTimedOutEventAttributes& WithInitiatedEventId(long long value) { SetInitiatedEventId(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>ChildWorkflowExecutionStarted</code> event recorded when
+     * this child workflow execution was started. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline long long GetStartedEventId() const{ return m_startedEventId; }
+
+    /**
+     * <p>The ID of the <code>ChildWorkflowExecutionStarted</code> event recorded when
+     * this child workflow execution was started. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline bool StartedEventIdHasBeenSet() const { return m_startedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>ChildWorkflowExecutionStarted</code> event recorded when
+     * this child workflow execution was started. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline void SetStartedEventId(long long value) { m_startedEventIdHasBeenSet = true; m_startedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>ChildWorkflowExecutionStarted</code> event recorded when
+     * this child workflow execution was started. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline ChildWorkflowExecutionTimedOutEventAttributes& WithStartedEventId(long long value) { SetStartedEventId(value); return *this;}
+
+  private:
+
+    WorkflowExecution m_workflowExecution;
+    bool m_workflowExecutionHasBeenSet;
+
+    WorkflowType m_workflowType;
+    bool m_workflowTypeHasBeenSet;
+
+    WorkflowExecutionTimeoutType m_timeoutType;
+    bool m_timeoutTypeHasBeenSet;
+
+    long long m_initiatedEventId;
+    bool m_initiatedEventIdHasBeenSet;
+
+    long long m_startedEventId;
+    bool m_startedEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/CloseStatus.h

@@ -0,0 +1,35 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+  enum class CloseStatus
+  {
+    NOT_SET,
+    COMPLETED,
+    FAILED,
+    CANCELED,
+    TERMINATED,
+    CONTINUED_AS_NEW,
+    TIMED_OUT
+  };
+
+namespace CloseStatusMapper
+{
+AWS_SWF_API CloseStatus GetCloseStatusForName(const Aws::String& name);
+
+AWS_SWF_API Aws::String GetNameForCloseStatus(CloseStatus value);
+} // namespace CloseStatusMapper
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/CloseStatusFilter.h

@@ -0,0 +1,85 @@
+/**
+ * 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/model/CloseStatus.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Used to filter the closed workflow executions in visibility APIs by their
+   * close status.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/CloseStatusFilter">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API CloseStatusFilter
+  {
+  public:
+    CloseStatusFilter();
+    CloseStatusFilter(Aws::Utils::Json::JsonView jsonValue);
+    CloseStatusFilter& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p> The close status that must match the close status of an execution for it to
+     * meet the criteria of this filter.</p>
+     */
+    inline const CloseStatus& GetStatus() const{ return m_status; }
+
+    /**
+     * <p> The close status that must match the close status of an execution for it to
+     * meet the criteria of this filter.</p>
+     */
+    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
+
+    /**
+     * <p> The close status that must match the close status of an execution for it to
+     * meet the criteria of this filter.</p>
+     */
+    inline void SetStatus(const CloseStatus& value) { m_statusHasBeenSet = true; m_status = value; }
+
+    /**
+     * <p> The close status that must match the close status of an execution for it to
+     * meet the criteria of this filter.</p>
+     */
+    inline void SetStatus(CloseStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
+
+    /**
+     * <p> The close status that must match the close status of an execution for it to
+     * meet the criteria of this filter.</p>
+     */
+    inline CloseStatusFilter& WithStatus(const CloseStatus& value) { SetStatus(value); return *this;}
+
+    /**
+     * <p> The close status that must match the close status of an execution for it to
+     * meet the criteria of this filter.</p>
+     */
+    inline CloseStatusFilter& WithStatus(CloseStatus&& value) { SetStatus(std::move(value)); return *this;}
+
+  private:
+
+    CloseStatus m_status;
+    bool m_statusHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/CompleteWorkflowExecutionDecisionAttributes.h

@@ -0,0 +1,110 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>CompleteWorkflowExecution</code>
+   * decision.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies to
+   * control this decision'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/CompleteWorkflowExecutionDecisionAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API CompleteWorkflowExecutionDecisionAttributes
+  {
+  public:
+    CompleteWorkflowExecutionDecisionAttributes();
+    CompleteWorkflowExecutionDecisionAttributes(Aws::Utils::Json::JsonView jsonValue);
+    CompleteWorkflowExecutionDecisionAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The result of the workflow execution. The form of the result is
+     * implementation defined.</p>
+     */
+    inline const Aws::String& GetResult() const{ return m_result; }
+
+    /**
+     * <p>The result of the workflow execution. The form of the result is
+     * implementation defined.</p>
+     */
+    inline bool ResultHasBeenSet() const { return m_resultHasBeenSet; }
+
+    /**
+     * <p>The result of the workflow execution. The form of the result is
+     * implementation defined.</p>
+     */
+    inline void SetResult(const Aws::String& value) { m_resultHasBeenSet = true; m_result = value; }
+
+    /**
+     * <p>The result of the workflow execution. The form of the result is
+     * implementation defined.</p>
+     */
+    inline void SetResult(Aws::String&& value) { m_resultHasBeenSet = true; m_result = std::move(value); }
+
+    /**
+     * <p>The result of the workflow execution. The form of the result is
+     * implementation defined.</p>
+     */
+    inline void SetResult(const char* value) { m_resultHasBeenSet = true; m_result.assign(value); }
+
+    /**
+     * <p>The result of the workflow execution. The form of the result is
+     * implementation defined.</p>
+     */
+    inline CompleteWorkflowExecutionDecisionAttributes& WithResult(const Aws::String& value) { SetResult(value); return *this;}
+
+    /**
+     * <p>The result of the workflow execution. The form of the result is
+     * implementation defined.</p>
+     */
+    inline CompleteWorkflowExecutionDecisionAttributes& WithResult(Aws::String&& value) { SetResult(std::move(value)); return *this;}
+
+    /**
+     * <p>The result of the workflow execution. The form of the result is
+     * implementation defined.</p>
+     */
+    inline CompleteWorkflowExecutionDecisionAttributes& WithResult(const char* value) { SetResult(value); return *this;}
+
+  private:
+
+    Aws::String m_result;
+    bool m_resultHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/CompleteWorkflowExecutionFailedCause.h

@@ -0,0 +1,31 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+  enum class CompleteWorkflowExecutionFailedCause
+  {
+    NOT_SET,
+    UNHANDLED_DECISION,
+    OPERATION_NOT_PERMITTED
+  };
+
+namespace CompleteWorkflowExecutionFailedCauseMapper
+{
+AWS_SWF_API CompleteWorkflowExecutionFailedCause GetCompleteWorkflowExecutionFailedCauseForName(const Aws::String& name);
+
+AWS_SWF_API Aws::String GetNameForCompleteWorkflowExecutionFailedCause(CompleteWorkflowExecutionFailedCause value);
+} // namespace CompleteWorkflowExecutionFailedCauseMapper
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/CompleteWorkflowExecutionFailedEventAttributes.h

@@ -0,0 +1,155 @@
+/**
+ * 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/model/CompleteWorkflowExecutionFailedCause.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>CompleteWorkflowExecutionFailed</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/CompleteWorkflowExecutionFailedEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API CompleteWorkflowExecutionFailedEventAttributes
+  {
+  public:
+    CompleteWorkflowExecutionFailedEventAttributes();
+    CompleteWorkflowExecutionFailedEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    CompleteWorkflowExecutionFailedEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline const CompleteWorkflowExecutionFailedCause& GetCause() const{ return m_cause; }
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline bool CauseHasBeenSet() const { return m_causeHasBeenSet; }
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline void SetCause(const CompleteWorkflowExecutionFailedCause& value) { m_causeHasBeenSet = true; m_cause = value; }
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline void SetCause(CompleteWorkflowExecutionFailedCause&& value) { m_causeHasBeenSet = true; m_cause = std::move(value); }
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline CompleteWorkflowExecutionFailedEventAttributes& WithCause(const CompleteWorkflowExecutionFailedCause& value) { SetCause(value); return *this;}
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline CompleteWorkflowExecutionFailedEventAttributes& WithCause(CompleteWorkflowExecutionFailedCause&& value) { SetCause(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>CompleteWorkflowExecution</code>
+     * decision to complete this execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline long long GetDecisionTaskCompletedEventId() const{ return m_decisionTaskCompletedEventId; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>CompleteWorkflowExecution</code>
+     * decision to complete this execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline bool DecisionTaskCompletedEventIdHasBeenSet() const { return m_decisionTaskCompletedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>CompleteWorkflowExecution</code>
+     * decision to complete this execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline void SetDecisionTaskCompletedEventId(long long value) { m_decisionTaskCompletedEventIdHasBeenSet = true; m_decisionTaskCompletedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>CompleteWorkflowExecution</code>
+     * decision to complete this execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline CompleteWorkflowExecutionFailedEventAttributes& WithDecisionTaskCompletedEventId(long long value) { SetDecisionTaskCompletedEventId(value); return *this;}
+
+  private:
+
+    CompleteWorkflowExecutionFailedCause m_cause;
+    bool m_causeHasBeenSet;
+
+    long long m_decisionTaskCompletedEventId;
+    bool m_decisionTaskCompletedEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ContinueAsNewWorkflowExecutionDecisionAttributes.h

@@ -0,0 +1,762 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/TaskList.h>
+#include <aws/swf/model/ChildPolicy.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>ContinueAsNewWorkflowExecution</code>
+   * decision.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies to
+   * control this decision'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>tag</code> – A tag used to identify
+   * the workflow execution</p> </li> <li> <p> <code>taskList</code> – String
+   * constraint. The key is <code>swf:taskList.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/ContinueAsNewWorkflowExecutionDecisionAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ContinueAsNewWorkflowExecutionDecisionAttributes
+  {
+  public:
+    ContinueAsNewWorkflowExecutionDecisionAttributes();
+    ContinueAsNewWorkflowExecutionDecisionAttributes(Aws::Utils::Json::JsonView jsonValue);
+    ContinueAsNewWorkflowExecutionDecisionAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The input provided to the new workflow execution.</p>
+     */
+    inline const Aws::String& GetInput() const{ return m_input; }
+
+    /**
+     * <p>The input provided to the new workflow execution.</p>
+     */
+    inline bool InputHasBeenSet() const { return m_inputHasBeenSet; }
+
+    /**
+     * <p>The input provided to the new workflow execution.</p>
+     */
+    inline void SetInput(const Aws::String& value) { m_inputHasBeenSet = true; m_input = value; }
+
+    /**
+     * <p>The input provided to the new workflow execution.</p>
+     */
+    inline void SetInput(Aws::String&& value) { m_inputHasBeenSet = true; m_input = std::move(value); }
+
+    /**
+     * <p>The input provided to the new workflow execution.</p>
+     */
+    inline void SetInput(const char* value) { m_inputHasBeenSet = true; m_input.assign(value); }
+
+    /**
+     * <p>The input provided to the new workflow execution.</p>
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithInput(const Aws::String& value) { SetInput(value); return *this;}
+
+    /**
+     * <p>The input provided to the new workflow execution.</p>
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithInput(Aws::String&& value) { SetInput(std::move(value)); return *this;}
+
+    /**
+     * <p>The input provided to the new workflow execution.</p>
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithInput(const char* value) { SetInput(value); return *this;}
+
+
+    /**
+     * <p>If set, specifies the total duration for this workflow execution. This
+     * overrides the <code>defaultExecutionStartToCloseTimeout</code> specified when
+     * registering the workflow type.</p> <p>The duration is specified in seconds, an
+     * integer greater than or equal to <code>0</code>. You can use <code>NONE</code>
+     * to specify unlimited duration.</p>  <p>An execution start-to-close timeout
+     * for this workflow execution must be specified either as a default for the
+     * workflow type or through this field. If neither this field is set nor a default
+     * execution start-to-close timeout was specified at registration time then a fault
+     * is returned.</p> 
+     */
+    inline const Aws::String& GetExecutionStartToCloseTimeout() const{ return m_executionStartToCloseTimeout; }
+
+    /**
+     * <p>If set, specifies the total duration for this workflow execution. This
+     * overrides the <code>defaultExecutionStartToCloseTimeout</code> specified when
+     * registering the workflow type.</p> <p>The duration is specified in seconds, an
+     * integer greater than or equal to <code>0</code>. You can use <code>NONE</code>
+     * to specify unlimited duration.</p>  <p>An execution start-to-close timeout
+     * for this workflow execution must be specified either as a default for the
+     * workflow type or through this field. If neither this field is set nor a default
+     * execution start-to-close timeout was specified at registration time then a fault
+     * is returned.</p> 
+     */
+    inline bool ExecutionStartToCloseTimeoutHasBeenSet() const { return m_executionStartToCloseTimeoutHasBeenSet; }
+
+    /**
+     * <p>If set, specifies the total duration for this workflow execution. This
+     * overrides the <code>defaultExecutionStartToCloseTimeout</code> specified when
+     * registering the workflow type.</p> <p>The duration is specified in seconds, an
+     * integer greater than or equal to <code>0</code>. You can use <code>NONE</code>
+     * to specify unlimited duration.</p>  <p>An execution start-to-close timeout
+     * for this workflow execution must be specified either as a default for the
+     * workflow type or through this field. If neither this field is set nor a default
+     * execution start-to-close timeout was specified at registration time then a fault
+     * is returned.</p> 
+     */
+    inline void SetExecutionStartToCloseTimeout(const Aws::String& value) { m_executionStartToCloseTimeoutHasBeenSet = true; m_executionStartToCloseTimeout = value; }
+
+    /**
+     * <p>If set, specifies the total duration for this workflow execution. This
+     * overrides the <code>defaultExecutionStartToCloseTimeout</code> specified when
+     * registering the workflow type.</p> <p>The duration is specified in seconds, an
+     * integer greater than or equal to <code>0</code>. You can use <code>NONE</code>
+     * to specify unlimited duration.</p>  <p>An execution start-to-close timeout
+     * for this workflow execution must be specified either as a default for the
+     * workflow type or through this field. If neither this field is set nor a default
+     * execution start-to-close timeout was specified at registration time then a fault
+     * is returned.</p> 
+     */
+    inline void SetExecutionStartToCloseTimeout(Aws::String&& value) { m_executionStartToCloseTimeoutHasBeenSet = true; m_executionStartToCloseTimeout = std::move(value); }
+
+    /**
+     * <p>If set, specifies the total duration for this workflow execution. This
+     * overrides the <code>defaultExecutionStartToCloseTimeout</code> specified when
+     * registering the workflow type.</p> <p>The duration is specified in seconds, an
+     * integer greater than or equal to <code>0</code>. You can use <code>NONE</code>
+     * to specify unlimited duration.</p>  <p>An execution start-to-close timeout
+     * for this workflow execution must be specified either as a default for the
+     * workflow type or through this field. If neither this field is set nor a default
+     * execution start-to-close timeout was specified at registration time then a fault
+     * is returned.</p> 
+     */
+    inline void SetExecutionStartToCloseTimeout(const char* value) { m_executionStartToCloseTimeoutHasBeenSet = true; m_executionStartToCloseTimeout.assign(value); }
+
+    /**
+     * <p>If set, specifies the total duration for this workflow execution. This
+     * overrides the <code>defaultExecutionStartToCloseTimeout</code> specified when
+     * registering the workflow type.</p> <p>The duration is specified in seconds, an
+     * integer greater than or equal to <code>0</code>. You can use <code>NONE</code>
+     * to specify unlimited duration.</p>  <p>An execution start-to-close timeout
+     * for this workflow execution must be specified either as a default for the
+     * workflow type or through this field. If neither this field is set nor a default
+     * execution start-to-close timeout was specified at registration time then a fault
+     * is returned.</p> 
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithExecutionStartToCloseTimeout(const Aws::String& value) { SetExecutionStartToCloseTimeout(value); return *this;}
+
+    /**
+     * <p>If set, specifies the total duration for this workflow execution. This
+     * overrides the <code>defaultExecutionStartToCloseTimeout</code> specified when
+     * registering the workflow type.</p> <p>The duration is specified in seconds, an
+     * integer greater than or equal to <code>0</code>. You can use <code>NONE</code>
+     * to specify unlimited duration.</p>  <p>An execution start-to-close timeout
+     * for this workflow execution must be specified either as a default for the
+     * workflow type or through this field. If neither this field is set nor a default
+     * execution start-to-close timeout was specified at registration time then a fault
+     * is returned.</p> 
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithExecutionStartToCloseTimeout(Aws::String&& value) { SetExecutionStartToCloseTimeout(std::move(value)); return *this;}
+
+    /**
+     * <p>If set, specifies the total duration for this workflow execution. This
+     * overrides the <code>defaultExecutionStartToCloseTimeout</code> specified when
+     * registering the workflow type.</p> <p>The duration is specified in seconds, an
+     * integer greater than or equal to <code>0</code>. You can use <code>NONE</code>
+     * to specify unlimited duration.</p>  <p>An execution start-to-close timeout
+     * for this workflow execution must be specified either as a default for the
+     * workflow type or through this field. If neither this field is set nor a default
+     * execution start-to-close timeout was specified at registration time then a fault
+     * is returned.</p> 
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithExecutionStartToCloseTimeout(const char* value) { SetExecutionStartToCloseTimeout(value); return *this;}
+
+
+    /**
+     * <p>The task list to use for the decisions of the new (continued) workflow
+     * execution.</p>
+     */
+    inline const TaskList& GetTaskList() const{ return m_taskList; }
+
+    /**
+     * <p>The task list to use for the decisions of the new (continued) workflow
+     * execution.</p>
+     */
+    inline bool TaskListHasBeenSet() const { return m_taskListHasBeenSet; }
+
+    /**
+     * <p>The task list to use for the decisions of the new (continued) workflow
+     * execution.</p>
+     */
+    inline void SetTaskList(const TaskList& value) { m_taskListHasBeenSet = true; m_taskList = value; }
+
+    /**
+     * <p>The task list to use for the decisions of the new (continued) workflow
+     * execution.</p>
+     */
+    inline void SetTaskList(TaskList&& value) { m_taskListHasBeenSet = true; m_taskList = std::move(value); }
+
+    /**
+     * <p>The task list to use for the decisions of the new (continued) workflow
+     * execution.</p>
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithTaskList(const TaskList& value) { SetTaskList(value); return *this;}
+
+    /**
+     * <p>The task list to use for the decisions of the new (continued) workflow
+     * execution.</p>
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithTaskList(TaskList&& value) { SetTaskList(std::move(value)); return *this;}
+
+
+    /**
+     * <p> The task priority that, if set, specifies the priority for the decision
+     * tasks for this workflow execution. This overrides the defaultTaskPriority
+     * specified when registering the workflow type. Valid values are integers that
+     * range from Java's <code>Integer.MIN_VALUE</code> (-2147483648) to
+     * <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers indicate higher
+     * priority.</p> <p>For more information about setting task priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline const Aws::String& GetTaskPriority() const{ return m_taskPriority; }
+
+    /**
+     * <p> The task priority that, if set, specifies the priority for the decision
+     * tasks for this workflow execution. This overrides the defaultTaskPriority
+     * specified when registering the workflow type. Valid values are integers that
+     * range from Java's <code>Integer.MIN_VALUE</code> (-2147483648) to
+     * <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers indicate higher
+     * priority.</p> <p>For more information about setting task priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline bool TaskPriorityHasBeenSet() const { return m_taskPriorityHasBeenSet; }
+
+    /**
+     * <p> The task priority that, if set, specifies the priority for the decision
+     * tasks for this workflow execution. This overrides the defaultTaskPriority
+     * specified when registering the workflow type. Valid values are integers that
+     * range from Java's <code>Integer.MIN_VALUE</code> (-2147483648) to
+     * <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers indicate higher
+     * priority.</p> <p>For more information about setting task priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline void SetTaskPriority(const Aws::String& value) { m_taskPriorityHasBeenSet = true; m_taskPriority = value; }
+
+    /**
+     * <p> The task priority that, if set, specifies the priority for the decision
+     * tasks for this workflow execution. This overrides the defaultTaskPriority
+     * specified when registering the workflow type. Valid values are integers that
+     * range from Java's <code>Integer.MIN_VALUE</code> (-2147483648) to
+     * <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers indicate higher
+     * priority.</p> <p>For more information about setting task priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline void SetTaskPriority(Aws::String&& value) { m_taskPriorityHasBeenSet = true; m_taskPriority = std::move(value); }
+
+    /**
+     * <p> The task priority that, if set, specifies the priority for the decision
+     * tasks for this workflow execution. This overrides the defaultTaskPriority
+     * specified when registering the workflow type. Valid values are integers that
+     * range from Java's <code>Integer.MIN_VALUE</code> (-2147483648) to
+     * <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers indicate higher
+     * priority.</p> <p>For more information about setting task priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline void SetTaskPriority(const char* value) { m_taskPriorityHasBeenSet = true; m_taskPriority.assign(value); }
+
+    /**
+     * <p> The task priority that, if set, specifies the priority for the decision
+     * tasks for this workflow execution. This overrides the defaultTaskPriority
+     * specified when registering the workflow type. Valid values are integers that
+     * range from Java's <code>Integer.MIN_VALUE</code> (-2147483648) to
+     * <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers indicate higher
+     * priority.</p> <p>For more information about setting task priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithTaskPriority(const Aws::String& value) { SetTaskPriority(value); return *this;}
+
+    /**
+     * <p> The task priority that, if set, specifies the priority for the decision
+     * tasks for this workflow execution. This overrides the defaultTaskPriority
+     * specified when registering the workflow type. Valid values are integers that
+     * range from Java's <code>Integer.MIN_VALUE</code> (-2147483648) to
+     * <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers indicate higher
+     * priority.</p> <p>For more information about setting task priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithTaskPriority(Aws::String&& value) { SetTaskPriority(std::move(value)); return *this;}
+
+    /**
+     * <p> The task priority that, if set, specifies the priority for the decision
+     * tasks for this workflow execution. This overrides the defaultTaskPriority
+     * specified when registering the workflow type. Valid values are integers that
+     * range from Java's <code>Integer.MIN_VALUE</code> (-2147483648) to
+     * <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers indicate higher
+     * priority.</p> <p>For more information about setting task priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithTaskPriority(const char* value) { SetTaskPriority(value); return *this;}
+
+
+    /**
+     * <p>Specifies the maximum duration of decision tasks for the new workflow
+     * execution. This parameter overrides the
+     * <code>defaultTaskStartToCloseTimout</code> specified when registering the
+     * workflow type using <a>RegisterWorkflowType</a>.</p> <p>The duration is
+     * specified in seconds, an integer greater than or equal to <code>0</code>. You
+     * can use <code>NONE</code> to specify unlimited duration.</p>  <p>A task
+     * start-to-close timeout for the new workflow execution must be specified either
+     * as a default for the workflow type or through this parameter. If neither this
+     * parameter is set nor a default task start-to-close timeout was specified at
+     * registration time then a fault is returned.</p> 
+     */
+    inline const Aws::String& GetTaskStartToCloseTimeout() const{ return m_taskStartToCloseTimeout; }
+
+    /**
+     * <p>Specifies the maximum duration of decision tasks for the new workflow
+     * execution. This parameter overrides the
+     * <code>defaultTaskStartToCloseTimout</code> specified when registering the
+     * workflow type using <a>RegisterWorkflowType</a>.</p> <p>The duration is
+     * specified in seconds, an integer greater than or equal to <code>0</code>. You
+     * can use <code>NONE</code> to specify unlimited duration.</p>  <p>A task
+     * start-to-close timeout for the new workflow execution must be specified either
+     * as a default for the workflow type or through this parameter. If neither this
+     * parameter is set nor a default task start-to-close timeout was specified at
+     * registration time then a fault is returned.</p> 
+     */
+    inline bool TaskStartToCloseTimeoutHasBeenSet() const { return m_taskStartToCloseTimeoutHasBeenSet; }
+
+    /**
+     * <p>Specifies the maximum duration of decision tasks for the new workflow
+     * execution. This parameter overrides the
+     * <code>defaultTaskStartToCloseTimout</code> specified when registering the
+     * workflow type using <a>RegisterWorkflowType</a>.</p> <p>The duration is
+     * specified in seconds, an integer greater than or equal to <code>0</code>. You
+     * can use <code>NONE</code> to specify unlimited duration.</p>  <p>A task
+     * start-to-close timeout for the new workflow execution must be specified either
+     * as a default for the workflow type or through this parameter. If neither this
+     * parameter is set nor a default task start-to-close timeout was specified at
+     * registration time then a fault is returned.</p> 
+     */
+    inline void SetTaskStartToCloseTimeout(const Aws::String& value) { m_taskStartToCloseTimeoutHasBeenSet = true; m_taskStartToCloseTimeout = value; }
+
+    /**
+     * <p>Specifies the maximum duration of decision tasks for the new workflow
+     * execution. This parameter overrides the
+     * <code>defaultTaskStartToCloseTimout</code> specified when registering the
+     * workflow type using <a>RegisterWorkflowType</a>.</p> <p>The duration is
+     * specified in seconds, an integer greater than or equal to <code>0</code>. You
+     * can use <code>NONE</code> to specify unlimited duration.</p>  <p>A task
+     * start-to-close timeout for the new workflow execution must be specified either
+     * as a default for the workflow type or through this parameter. If neither this
+     * parameter is set nor a default task start-to-close timeout was specified at
+     * registration time then a fault is returned.</p> 
+     */
+    inline void SetTaskStartToCloseTimeout(Aws::String&& value) { m_taskStartToCloseTimeoutHasBeenSet = true; m_taskStartToCloseTimeout = std::move(value); }
+
+    /**
+     * <p>Specifies the maximum duration of decision tasks for the new workflow
+     * execution. This parameter overrides the
+     * <code>defaultTaskStartToCloseTimout</code> specified when registering the
+     * workflow type using <a>RegisterWorkflowType</a>.</p> <p>The duration is
+     * specified in seconds, an integer greater than or equal to <code>0</code>. You
+     * can use <code>NONE</code> to specify unlimited duration.</p>  <p>A task
+     * start-to-close timeout for the new workflow execution must be specified either
+     * as a default for the workflow type or through this parameter. If neither this
+     * parameter is set nor a default task start-to-close timeout was specified at
+     * registration time then a fault is returned.</p> 
+     */
+    inline void SetTaskStartToCloseTimeout(const char* value) { m_taskStartToCloseTimeoutHasBeenSet = true; m_taskStartToCloseTimeout.assign(value); }
+
+    /**
+     * <p>Specifies the maximum duration of decision tasks for the new workflow
+     * execution. This parameter overrides the
+     * <code>defaultTaskStartToCloseTimout</code> specified when registering the
+     * workflow type using <a>RegisterWorkflowType</a>.</p> <p>The duration is
+     * specified in seconds, an integer greater than or equal to <code>0</code>. You
+     * can use <code>NONE</code> to specify unlimited duration.</p>  <p>A task
+     * start-to-close timeout for the new workflow execution must be specified either
+     * as a default for the workflow type or through this parameter. If neither this
+     * parameter is set nor a default task start-to-close timeout was specified at
+     * registration time then a fault is returned.</p> 
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithTaskStartToCloseTimeout(const Aws::String& value) { SetTaskStartToCloseTimeout(value); return *this;}
+
+    /**
+     * <p>Specifies the maximum duration of decision tasks for the new workflow
+     * execution. This parameter overrides the
+     * <code>defaultTaskStartToCloseTimout</code> specified when registering the
+     * workflow type using <a>RegisterWorkflowType</a>.</p> <p>The duration is
+     * specified in seconds, an integer greater than or equal to <code>0</code>. You
+     * can use <code>NONE</code> to specify unlimited duration.</p>  <p>A task
+     * start-to-close timeout for the new workflow execution must be specified either
+     * as a default for the workflow type or through this parameter. If neither this
+     * parameter is set nor a default task start-to-close timeout was specified at
+     * registration time then a fault is returned.</p> 
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithTaskStartToCloseTimeout(Aws::String&& value) { SetTaskStartToCloseTimeout(std::move(value)); return *this;}
+
+    /**
+     * <p>Specifies the maximum duration of decision tasks for the new workflow
+     * execution. This parameter overrides the
+     * <code>defaultTaskStartToCloseTimout</code> specified when registering the
+     * workflow type using <a>RegisterWorkflowType</a>.</p> <p>The duration is
+     * specified in seconds, an integer greater than or equal to <code>0</code>. You
+     * can use <code>NONE</code> to specify unlimited duration.</p>  <p>A task
+     * start-to-close timeout for the new workflow execution must be specified either
+     * as a default for the workflow type or through this parameter. If neither this
+     * parameter is set nor a default task start-to-close timeout was specified at
+     * registration time then a fault is returned.</p> 
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithTaskStartToCloseTimeout(const char* value) { SetTaskStartToCloseTimeout(value); return *this;}
+
+
+    /**
+     * <p>If set, specifies the policy to use for the child workflow executions of the
+     * new execution if it is terminated by calling the
+     * <a>TerminateWorkflowExecution</a> action explicitly or due to an expired
+     * timeout. This policy overrides the default child policy specified when
+     * registering the workflow type using <a>RegisterWorkflowType</a>.</p> <p>The
+     * supported child policies are:</p> <ul> <li> <p> <code>TERMINATE</code> – The
+     * child executions are terminated.</p> </li> <li> <p> <code>REQUEST_CANCEL</code>
+     * – A request to cancel is attempted for each child execution by recording a
+     * <code>WorkflowExecutionCancelRequested</code> event in its history. It is up to
+     * the decider to take appropriate actions when it receives an execution history
+     * with this event.</p> </li> <li> <p> <code>ABANDON</code> – No action is taken.
+     * The child executions continue to run.</p> </li> </ul>  <p>A child policy
+     * for this workflow execution must be specified either as a default for the
+     * workflow type or through this parameter. If neither this parameter is set nor a
+     * default child policy was specified at registration time then a fault is
+     * returned.</p> 
+     */
+    inline const ChildPolicy& GetChildPolicy() const{ return m_childPolicy; }
+
+    /**
+     * <p>If set, specifies the policy to use for the child workflow executions of the
+     * new execution if it is terminated by calling the
+     * <a>TerminateWorkflowExecution</a> action explicitly or due to an expired
+     * timeout. This policy overrides the default child policy specified when
+     * registering the workflow type using <a>RegisterWorkflowType</a>.</p> <p>The
+     * supported child policies are:</p> <ul> <li> <p> <code>TERMINATE</code> – The
+     * child executions are terminated.</p> </li> <li> <p> <code>REQUEST_CANCEL</code>
+     * – A request to cancel is attempted for each child execution by recording a
+     * <code>WorkflowExecutionCancelRequested</code> event in its history. It is up to
+     * the decider to take appropriate actions when it receives an execution history
+     * with this event.</p> </li> <li> <p> <code>ABANDON</code> – No action is taken.
+     * The child executions continue to run.</p> </li> </ul>  <p>A child policy
+     * for this workflow execution must be specified either as a default for the
+     * workflow type or through this parameter. If neither this parameter is set nor a
+     * default child policy was specified at registration time then a fault is
+     * returned.</p> 
+     */
+    inline bool ChildPolicyHasBeenSet() const { return m_childPolicyHasBeenSet; }
+
+    /**
+     * <p>If set, specifies the policy to use for the child workflow executions of the
+     * new execution if it is terminated by calling the
+     * <a>TerminateWorkflowExecution</a> action explicitly or due to an expired
+     * timeout. This policy overrides the default child policy specified when
+     * registering the workflow type using <a>RegisterWorkflowType</a>.</p> <p>The
+     * supported child policies are:</p> <ul> <li> <p> <code>TERMINATE</code> – The
+     * child executions are terminated.</p> </li> <li> <p> <code>REQUEST_CANCEL</code>
+     * – A request to cancel is attempted for each child execution by recording a
+     * <code>WorkflowExecutionCancelRequested</code> event in its history. It is up to
+     * the decider to take appropriate actions when it receives an execution history
+     * with this event.</p> </li> <li> <p> <code>ABANDON</code> – No action is taken.
+     * The child executions continue to run.</p> </li> </ul>  <p>A child policy
+     * for this workflow execution must be specified either as a default for the
+     * workflow type or through this parameter. If neither this parameter is set nor a
+     * default child policy was specified at registration time then a fault is
+     * returned.</p> 
+     */
+    inline void SetChildPolicy(const ChildPolicy& value) { m_childPolicyHasBeenSet = true; m_childPolicy = value; }
+
+    /**
+     * <p>If set, specifies the policy to use for the child workflow executions of the
+     * new execution if it is terminated by calling the
+     * <a>TerminateWorkflowExecution</a> action explicitly or due to an expired
+     * timeout. This policy overrides the default child policy specified when
+     * registering the workflow type using <a>RegisterWorkflowType</a>.</p> <p>The
+     * supported child policies are:</p> <ul> <li> <p> <code>TERMINATE</code> – The
+     * child executions are terminated.</p> </li> <li> <p> <code>REQUEST_CANCEL</code>
+     * – A request to cancel is attempted for each child execution by recording a
+     * <code>WorkflowExecutionCancelRequested</code> event in its history. It is up to
+     * the decider to take appropriate actions when it receives an execution history
+     * with this event.</p> </li> <li> <p> <code>ABANDON</code> – No action is taken.
+     * The child executions continue to run.</p> </li> </ul>  <p>A child policy
+     * for this workflow execution must be specified either as a default for the
+     * workflow type or through this parameter. If neither this parameter is set nor a
+     * default child policy was specified at registration time then a fault is
+     * returned.</p> 
+     */
+    inline void SetChildPolicy(ChildPolicy&& value) { m_childPolicyHasBeenSet = true; m_childPolicy = std::move(value); }
+
+    /**
+     * <p>If set, specifies the policy to use for the child workflow executions of the
+     * new execution if it is terminated by calling the
+     * <a>TerminateWorkflowExecution</a> action explicitly or due to an expired
+     * timeout. This policy overrides the default child policy specified when
+     * registering the workflow type using <a>RegisterWorkflowType</a>.</p> <p>The
+     * supported child policies are:</p> <ul> <li> <p> <code>TERMINATE</code> – The
+     * child executions are terminated.</p> </li> <li> <p> <code>REQUEST_CANCEL</code>
+     * – A request to cancel is attempted for each child execution by recording a
+     * <code>WorkflowExecutionCancelRequested</code> event in its history. It is up to
+     * the decider to take appropriate actions when it receives an execution history
+     * with this event.</p> </li> <li> <p> <code>ABANDON</code> – No action is taken.
+     * The child executions continue to run.</p> </li> </ul>  <p>A child policy
+     * for this workflow execution must be specified either as a default for the
+     * workflow type or through this parameter. If neither this parameter is set nor a
+     * default child policy was specified at registration time then a fault is
+     * returned.</p> 
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithChildPolicy(const ChildPolicy& value) { SetChildPolicy(value); return *this;}
+
+    /**
+     * <p>If set, specifies the policy to use for the child workflow executions of the
+     * new execution if it is terminated by calling the
+     * <a>TerminateWorkflowExecution</a> action explicitly or due to an expired
+     * timeout. This policy overrides the default child policy specified when
+     * registering the workflow type using <a>RegisterWorkflowType</a>.</p> <p>The
+     * supported child policies are:</p> <ul> <li> <p> <code>TERMINATE</code> – The
+     * child executions are terminated.</p> </li> <li> <p> <code>REQUEST_CANCEL</code>
+     * – A request to cancel is attempted for each child execution by recording a
+     * <code>WorkflowExecutionCancelRequested</code> event in its history. It is up to
+     * the decider to take appropriate actions when it receives an execution history
+     * with this event.</p> </li> <li> <p> <code>ABANDON</code> – No action is taken.
+     * The child executions continue to run.</p> </li> </ul>  <p>A child policy
+     * for this workflow execution must be specified either as a default for the
+     * workflow type or through this parameter. If neither this parameter is set nor a
+     * default child policy was specified at registration time then a fault is
+     * returned.</p> 
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithChildPolicy(ChildPolicy&& value) { SetChildPolicy(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The list of tags to associate with the new workflow execution. A maximum of 5
+     * tags can be specified. You can list workflow executions with a specific tag by
+     * calling <a>ListOpenWorkflowExecutions</a> or <a>ListClosedWorkflowExecutions</a>
+     * and specifying a <a>TagFilter</a>.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetTagList() const{ return m_tagList; }
+
+    /**
+     * <p>The list of tags to associate with the new workflow execution. A maximum of 5
+     * tags can be specified. You can list workflow executions with a specific tag by
+     * calling <a>ListOpenWorkflowExecutions</a> or <a>ListClosedWorkflowExecutions</a>
+     * and specifying a <a>TagFilter</a>.</p>
+     */
+    inline bool TagListHasBeenSet() const { return m_tagListHasBeenSet; }
+
+    /**
+     * <p>The list of tags to associate with the new workflow execution. A maximum of 5
+     * tags can be specified. You can list workflow executions with a specific tag by
+     * calling <a>ListOpenWorkflowExecutions</a> or <a>ListClosedWorkflowExecutions</a>
+     * and specifying a <a>TagFilter</a>.</p>
+     */
+    inline void SetTagList(const Aws::Vector<Aws::String>& value) { m_tagListHasBeenSet = true; m_tagList = value; }
+
+    /**
+     * <p>The list of tags to associate with the new workflow execution. A maximum of 5
+     * tags can be specified. You can list workflow executions with a specific tag by
+     * calling <a>ListOpenWorkflowExecutions</a> or <a>ListClosedWorkflowExecutions</a>
+     * and specifying a <a>TagFilter</a>.</p>
+     */
+    inline void SetTagList(Aws::Vector<Aws::String>&& value) { m_tagListHasBeenSet = true; m_tagList = std::move(value); }
+
+    /**
+     * <p>The list of tags to associate with the new workflow execution. A maximum of 5
+     * tags can be specified. You can list workflow executions with a specific tag by
+     * calling <a>ListOpenWorkflowExecutions</a> or <a>ListClosedWorkflowExecutions</a>
+     * and specifying a <a>TagFilter</a>.</p>
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithTagList(const Aws::Vector<Aws::String>& value) { SetTagList(value); return *this;}
+
+    /**
+     * <p>The list of tags to associate with the new workflow execution. A maximum of 5
+     * tags can be specified. You can list workflow executions with a specific tag by
+     * calling <a>ListOpenWorkflowExecutions</a> or <a>ListClosedWorkflowExecutions</a>
+     * and specifying a <a>TagFilter</a>.</p>
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithTagList(Aws::Vector<Aws::String>&& value) { SetTagList(std::move(value)); return *this;}
+
+    /**
+     * <p>The list of tags to associate with the new workflow execution. A maximum of 5
+     * tags can be specified. You can list workflow executions with a specific tag by
+     * calling <a>ListOpenWorkflowExecutions</a> or <a>ListClosedWorkflowExecutions</a>
+     * and specifying a <a>TagFilter</a>.</p>
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& AddTagList(const Aws::String& value) { m_tagListHasBeenSet = true; m_tagList.push_back(value); return *this; }
+
+    /**
+     * <p>The list of tags to associate with the new workflow execution. A maximum of 5
+     * tags can be specified. You can list workflow executions with a specific tag by
+     * calling <a>ListOpenWorkflowExecutions</a> or <a>ListClosedWorkflowExecutions</a>
+     * and specifying a <a>TagFilter</a>.</p>
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& AddTagList(Aws::String&& value) { m_tagListHasBeenSet = true; m_tagList.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>The list of tags to associate with the new workflow execution. A maximum of 5
+     * tags can be specified. You can list workflow executions with a specific tag by
+     * calling <a>ListOpenWorkflowExecutions</a> or <a>ListClosedWorkflowExecutions</a>
+     * and specifying a <a>TagFilter</a>.</p>
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& AddTagList(const char* value) { m_tagListHasBeenSet = true; m_tagList.push_back(value); return *this; }
+
+
+    /**
+     * <p>The version of the workflow to start.</p>
+     */
+    inline const Aws::String& GetWorkflowTypeVersion() const{ return m_workflowTypeVersion; }
+
+    /**
+     * <p>The version of the workflow to start.</p>
+     */
+    inline bool WorkflowTypeVersionHasBeenSet() const { return m_workflowTypeVersionHasBeenSet; }
+
+    /**
+     * <p>The version of the workflow to start.</p>
+     */
+    inline void SetWorkflowTypeVersion(const Aws::String& value) { m_workflowTypeVersionHasBeenSet = true; m_workflowTypeVersion = value; }
+
+    /**
+     * <p>The version of the workflow to start.</p>
+     */
+    inline void SetWorkflowTypeVersion(Aws::String&& value) { m_workflowTypeVersionHasBeenSet = true; m_workflowTypeVersion = std::move(value); }
+
+    /**
+     * <p>The version of the workflow to start.</p>
+     */
+    inline void SetWorkflowTypeVersion(const char* value) { m_workflowTypeVersionHasBeenSet = true; m_workflowTypeVersion.assign(value); }
+
+    /**
+     * <p>The version of the workflow to start.</p>
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithWorkflowTypeVersion(const Aws::String& value) { SetWorkflowTypeVersion(value); return *this;}
+
+    /**
+     * <p>The version of the workflow to start.</p>
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithWorkflowTypeVersion(Aws::String&& value) { SetWorkflowTypeVersion(std::move(value)); return *this;}
+
+    /**
+     * <p>The version of the workflow to start.</p>
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithWorkflowTypeVersion(const char* value) { SetWorkflowTypeVersion(value); return *this;}
+
+
+    /**
+     * <p>The IAM role to attach to the new (continued) execution.</p>
+     */
+    inline const Aws::String& GetLambdaRole() const{ return m_lambdaRole; }
+
+    /**
+     * <p>The IAM role to attach to the new (continued) execution.</p>
+     */
+    inline bool LambdaRoleHasBeenSet() const { return m_lambdaRoleHasBeenSet; }
+
+    /**
+     * <p>The IAM role to attach to the new (continued) execution.</p>
+     */
+    inline void SetLambdaRole(const Aws::String& value) { m_lambdaRoleHasBeenSet = true; m_lambdaRole = value; }
+
+    /**
+     * <p>The IAM role to attach to the new (continued) execution.</p>
+     */
+    inline void SetLambdaRole(Aws::String&& value) { m_lambdaRoleHasBeenSet = true; m_lambdaRole = std::move(value); }
+
+    /**
+     * <p>The IAM role to attach to the new (continued) execution.</p>
+     */
+    inline void SetLambdaRole(const char* value) { m_lambdaRoleHasBeenSet = true; m_lambdaRole.assign(value); }
+
+    /**
+     * <p>The IAM role to attach to the new (continued) execution.</p>
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithLambdaRole(const Aws::String& value) { SetLambdaRole(value); return *this;}
+
+    /**
+     * <p>The IAM role to attach to the new (continued) execution.</p>
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithLambdaRole(Aws::String&& value) { SetLambdaRole(std::move(value)); return *this;}
+
+    /**
+     * <p>The IAM role to attach to the new (continued) execution.</p>
+     */
+    inline ContinueAsNewWorkflowExecutionDecisionAttributes& WithLambdaRole(const char* value) { SetLambdaRole(value); return *this;}
+
+  private:
+
+    Aws::String m_input;
+    bool m_inputHasBeenSet;
+
+    Aws::String m_executionStartToCloseTimeout;
+    bool m_executionStartToCloseTimeoutHasBeenSet;
+
+    TaskList m_taskList;
+    bool m_taskListHasBeenSet;
+
+    Aws::String m_taskPriority;
+    bool m_taskPriorityHasBeenSet;
+
+    Aws::String m_taskStartToCloseTimeout;
+    bool m_taskStartToCloseTimeoutHasBeenSet;
+
+    ChildPolicy m_childPolicy;
+    bool m_childPolicyHasBeenSet;
+
+    Aws::Vector<Aws::String> m_tagList;
+    bool m_tagListHasBeenSet;
+
+    Aws::String m_workflowTypeVersion;
+    bool m_workflowTypeVersionHasBeenSet;
+
+    Aws::String m_lambdaRole;
+    bool m_lambdaRoleHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ContinueAsNewWorkflowExecutionFailedCause.h

@@ -0,0 +1,38 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+  enum class ContinueAsNewWorkflowExecutionFailedCause
+  {
+    NOT_SET,
+    UNHANDLED_DECISION,
+    WORKFLOW_TYPE_DEPRECATED,
+    WORKFLOW_TYPE_DOES_NOT_EXIST,
+    DEFAULT_EXECUTION_START_TO_CLOSE_TIMEOUT_UNDEFINED,
+    DEFAULT_TASK_START_TO_CLOSE_TIMEOUT_UNDEFINED,
+    DEFAULT_TASK_LIST_UNDEFINED,
+    DEFAULT_CHILD_POLICY_UNDEFINED,
+    CONTINUE_AS_NEW_WORKFLOW_EXECUTION_RATE_EXCEEDED,
+    OPERATION_NOT_PERMITTED
+  };
+
+namespace ContinueAsNewWorkflowExecutionFailedCauseMapper
+{
+AWS_SWF_API ContinueAsNewWorkflowExecutionFailedCause GetContinueAsNewWorkflowExecutionFailedCauseForName(const Aws::String& name);
+
+AWS_SWF_API Aws::String GetNameForContinueAsNewWorkflowExecutionFailedCause(ContinueAsNewWorkflowExecutionFailedCause value);
+} // namespace ContinueAsNewWorkflowExecutionFailedCauseMapper
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ContinueAsNewWorkflowExecutionFailedEventAttributes.h

@@ -0,0 +1,155 @@
+/**
+ * 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/model/ContinueAsNewWorkflowExecutionFailedCause.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>ContinueAsNewWorkflowExecutionFailed</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ContinueAsNewWorkflowExecutionFailedEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ContinueAsNewWorkflowExecutionFailedEventAttributes
+  {
+  public:
+    ContinueAsNewWorkflowExecutionFailedEventAttributes();
+    ContinueAsNewWorkflowExecutionFailedEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    ContinueAsNewWorkflowExecutionFailedEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline const ContinueAsNewWorkflowExecutionFailedCause& GetCause() const{ return m_cause; }
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline bool CauseHasBeenSet() const { return m_causeHasBeenSet; }
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline void SetCause(const ContinueAsNewWorkflowExecutionFailedCause& value) { m_causeHasBeenSet = true; m_cause = value; }
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline void SetCause(ContinueAsNewWorkflowExecutionFailedCause&& value) { m_causeHasBeenSet = true; m_cause = std::move(value); }
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline ContinueAsNewWorkflowExecutionFailedEventAttributes& WithCause(const ContinueAsNewWorkflowExecutionFailedCause& value) { SetCause(value); return *this;}
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline ContinueAsNewWorkflowExecutionFailedEventAttributes& WithCause(ContinueAsNewWorkflowExecutionFailedCause&& value) { SetCause(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>ContinueAsNewWorkflowExecution</code>
+     * decision that started this execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline long long GetDecisionTaskCompletedEventId() const{ return m_decisionTaskCompletedEventId; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>ContinueAsNewWorkflowExecution</code>
+     * decision that started this execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline bool DecisionTaskCompletedEventIdHasBeenSet() const { return m_decisionTaskCompletedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>ContinueAsNewWorkflowExecution</code>
+     * decision that started this execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline void SetDecisionTaskCompletedEventId(long long value) { m_decisionTaskCompletedEventIdHasBeenSet = true; m_decisionTaskCompletedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>ContinueAsNewWorkflowExecution</code>
+     * decision that started this execution. This information can be useful for
+     * diagnosing problems by tracing back the chain of events leading up to this
+     * event.</p>
+     */
+    inline ContinueAsNewWorkflowExecutionFailedEventAttributes& WithDecisionTaskCompletedEventId(long long value) { SetDecisionTaskCompletedEventId(value); return *this;}
+
+  private:
+
+    ContinueAsNewWorkflowExecutionFailedCause m_cause;
+    bool m_causeHasBeenSet;
+
+    long long m_decisionTaskCompletedEventId;
+    bool m_decisionTaskCompletedEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/CountClosedWorkflowExecutionsRequest.h

@@ -0,0 +1,432 @@
+/**
+ * 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/SWFRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/ExecutionTimeFilter.h>
+#include <aws/swf/model/WorkflowExecutionFilter.h>
+#include <aws/swf/model/WorkflowTypeFilter.h>
+#include <aws/swf/model/TagFilter.h>
+#include <aws/swf/model/CloseStatusFilter.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SWF_API CountClosedWorkflowExecutionsRequest : public SWFRequest
+  {
+  public:
+    CountClosedWorkflowExecutionsRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "CountClosedWorkflowExecutions"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the domain containing the workflow executions to count.</p>
+     */
+    inline const Aws::String& GetDomain() const{ return m_domain; }
+
+    /**
+     * <p>The name of the domain containing the workflow executions to count.</p>
+     */
+    inline bool DomainHasBeenSet() const { return m_domainHasBeenSet; }
+
+    /**
+     * <p>The name of the domain containing the workflow executions to count.</p>
+     */
+    inline void SetDomain(const Aws::String& value) { m_domainHasBeenSet = true; m_domain = value; }
+
+    /**
+     * <p>The name of the domain containing the workflow executions to count.</p>
+     */
+    inline void SetDomain(Aws::String&& value) { m_domainHasBeenSet = true; m_domain = std::move(value); }
+
+    /**
+     * <p>The name of the domain containing the workflow executions to count.</p>
+     */
+    inline void SetDomain(const char* value) { m_domainHasBeenSet = true; m_domain.assign(value); }
+
+    /**
+     * <p>The name of the domain containing the workflow executions to count.</p>
+     */
+    inline CountClosedWorkflowExecutionsRequest& WithDomain(const Aws::String& value) { SetDomain(value); return *this;}
+
+    /**
+     * <p>The name of the domain containing the workflow executions to count.</p>
+     */
+    inline CountClosedWorkflowExecutionsRequest& WithDomain(Aws::String&& value) { SetDomain(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the domain containing the workflow executions to count.</p>
+     */
+    inline CountClosedWorkflowExecutionsRequest& WithDomain(const char* value) { SetDomain(value); return *this;}
+
+
+    /**
+     * <p>If specified, only workflow executions that meet the start time criteria of
+     * the filter are counted.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline const ExecutionTimeFilter& GetStartTimeFilter() const{ return m_startTimeFilter; }
+
+    /**
+     * <p>If specified, only workflow executions that meet the start time criteria of
+     * the filter are counted.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline bool StartTimeFilterHasBeenSet() const { return m_startTimeFilterHasBeenSet; }
+
+    /**
+     * <p>If specified, only workflow executions that meet the start time criteria of
+     * the filter are counted.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline void SetStartTimeFilter(const ExecutionTimeFilter& value) { m_startTimeFilterHasBeenSet = true; m_startTimeFilter = value; }
+
+    /**
+     * <p>If specified, only workflow executions that meet the start time criteria of
+     * the filter are counted.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline void SetStartTimeFilter(ExecutionTimeFilter&& value) { m_startTimeFilterHasBeenSet = true; m_startTimeFilter = std::move(value); }
+
+    /**
+     * <p>If specified, only workflow executions that meet the start time criteria of
+     * the filter are counted.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline CountClosedWorkflowExecutionsRequest& WithStartTimeFilter(const ExecutionTimeFilter& value) { SetStartTimeFilter(value); return *this;}
+
+    /**
+     * <p>If specified, only workflow executions that meet the start time criteria of
+     * the filter are counted.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline CountClosedWorkflowExecutionsRequest& WithStartTimeFilter(ExecutionTimeFilter&& value) { SetStartTimeFilter(std::move(value)); return *this;}
+
+
+    /**
+     * <p>If specified, only workflow executions that meet the close time criteria of
+     * the filter are counted.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline const ExecutionTimeFilter& GetCloseTimeFilter() const{ return m_closeTimeFilter; }
+
+    /**
+     * <p>If specified, only workflow executions that meet the close time criteria of
+     * the filter are counted.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline bool CloseTimeFilterHasBeenSet() const { return m_closeTimeFilterHasBeenSet; }
+
+    /**
+     * <p>If specified, only workflow executions that meet the close time criteria of
+     * the filter are counted.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline void SetCloseTimeFilter(const ExecutionTimeFilter& value) { m_closeTimeFilterHasBeenSet = true; m_closeTimeFilter = value; }
+
+    /**
+     * <p>If specified, only workflow executions that meet the close time criteria of
+     * the filter are counted.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline void SetCloseTimeFilter(ExecutionTimeFilter&& value) { m_closeTimeFilterHasBeenSet = true; m_closeTimeFilter = std::move(value); }
+
+    /**
+     * <p>If specified, only workflow executions that meet the close time criteria of
+     * the filter are counted.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline CountClosedWorkflowExecutionsRequest& WithCloseTimeFilter(const ExecutionTimeFilter& value) { SetCloseTimeFilter(value); return *this;}
+
+    /**
+     * <p>If specified, only workflow executions that meet the close time criteria of
+     * the filter are counted.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline CountClosedWorkflowExecutionsRequest& WithCloseTimeFilter(ExecutionTimeFilter&& value) { SetCloseTimeFilter(std::move(value)); return *this;}
+
+
+    /**
+     * <p>If specified, only workflow executions matching the <code>WorkflowId</code>
+     * in the filter are counted.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline const WorkflowExecutionFilter& GetExecutionFilter() const{ return m_executionFilter; }
+
+    /**
+     * <p>If specified, only workflow executions matching the <code>WorkflowId</code>
+     * in the filter are counted.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline bool ExecutionFilterHasBeenSet() const { return m_executionFilterHasBeenSet; }
+
+    /**
+     * <p>If specified, only workflow executions matching the <code>WorkflowId</code>
+     * in the filter are counted.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline void SetExecutionFilter(const WorkflowExecutionFilter& value) { m_executionFilterHasBeenSet = true; m_executionFilter = value; }
+
+    /**
+     * <p>If specified, only workflow executions matching the <code>WorkflowId</code>
+     * in the filter are counted.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline void SetExecutionFilter(WorkflowExecutionFilter&& value) { m_executionFilterHasBeenSet = true; m_executionFilter = std::move(value); }
+
+    /**
+     * <p>If specified, only workflow executions matching the <code>WorkflowId</code>
+     * in the filter are counted.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline CountClosedWorkflowExecutionsRequest& WithExecutionFilter(const WorkflowExecutionFilter& value) { SetExecutionFilter(value); return *this;}
+
+    /**
+     * <p>If specified, only workflow executions matching the <code>WorkflowId</code>
+     * in the filter are counted.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline CountClosedWorkflowExecutionsRequest& WithExecutionFilter(WorkflowExecutionFilter&& value) { SetExecutionFilter(std::move(value)); return *this;}
+
+
+    /**
+     * <p>If specified, indicates the type of the workflow executions to be
+     * counted.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline const WorkflowTypeFilter& GetTypeFilter() const{ return m_typeFilter; }
+
+    /**
+     * <p>If specified, indicates the type of the workflow executions to be
+     * counted.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline bool TypeFilterHasBeenSet() const { return m_typeFilterHasBeenSet; }
+
+    /**
+     * <p>If specified, indicates the type of the workflow executions to be
+     * counted.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline void SetTypeFilter(const WorkflowTypeFilter& value) { m_typeFilterHasBeenSet = true; m_typeFilter = value; }
+
+    /**
+     * <p>If specified, indicates the type of the workflow executions to be
+     * counted.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline void SetTypeFilter(WorkflowTypeFilter&& value) { m_typeFilterHasBeenSet = true; m_typeFilter = std::move(value); }
+
+    /**
+     * <p>If specified, indicates the type of the workflow executions to be
+     * counted.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline CountClosedWorkflowExecutionsRequest& WithTypeFilter(const WorkflowTypeFilter& value) { SetTypeFilter(value); return *this;}
+
+    /**
+     * <p>If specified, indicates the type of the workflow executions to be
+     * counted.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline CountClosedWorkflowExecutionsRequest& WithTypeFilter(WorkflowTypeFilter&& value) { SetTypeFilter(std::move(value)); return *this;}
+
+
+    /**
+     * <p>If specified, only executions that have a tag that matches the filter are
+     * counted.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline const TagFilter& GetTagFilter() const{ return m_tagFilter; }
+
+    /**
+     * <p>If specified, only executions that have a tag that matches the filter are
+     * counted.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline bool TagFilterHasBeenSet() const { return m_tagFilterHasBeenSet; }
+
+    /**
+     * <p>If specified, only executions that have a tag that matches the filter are
+     * counted.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline void SetTagFilter(const TagFilter& value) { m_tagFilterHasBeenSet = true; m_tagFilter = value; }
+
+    /**
+     * <p>If specified, only executions that have a tag that matches the filter are
+     * counted.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline void SetTagFilter(TagFilter&& value) { m_tagFilterHasBeenSet = true; m_tagFilter = std::move(value); }
+
+    /**
+     * <p>If specified, only executions that have a tag that matches the filter are
+     * counted.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline CountClosedWorkflowExecutionsRequest& WithTagFilter(const TagFilter& value) { SetTagFilter(value); return *this;}
+
+    /**
+     * <p>If specified, only executions that have a tag that matches the filter are
+     * counted.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline CountClosedWorkflowExecutionsRequest& WithTagFilter(TagFilter&& value) { SetTagFilter(std::move(value)); return *this;}
+
+
+    /**
+     * <p>If specified, only workflow executions that match this close status are
+     * counted. This filter has an affect only if <code>executionStatus</code> is
+     * specified as <code>CLOSED</code>.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline const CloseStatusFilter& GetCloseStatusFilter() const{ return m_closeStatusFilter; }
+
+    /**
+     * <p>If specified, only workflow executions that match this close status are
+     * counted. This filter has an affect only if <code>executionStatus</code> is
+     * specified as <code>CLOSED</code>.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline bool CloseStatusFilterHasBeenSet() const { return m_closeStatusFilterHasBeenSet; }
+
+    /**
+     * <p>If specified, only workflow executions that match this close status are
+     * counted. This filter has an affect only if <code>executionStatus</code> is
+     * specified as <code>CLOSED</code>.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline void SetCloseStatusFilter(const CloseStatusFilter& value) { m_closeStatusFilterHasBeenSet = true; m_closeStatusFilter = value; }
+
+    /**
+     * <p>If specified, only workflow executions that match this close status are
+     * counted. This filter has an affect only if <code>executionStatus</code> is
+     * specified as <code>CLOSED</code>.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline void SetCloseStatusFilter(CloseStatusFilter&& value) { m_closeStatusFilterHasBeenSet = true; m_closeStatusFilter = std::move(value); }
+
+    /**
+     * <p>If specified, only workflow executions that match this close status are
+     * counted. This filter has an affect only if <code>executionStatus</code> is
+     * specified as <code>CLOSED</code>.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline CountClosedWorkflowExecutionsRequest& WithCloseStatusFilter(const CloseStatusFilter& value) { SetCloseStatusFilter(value); return *this;}
+
+    /**
+     * <p>If specified, only workflow executions that match this close status are
+     * counted. This filter has an affect only if <code>executionStatus</code> is
+     * specified as <code>CLOSED</code>.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline CountClosedWorkflowExecutionsRequest& WithCloseStatusFilter(CloseStatusFilter&& value) { SetCloseStatusFilter(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_domain;
+    bool m_domainHasBeenSet;
+
+    ExecutionTimeFilter m_startTimeFilter;
+    bool m_startTimeFilterHasBeenSet;
+
+    ExecutionTimeFilter m_closeTimeFilter;
+    bool m_closeTimeFilterHasBeenSet;
+
+    WorkflowExecutionFilter m_executionFilter;
+    bool m_executionFilterHasBeenSet;
+
+    WorkflowTypeFilter m_typeFilter;
+    bool m_typeFilterHasBeenSet;
+
+    TagFilter m_tagFilter;
+    bool m_tagFilterHasBeenSet;
+
+    CloseStatusFilter m_closeStatusFilter;
+    bool m_closeStatusFilterHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/CountClosedWorkflowExecutionsResult.h

@@ -0,0 +1,83 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/swf/SWF_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+  /**
+   * <p>Contains the count of workflow executions returned from
+   * <a>CountOpenWorkflowExecutions</a> or <a>CountClosedWorkflowExecutions</a>
+   * </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/WorkflowExecutionCount">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API CountClosedWorkflowExecutionsResult
+  {
+  public:
+    CountClosedWorkflowExecutionsResult();
+    CountClosedWorkflowExecutionsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    CountClosedWorkflowExecutionsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The number of workflow executions.</p>
+     */
+    inline int GetCount() const{ return m_count; }
+
+    /**
+     * <p>The number of workflow executions.</p>
+     */
+    inline void SetCount(int value) { m_count = value; }
+
+    /**
+     * <p>The number of workflow executions.</p>
+     */
+    inline CountClosedWorkflowExecutionsResult& WithCount(int value) { SetCount(value); return *this;}
+
+
+    /**
+     * <p>If set to true, indicates that the actual count was more than the maximum
+     * supported by this API and the count returned is the truncated value.</p>
+     */
+    inline bool GetTruncated() const{ return m_truncated; }
+
+    /**
+     * <p>If set to true, indicates that the actual count was more than the maximum
+     * supported by this API and the count returned is the truncated value.</p>
+     */
+    inline void SetTruncated(bool value) { m_truncated = value; }
+
+    /**
+     * <p>If set to true, indicates that the actual count was more than the maximum
+     * supported by this API and the count returned is the truncated value.</p>
+     */
+    inline CountClosedWorkflowExecutionsResult& WithTruncated(bool value) { SetTruncated(value); return *this;}
+
+  private:
+
+    int m_count;
+
+    bool m_truncated;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/CountOpenWorkflowExecutionsRequest.h

@@ -0,0 +1,285 @@
+/**
+ * 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/SWFRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/ExecutionTimeFilter.h>
+#include <aws/swf/model/WorkflowTypeFilter.h>
+#include <aws/swf/model/TagFilter.h>
+#include <aws/swf/model/WorkflowExecutionFilter.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SWF_API CountOpenWorkflowExecutionsRequest : public SWFRequest
+  {
+  public:
+    CountOpenWorkflowExecutionsRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "CountOpenWorkflowExecutions"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the domain containing the workflow executions to count.</p>
+     */
+    inline const Aws::String& GetDomain() const{ return m_domain; }
+
+    /**
+     * <p>The name of the domain containing the workflow executions to count.</p>
+     */
+    inline bool DomainHasBeenSet() const { return m_domainHasBeenSet; }
+
+    /**
+     * <p>The name of the domain containing the workflow executions to count.</p>
+     */
+    inline void SetDomain(const Aws::String& value) { m_domainHasBeenSet = true; m_domain = value; }
+
+    /**
+     * <p>The name of the domain containing the workflow executions to count.</p>
+     */
+    inline void SetDomain(Aws::String&& value) { m_domainHasBeenSet = true; m_domain = std::move(value); }
+
+    /**
+     * <p>The name of the domain containing the workflow executions to count.</p>
+     */
+    inline void SetDomain(const char* value) { m_domainHasBeenSet = true; m_domain.assign(value); }
+
+    /**
+     * <p>The name of the domain containing the workflow executions to count.</p>
+     */
+    inline CountOpenWorkflowExecutionsRequest& WithDomain(const Aws::String& value) { SetDomain(value); return *this;}
+
+    /**
+     * <p>The name of the domain containing the workflow executions to count.</p>
+     */
+    inline CountOpenWorkflowExecutionsRequest& WithDomain(Aws::String&& value) { SetDomain(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the domain containing the workflow executions to count.</p>
+     */
+    inline CountOpenWorkflowExecutionsRequest& WithDomain(const char* value) { SetDomain(value); return *this;}
+
+
+    /**
+     * <p>Specifies the start time criteria that workflow executions must meet in order
+     * to be counted.</p>
+     */
+    inline const ExecutionTimeFilter& GetStartTimeFilter() const{ return m_startTimeFilter; }
+
+    /**
+     * <p>Specifies the start time criteria that workflow executions must meet in order
+     * to be counted.</p>
+     */
+    inline bool StartTimeFilterHasBeenSet() const { return m_startTimeFilterHasBeenSet; }
+
+    /**
+     * <p>Specifies the start time criteria that workflow executions must meet in order
+     * to be counted.</p>
+     */
+    inline void SetStartTimeFilter(const ExecutionTimeFilter& value) { m_startTimeFilterHasBeenSet = true; m_startTimeFilter = value; }
+
+    /**
+     * <p>Specifies the start time criteria that workflow executions must meet in order
+     * to be counted.</p>
+     */
+    inline void SetStartTimeFilter(ExecutionTimeFilter&& value) { m_startTimeFilterHasBeenSet = true; m_startTimeFilter = std::move(value); }
+
+    /**
+     * <p>Specifies the start time criteria that workflow executions must meet in order
+     * to be counted.</p>
+     */
+    inline CountOpenWorkflowExecutionsRequest& WithStartTimeFilter(const ExecutionTimeFilter& value) { SetStartTimeFilter(value); return *this;}
+
+    /**
+     * <p>Specifies the start time criteria that workflow executions must meet in order
+     * to be counted.</p>
+     */
+    inline CountOpenWorkflowExecutionsRequest& WithStartTimeFilter(ExecutionTimeFilter&& value) { SetStartTimeFilter(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Specifies the type of the workflow executions to be counted.</p>  <p>
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline const WorkflowTypeFilter& GetTypeFilter() const{ return m_typeFilter; }
+
+    /**
+     * <p>Specifies the type of the workflow executions to be counted.</p>  <p>
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline bool TypeFilterHasBeenSet() const { return m_typeFilterHasBeenSet; }
+
+    /**
+     * <p>Specifies the type of the workflow executions to be counted.</p>  <p>
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline void SetTypeFilter(const WorkflowTypeFilter& value) { m_typeFilterHasBeenSet = true; m_typeFilter = value; }
+
+    /**
+     * <p>Specifies the type of the workflow executions to be counted.</p>  <p>
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline void SetTypeFilter(WorkflowTypeFilter&& value) { m_typeFilterHasBeenSet = true; m_typeFilter = std::move(value); }
+
+    /**
+     * <p>Specifies the type of the workflow executions to be counted.</p>  <p>
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline CountOpenWorkflowExecutionsRequest& WithTypeFilter(const WorkflowTypeFilter& value) { SetTypeFilter(value); return *this;}
+
+    /**
+     * <p>Specifies the type of the workflow executions to be counted.</p>  <p>
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline CountOpenWorkflowExecutionsRequest& WithTypeFilter(WorkflowTypeFilter&& value) { SetTypeFilter(std::move(value)); return *this;}
+
+
+    /**
+     * <p>If specified, only executions that have a tag that matches the filter are
+     * counted.</p>  <p> <code>executionFilter</code>, <code>typeFilter</code>
+     * and <code>tagFilter</code> are mutually exclusive. You can specify at most one
+     * of these in a request.</p> 
+     */
+    inline const TagFilter& GetTagFilter() const{ return m_tagFilter; }
+
+    /**
+     * <p>If specified, only executions that have a tag that matches the filter are
+     * counted.</p>  <p> <code>executionFilter</code>, <code>typeFilter</code>
+     * and <code>tagFilter</code> are mutually exclusive. You can specify at most one
+     * of these in a request.</p> 
+     */
+    inline bool TagFilterHasBeenSet() const { return m_tagFilterHasBeenSet; }
+
+    /**
+     * <p>If specified, only executions that have a tag that matches the filter are
+     * counted.</p>  <p> <code>executionFilter</code>, <code>typeFilter</code>
+     * and <code>tagFilter</code> are mutually exclusive. You can specify at most one
+     * of these in a request.</p> 
+     */
+    inline void SetTagFilter(const TagFilter& value) { m_tagFilterHasBeenSet = true; m_tagFilter = value; }
+
+    /**
+     * <p>If specified, only executions that have a tag that matches the filter are
+     * counted.</p>  <p> <code>executionFilter</code>, <code>typeFilter</code>
+     * and <code>tagFilter</code> are mutually exclusive. You can specify at most one
+     * of these in a request.</p> 
+     */
+    inline void SetTagFilter(TagFilter&& value) { m_tagFilterHasBeenSet = true; m_tagFilter = std::move(value); }
+
+    /**
+     * <p>If specified, only executions that have a tag that matches the filter are
+     * counted.</p>  <p> <code>executionFilter</code>, <code>typeFilter</code>
+     * and <code>tagFilter</code> are mutually exclusive. You can specify at most one
+     * of these in a request.</p> 
+     */
+    inline CountOpenWorkflowExecutionsRequest& WithTagFilter(const TagFilter& value) { SetTagFilter(value); return *this;}
+
+    /**
+     * <p>If specified, only executions that have a tag that matches the filter are
+     * counted.</p>  <p> <code>executionFilter</code>, <code>typeFilter</code>
+     * and <code>tagFilter</code> are mutually exclusive. You can specify at most one
+     * of these in a request.</p> 
+     */
+    inline CountOpenWorkflowExecutionsRequest& WithTagFilter(TagFilter&& value) { SetTagFilter(std::move(value)); return *this;}
+
+
+    /**
+     * <p>If specified, only workflow executions matching the <code>WorkflowId</code>
+     * in the filter are counted.</p>  <p> <code>executionFilter</code>,
+     * <code>typeFilter</code> and <code>tagFilter</code> are mutually exclusive. You
+     * can specify at most one of these in a request.</p> 
+     */
+    inline const WorkflowExecutionFilter& GetExecutionFilter() const{ return m_executionFilter; }
+
+    /**
+     * <p>If specified, only workflow executions matching the <code>WorkflowId</code>
+     * in the filter are counted.</p>  <p> <code>executionFilter</code>,
+     * <code>typeFilter</code> and <code>tagFilter</code> are mutually exclusive. You
+     * can specify at most one of these in a request.</p> 
+     */
+    inline bool ExecutionFilterHasBeenSet() const { return m_executionFilterHasBeenSet; }
+
+    /**
+     * <p>If specified, only workflow executions matching the <code>WorkflowId</code>
+     * in the filter are counted.</p>  <p> <code>executionFilter</code>,
+     * <code>typeFilter</code> and <code>tagFilter</code> are mutually exclusive. You
+     * can specify at most one of these in a request.</p> 
+     */
+    inline void SetExecutionFilter(const WorkflowExecutionFilter& value) { m_executionFilterHasBeenSet = true; m_executionFilter = value; }
+
+    /**
+     * <p>If specified, only workflow executions matching the <code>WorkflowId</code>
+     * in the filter are counted.</p>  <p> <code>executionFilter</code>,
+     * <code>typeFilter</code> and <code>tagFilter</code> are mutually exclusive. You
+     * can specify at most one of these in a request.</p> 
+     */
+    inline void SetExecutionFilter(WorkflowExecutionFilter&& value) { m_executionFilterHasBeenSet = true; m_executionFilter = std::move(value); }
+
+    /**
+     * <p>If specified, only workflow executions matching the <code>WorkflowId</code>
+     * in the filter are counted.</p>  <p> <code>executionFilter</code>,
+     * <code>typeFilter</code> and <code>tagFilter</code> are mutually exclusive. You
+     * can specify at most one of these in a request.</p> 
+     */
+    inline CountOpenWorkflowExecutionsRequest& WithExecutionFilter(const WorkflowExecutionFilter& value) { SetExecutionFilter(value); return *this;}
+
+    /**
+     * <p>If specified, only workflow executions matching the <code>WorkflowId</code>
+     * in the filter are counted.</p>  <p> <code>executionFilter</code>,
+     * <code>typeFilter</code> and <code>tagFilter</code> are mutually exclusive. You
+     * can specify at most one of these in a request.</p> 
+     */
+    inline CountOpenWorkflowExecutionsRequest& WithExecutionFilter(WorkflowExecutionFilter&& value) { SetExecutionFilter(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_domain;
+    bool m_domainHasBeenSet;
+
+    ExecutionTimeFilter m_startTimeFilter;
+    bool m_startTimeFilterHasBeenSet;
+
+    WorkflowTypeFilter m_typeFilter;
+    bool m_typeFilterHasBeenSet;
+
+    TagFilter m_tagFilter;
+    bool m_tagFilterHasBeenSet;
+
+    WorkflowExecutionFilter m_executionFilter;
+    bool m_executionFilterHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/CountOpenWorkflowExecutionsResult.h

@@ -0,0 +1,83 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/swf/SWF_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+  /**
+   * <p>Contains the count of workflow executions returned from
+   * <a>CountOpenWorkflowExecutions</a> or <a>CountClosedWorkflowExecutions</a>
+   * </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/WorkflowExecutionCount">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API CountOpenWorkflowExecutionsResult
+  {
+  public:
+    CountOpenWorkflowExecutionsResult();
+    CountOpenWorkflowExecutionsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    CountOpenWorkflowExecutionsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The number of workflow executions.</p>
+     */
+    inline int GetCount() const{ return m_count; }
+
+    /**
+     * <p>The number of workflow executions.</p>
+     */
+    inline void SetCount(int value) { m_count = value; }
+
+    /**
+     * <p>The number of workflow executions.</p>
+     */
+    inline CountOpenWorkflowExecutionsResult& WithCount(int value) { SetCount(value); return *this;}
+
+
+    /**
+     * <p>If set to true, indicates that the actual count was more than the maximum
+     * supported by this API and the count returned is the truncated value.</p>
+     */
+    inline bool GetTruncated() const{ return m_truncated; }
+
+    /**
+     * <p>If set to true, indicates that the actual count was more than the maximum
+     * supported by this API and the count returned is the truncated value.</p>
+     */
+    inline void SetTruncated(bool value) { m_truncated = value; }
+
+    /**
+     * <p>If set to true, indicates that the actual count was more than the maximum
+     * supported by this API and the count returned is the truncated value.</p>
+     */
+    inline CountOpenWorkflowExecutionsResult& WithTruncated(bool value) { SetTruncated(value); return *this;}
+
+  private:
+
+    int m_count;
+
+    bool m_truncated;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/CountPendingActivityTasksRequest.h

@@ -0,0 +1,120 @@
+/**
+ * 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/SWFRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/TaskList.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SWF_API CountPendingActivityTasksRequest : public SWFRequest
+  {
+  public:
+    CountPendingActivityTasksRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "CountPendingActivityTasks"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the domain that contains the task list.</p>
+     */
+    inline const Aws::String& GetDomain() const{ return m_domain; }
+
+    /**
+     * <p>The name of the domain that contains the task list.</p>
+     */
+    inline bool DomainHasBeenSet() const { return m_domainHasBeenSet; }
+
+    /**
+     * <p>The name of the domain that contains the task list.</p>
+     */
+    inline void SetDomain(const Aws::String& value) { m_domainHasBeenSet = true; m_domain = value; }
+
+    /**
+     * <p>The name of the domain that contains the task list.</p>
+     */
+    inline void SetDomain(Aws::String&& value) { m_domainHasBeenSet = true; m_domain = std::move(value); }
+
+    /**
+     * <p>The name of the domain that contains the task list.</p>
+     */
+    inline void SetDomain(const char* value) { m_domainHasBeenSet = true; m_domain.assign(value); }
+
+    /**
+     * <p>The name of the domain that contains the task list.</p>
+     */
+    inline CountPendingActivityTasksRequest& WithDomain(const Aws::String& value) { SetDomain(value); return *this;}
+
+    /**
+     * <p>The name of the domain that contains the task list.</p>
+     */
+    inline CountPendingActivityTasksRequest& WithDomain(Aws::String&& value) { SetDomain(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the domain that contains the task list.</p>
+     */
+    inline CountPendingActivityTasksRequest& WithDomain(const char* value) { SetDomain(value); return *this;}
+
+
+    /**
+     * <p>The name of the task list.</p>
+     */
+    inline const TaskList& GetTaskList() const{ return m_taskList; }
+
+    /**
+     * <p>The name of the task list.</p>
+     */
+    inline bool TaskListHasBeenSet() const { return m_taskListHasBeenSet; }
+
+    /**
+     * <p>The name of the task list.</p>
+     */
+    inline void SetTaskList(const TaskList& value) { m_taskListHasBeenSet = true; m_taskList = value; }
+
+    /**
+     * <p>The name of the task list.</p>
+     */
+    inline void SetTaskList(TaskList&& value) { m_taskListHasBeenSet = true; m_taskList = std::move(value); }
+
+    /**
+     * <p>The name of the task list.</p>
+     */
+    inline CountPendingActivityTasksRequest& WithTaskList(const TaskList& value) { SetTaskList(value); return *this;}
+
+    /**
+     * <p>The name of the task list.</p>
+     */
+    inline CountPendingActivityTasksRequest& WithTaskList(TaskList&& value) { SetTaskList(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_domain;
+    bool m_domainHasBeenSet;
+
+    TaskList m_taskList;
+    bool m_taskListHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/CountPendingActivityTasksResult.h

@@ -0,0 +1,81 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/swf/SWF_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+  /**
+   * <p>Contains the count of tasks in a task list.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/PendingTaskCount">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API CountPendingActivityTasksResult
+  {
+  public:
+    CountPendingActivityTasksResult();
+    CountPendingActivityTasksResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    CountPendingActivityTasksResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The number of tasks in the task list.</p>
+     */
+    inline int GetCount() const{ return m_count; }
+
+    /**
+     * <p>The number of tasks in the task list.</p>
+     */
+    inline void SetCount(int value) { m_count = value; }
+
+    /**
+     * <p>The number of tasks in the task list.</p>
+     */
+    inline CountPendingActivityTasksResult& WithCount(int value) { SetCount(value); return *this;}
+
+
+    /**
+     * <p>If set to true, indicates that the actual count was more than the maximum
+     * supported by this API and the count returned is the truncated value.</p>
+     */
+    inline bool GetTruncated() const{ return m_truncated; }
+
+    /**
+     * <p>If set to true, indicates that the actual count was more than the maximum
+     * supported by this API and the count returned is the truncated value.</p>
+     */
+    inline void SetTruncated(bool value) { m_truncated = value; }
+
+    /**
+     * <p>If set to true, indicates that the actual count was more than the maximum
+     * supported by this API and the count returned is the truncated value.</p>
+     */
+    inline CountPendingActivityTasksResult& WithTruncated(bool value) { SetTruncated(value); return *this;}
+
+  private:
+
+    int m_count;
+
+    bool m_truncated;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/CountPendingDecisionTasksRequest.h

@@ -0,0 +1,120 @@
+/**
+ * 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/SWFRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/TaskList.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SWF_API CountPendingDecisionTasksRequest : public SWFRequest
+  {
+  public:
+    CountPendingDecisionTasksRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "CountPendingDecisionTasks"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the domain that contains the task list.</p>
+     */
+    inline const Aws::String& GetDomain() const{ return m_domain; }
+
+    /**
+     * <p>The name of the domain that contains the task list.</p>
+     */
+    inline bool DomainHasBeenSet() const { return m_domainHasBeenSet; }
+
+    /**
+     * <p>The name of the domain that contains the task list.</p>
+     */
+    inline void SetDomain(const Aws::String& value) { m_domainHasBeenSet = true; m_domain = value; }
+
+    /**
+     * <p>The name of the domain that contains the task list.</p>
+     */
+    inline void SetDomain(Aws::String&& value) { m_domainHasBeenSet = true; m_domain = std::move(value); }
+
+    /**
+     * <p>The name of the domain that contains the task list.</p>
+     */
+    inline void SetDomain(const char* value) { m_domainHasBeenSet = true; m_domain.assign(value); }
+
+    /**
+     * <p>The name of the domain that contains the task list.</p>
+     */
+    inline CountPendingDecisionTasksRequest& WithDomain(const Aws::String& value) { SetDomain(value); return *this;}
+
+    /**
+     * <p>The name of the domain that contains the task list.</p>
+     */
+    inline CountPendingDecisionTasksRequest& WithDomain(Aws::String&& value) { SetDomain(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the domain that contains the task list.</p>
+     */
+    inline CountPendingDecisionTasksRequest& WithDomain(const char* value) { SetDomain(value); return *this;}
+
+
+    /**
+     * <p>The name of the task list.</p>
+     */
+    inline const TaskList& GetTaskList() const{ return m_taskList; }
+
+    /**
+     * <p>The name of the task list.</p>
+     */
+    inline bool TaskListHasBeenSet() const { return m_taskListHasBeenSet; }
+
+    /**
+     * <p>The name of the task list.</p>
+     */
+    inline void SetTaskList(const TaskList& value) { m_taskListHasBeenSet = true; m_taskList = value; }
+
+    /**
+     * <p>The name of the task list.</p>
+     */
+    inline void SetTaskList(TaskList&& value) { m_taskListHasBeenSet = true; m_taskList = std::move(value); }
+
+    /**
+     * <p>The name of the task list.</p>
+     */
+    inline CountPendingDecisionTasksRequest& WithTaskList(const TaskList& value) { SetTaskList(value); return *this;}
+
+    /**
+     * <p>The name of the task list.</p>
+     */
+    inline CountPendingDecisionTasksRequest& WithTaskList(TaskList&& value) { SetTaskList(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_domain;
+    bool m_domainHasBeenSet;
+
+    TaskList m_taskList;
+    bool m_taskListHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/CountPendingDecisionTasksResult.h

@@ -0,0 +1,81 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/swf/SWF_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+  /**
+   * <p>Contains the count of tasks in a task list.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/PendingTaskCount">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API CountPendingDecisionTasksResult
+  {
+  public:
+    CountPendingDecisionTasksResult();
+    CountPendingDecisionTasksResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    CountPendingDecisionTasksResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The number of tasks in the task list.</p>
+     */
+    inline int GetCount() const{ return m_count; }
+
+    /**
+     * <p>The number of tasks in the task list.</p>
+     */
+    inline void SetCount(int value) { m_count = value; }
+
+    /**
+     * <p>The number of tasks in the task list.</p>
+     */
+    inline CountPendingDecisionTasksResult& WithCount(int value) { SetCount(value); return *this;}
+
+
+    /**
+     * <p>If set to true, indicates that the actual count was more than the maximum
+     * supported by this API and the count returned is the truncated value.</p>
+     */
+    inline bool GetTruncated() const{ return m_truncated; }
+
+    /**
+     * <p>If set to true, indicates that the actual count was more than the maximum
+     * supported by this API and the count returned is the truncated value.</p>
+     */
+    inline void SetTruncated(bool value) { m_truncated = value; }
+
+    /**
+     * <p>If set to true, indicates that the actual count was more than the maximum
+     * supported by this API and the count returned is the truncated value.</p>
+     */
+    inline CountPendingDecisionTasksResult& WithTruncated(bool value) { SetTruncated(value); return *this;}
+
+  private:
+
+    int m_count;
+
+    bool m_truncated;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/Decision.h

@@ -0,0 +1,740 @@
+/**
+ * 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/model/DecisionType.h>
+#include <aws/swf/model/ScheduleActivityTaskDecisionAttributes.h>
+#include <aws/swf/model/RequestCancelActivityTaskDecisionAttributes.h>
+#include <aws/swf/model/CompleteWorkflowExecutionDecisionAttributes.h>
+#include <aws/swf/model/FailWorkflowExecutionDecisionAttributes.h>
+#include <aws/swf/model/CancelWorkflowExecutionDecisionAttributes.h>
+#include <aws/swf/model/ContinueAsNewWorkflowExecutionDecisionAttributes.h>
+#include <aws/swf/model/RecordMarkerDecisionAttributes.h>
+#include <aws/swf/model/StartTimerDecisionAttributes.h>
+#include <aws/swf/model/CancelTimerDecisionAttributes.h>
+#include <aws/swf/model/SignalExternalWorkflowExecutionDecisionAttributes.h>
+#include <aws/swf/model/RequestCancelExternalWorkflowExecutionDecisionAttributes.h>
+#include <aws/swf/model/StartChildWorkflowExecutionDecisionAttributes.h>
+#include <aws/swf/model/ScheduleLambdaFunctionDecisionAttributes.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Specifies a decision made by the decider. A decision can be one of these
+   * types:</p> <ul> <li> <p> <code>CancelTimer</code> – Cancels a previously started
+   * timer and records a <code>TimerCanceled</code> event in the history.</p> </li>
+   * <li> <p> <code>CancelWorkflowExecution</code> – Closes the workflow execution
+   * and records a <code>WorkflowExecutionCanceled</code> event in the history.</p>
+   * </li> <li> <p> <code>CompleteWorkflowExecution</code> – Closes the workflow
+   * execution and records a <code>WorkflowExecutionCompleted</code> event in the
+   * history .</p> </li> <li> <p> <code>ContinueAsNewWorkflowExecution</code> –
+   * Closes the workflow execution and starts a new workflow execution of the same
+   * type using the same workflow ID and a unique run Id. A
+   * <code>WorkflowExecutionContinuedAsNew</code> event is recorded in the
+   * history.</p> </li> <li> <p> <code>FailWorkflowExecution</code> – Closes the
+   * workflow execution and records a <code>WorkflowExecutionFailed</code> event in
+   * the history.</p> </li> <li> <p> <code>RecordMarker</code> – Records a
+   * <code>MarkerRecorded</code> event in the history. Markers can be used for adding
+   * custom information in the history for instance to let deciders know that they
+   * don't need to look at the history beyond the marker event.</p> </li> <li> <p>
+   * <code>RequestCancelActivityTask</code> – Attempts to cancel a previously
+   * scheduled activity task. If the activity task was scheduled but has not been
+   * assigned to a worker, then it is canceled. If the activity task was already
+   * assigned to a worker, then the worker is informed that cancellation has been
+   * requested in the response to <a>RecordActivityTaskHeartbeat</a>.</p> </li> <li>
+   * <p> <code>RequestCancelExternalWorkflowExecution</code> – Requests that a
+   * request be made to cancel the specified external workflow execution and records
+   * a <code>RequestCancelExternalWorkflowExecutionInitiated</code> event in the
+   * history.</p> </li> <li> <p> <code>ScheduleActivityTask</code> – Schedules an
+   * activity task.</p> </li> <li> <p> <code>SignalExternalWorkflowExecution</code> –
+   * Requests a signal to be delivered to the specified external workflow execution
+   * and records a <code>SignalExternalWorkflowExecutionInitiated</code> event in the
+   * history.</p> </li> <li> <p> <code>StartChildWorkflowExecution</code> – Requests
+   * that a child workflow execution be started and records a
+   * <code>StartChildWorkflowExecutionInitiated</code> event in the history. The
+   * child workflow execution is a separate workflow execution with its own
+   * history.</p> </li> <li> <p> <code>StartTimer</code> – Starts a timer for this
+   * workflow execution and records a <code>TimerStarted</code> event in the history.
+   * This timer fires after the specified delay and record a <code>TimerFired</code>
+   * event.</p> </li> </ul> <p> <b>Access Control</b> </p> <p>If you grant permission
+   * to use <code>RespondDecisionTaskCompleted</code>, you can use IAM policies to
+   * express permissions for the list of decisions returned by this action as if they
+   * were members of the API. Treating decisions as a pseudo API maintains a uniform
+   * conceptual model and helps keep policies readable. 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> <b>Decision Failure</b> </p> <p>Decisions can fail for
+   * several reasons</p> <ul> <li> <p>The ordering of decisions should follow a
+   * logical flow. Some decisions might not make sense in the current context of the
+   * workflow execution and therefore fails.</p> </li> <li> <p>A limit on your
+   * account was reached.</p> </li> <li> <p>The decision lacks sufficient
+   * permissions.</p> </li> </ul> <p>One of the following events might be added to
+   * the history to indicate an error. The event attribute's <code>cause</code>
+   * parameter indicates the cause. If <code>cause</code> is set to
+   * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+   * sufficient permissions. 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> <ul> <li> <p> <code>ScheduleActivityTaskFailed</code> – A
+   * <code>ScheduleActivityTask</code> decision failed. This could happen if the
+   * activity type specified in the decision isn't registered, is in a deprecated
+   * state, or the decision isn't properly configured.</p> </li> <li> <p>
+   * <code>RequestCancelActivityTaskFailed</code> – A
+   * <code>RequestCancelActivityTask</code> decision failed. This could happen if
+   * there is no open activity task with the specified activityId.</p> </li> <li> <p>
+   * <code>StartTimerFailed</code> – A <code>StartTimer</code> decision failed. This
+   * could happen if there is another open timer with the same timerId.</p> </li>
+   * <li> <p> <code>CancelTimerFailed</code> – A <code>CancelTimer</code> decision
+   * failed. This could happen if there is no open timer with the specified
+   * timerId.</p> </li> <li> <p> <code>StartChildWorkflowExecutionFailed</code> – A
+   * <code>StartChildWorkflowExecution</code> decision failed. This could happen if
+   * the workflow type specified isn't registered, is deprecated, or the decision
+   * isn't properly configured.</p> </li> <li> <p>
+   * <code>SignalExternalWorkflowExecutionFailed</code> – A
+   * <code>SignalExternalWorkflowExecution</code> decision failed. This could happen
+   * if the <code>workflowID</code> specified in the decision was incorrect.</p>
+   * </li> <li> <p> <code>RequestCancelExternalWorkflowExecutionFailed</code> – A
+   * <code>RequestCancelExternalWorkflowExecution</code> decision failed. This could
+   * happen if the <code>workflowID</code> specified in the decision was
+   * incorrect.</p> </li> <li> <p> <code>CancelWorkflowExecutionFailed</code> – A
+   * <code>CancelWorkflowExecution</code> decision failed. This could happen if there
+   * is an unhandled decision task pending in the workflow execution.</p> </li> <li>
+   * <p> <code>CompleteWorkflowExecutionFailed</code> – A
+   * <code>CompleteWorkflowExecution</code> decision failed. This could happen if
+   * there is an unhandled decision task pending in the workflow execution.</p> </li>
+   * <li> <p> <code>ContinueAsNewWorkflowExecutionFailed</code> – A
+   * <code>ContinueAsNewWorkflowExecution</code> decision failed. This could happen
+   * if there is an unhandled decision task pending in the workflow execution or the
+   * ContinueAsNewWorkflowExecution decision was not configured correctly.</p> </li>
+   * <li> <p> <code>FailWorkflowExecutionFailed</code> – A
+   * <code>FailWorkflowExecution</code> decision failed. This could happen if there
+   * is an unhandled decision task pending in the workflow execution.</p> </li> </ul>
+   * <p>The preceding error events might occur due to an error in the decider logic,
+   * which might put the workflow execution in an unstable state The cause field in
+   * the event structure for the error event indicates the cause of the error.</p>
+   *  <p>A workflow execution may be closed by the decider by returning one of
+   * the following decisions when completing a decision task:
+   * <code>CompleteWorkflowExecution</code>, <code>FailWorkflowExecution</code>,
+   * <code>CancelWorkflowExecution</code> and
+   * <code>ContinueAsNewWorkflowExecution</code>. An <code>UnhandledDecision</code>
+   * fault is returned if a workflow closing decision is specified and a signal or
+   * activity event had been added to the history while the decision task was being
+   * performed by the decider. Unlike the above situations which are logic issues,
+   * this fault is always possible because of race conditions in a distributed
+   * system. The right action here is to call <a>RespondDecisionTaskCompleted</a>
+   * without any decisions. This would result in another decision task with these new
+   * events included in the history. The decider should handle the new events and may
+   * decide to close the workflow execution.</p>  <p> <b>How to Code a
+   * Decision</b> </p> <p>You code a decision by first setting the decision type
+   * field to one of the above decision values, and then set the corresponding
+   * attributes field shown below:</p> <ul> <li> <p> <code>
+   * <a>ScheduleActivityTaskDecisionAttributes</a> </code> </p> </li> <li> <p> <code>
+   * <a>RequestCancelActivityTaskDecisionAttributes</a> </code> </p> </li> <li> <p>
+   * <code> <a>CompleteWorkflowExecutionDecisionAttributes</a> </code> </p> </li>
+   * <li> <p> <code> <a>FailWorkflowExecutionDecisionAttributes</a> </code> </p>
+   * </li> <li> <p> <code> <a>CancelWorkflowExecutionDecisionAttributes</a> </code>
+   * </p> </li> <li> <p> <code>
+   * <a>ContinueAsNewWorkflowExecutionDecisionAttributes</a> </code> </p> </li> <li>
+   * <p> <code> <a>RecordMarkerDecisionAttributes</a> </code> </p> </li> <li> <p>
+   * <code> <a>StartTimerDecisionAttributes</a> </code> </p> </li> <li> <p> <code>
+   * <a>CancelTimerDecisionAttributes</a> </code> </p> </li> <li> <p> <code>
+   * <a>SignalExternalWorkflowExecutionDecisionAttributes</a> </code> </p> </li> <li>
+   * <p> <code> <a>RequestCancelExternalWorkflowExecutionDecisionAttributes</a>
+   * </code> </p> </li> <li> <p> <code>
+   * <a>StartChildWorkflowExecutionDecisionAttributes</a> </code> </p> </li>
+   * </ul><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/Decision">AWS API
+   * Reference</a></p>
+   */
+  class AWS_SWF_API Decision
+  {
+  public:
+    Decision();
+    Decision(Aws::Utils::Json::JsonView jsonValue);
+    Decision& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Specifies the type of the decision.</p>
+     */
+    inline const DecisionType& GetDecisionType() const{ return m_decisionType; }
+
+    /**
+     * <p>Specifies the type of the decision.</p>
+     */
+    inline bool DecisionTypeHasBeenSet() const { return m_decisionTypeHasBeenSet; }
+
+    /**
+     * <p>Specifies the type of the decision.</p>
+     */
+    inline void SetDecisionType(const DecisionType& value) { m_decisionTypeHasBeenSet = true; m_decisionType = value; }
+
+    /**
+     * <p>Specifies the type of the decision.</p>
+     */
+    inline void SetDecisionType(DecisionType&& value) { m_decisionTypeHasBeenSet = true; m_decisionType = std::move(value); }
+
+    /**
+     * <p>Specifies the type of the decision.</p>
+     */
+    inline Decision& WithDecisionType(const DecisionType& value) { SetDecisionType(value); return *this;}
+
+    /**
+     * <p>Specifies the type of the decision.</p>
+     */
+    inline Decision& WithDecisionType(DecisionType&& value) { SetDecisionType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Provides the details of the <code>ScheduleActivityTask</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline const ScheduleActivityTaskDecisionAttributes& GetScheduleActivityTaskDecisionAttributes() const{ return m_scheduleActivityTaskDecisionAttributes; }
+
+    /**
+     * <p>Provides the details of the <code>ScheduleActivityTask</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline bool ScheduleActivityTaskDecisionAttributesHasBeenSet() const { return m_scheduleActivityTaskDecisionAttributesHasBeenSet; }
+
+    /**
+     * <p>Provides the details of the <code>ScheduleActivityTask</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline void SetScheduleActivityTaskDecisionAttributes(const ScheduleActivityTaskDecisionAttributes& value) { m_scheduleActivityTaskDecisionAttributesHasBeenSet = true; m_scheduleActivityTaskDecisionAttributes = value; }
+
+    /**
+     * <p>Provides the details of the <code>ScheduleActivityTask</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline void SetScheduleActivityTaskDecisionAttributes(ScheduleActivityTaskDecisionAttributes&& value) { m_scheduleActivityTaskDecisionAttributesHasBeenSet = true; m_scheduleActivityTaskDecisionAttributes = std::move(value); }
+
+    /**
+     * <p>Provides the details of the <code>ScheduleActivityTask</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline Decision& WithScheduleActivityTaskDecisionAttributes(const ScheduleActivityTaskDecisionAttributes& value) { SetScheduleActivityTaskDecisionAttributes(value); return *this;}
+
+    /**
+     * <p>Provides the details of the <code>ScheduleActivityTask</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline Decision& WithScheduleActivityTaskDecisionAttributes(ScheduleActivityTaskDecisionAttributes&& value) { SetScheduleActivityTaskDecisionAttributes(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Provides the details of the <code>RequestCancelActivityTask</code> decision.
+     * It isn't set for other decision types.</p>
+     */
+    inline const RequestCancelActivityTaskDecisionAttributes& GetRequestCancelActivityTaskDecisionAttributes() const{ return m_requestCancelActivityTaskDecisionAttributes; }
+
+    /**
+     * <p>Provides the details of the <code>RequestCancelActivityTask</code> decision.
+     * It isn't set for other decision types.</p>
+     */
+    inline bool RequestCancelActivityTaskDecisionAttributesHasBeenSet() const { return m_requestCancelActivityTaskDecisionAttributesHasBeenSet; }
+
+    /**
+     * <p>Provides the details of the <code>RequestCancelActivityTask</code> decision.
+     * It isn't set for other decision types.</p>
+     */
+    inline void SetRequestCancelActivityTaskDecisionAttributes(const RequestCancelActivityTaskDecisionAttributes& value) { m_requestCancelActivityTaskDecisionAttributesHasBeenSet = true; m_requestCancelActivityTaskDecisionAttributes = value; }
+
+    /**
+     * <p>Provides the details of the <code>RequestCancelActivityTask</code> decision.
+     * It isn't set for other decision types.</p>
+     */
+    inline void SetRequestCancelActivityTaskDecisionAttributes(RequestCancelActivityTaskDecisionAttributes&& value) { m_requestCancelActivityTaskDecisionAttributesHasBeenSet = true; m_requestCancelActivityTaskDecisionAttributes = std::move(value); }
+
+    /**
+     * <p>Provides the details of the <code>RequestCancelActivityTask</code> decision.
+     * It isn't set for other decision types.</p>
+     */
+    inline Decision& WithRequestCancelActivityTaskDecisionAttributes(const RequestCancelActivityTaskDecisionAttributes& value) { SetRequestCancelActivityTaskDecisionAttributes(value); return *this;}
+
+    /**
+     * <p>Provides the details of the <code>RequestCancelActivityTask</code> decision.
+     * It isn't set for other decision types.</p>
+     */
+    inline Decision& WithRequestCancelActivityTaskDecisionAttributes(RequestCancelActivityTaskDecisionAttributes&& value) { SetRequestCancelActivityTaskDecisionAttributes(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Provides the details of the <code>CompleteWorkflowExecution</code> decision.
+     * It isn't set for other decision types.</p>
+     */
+    inline const CompleteWorkflowExecutionDecisionAttributes& GetCompleteWorkflowExecutionDecisionAttributes() const{ return m_completeWorkflowExecutionDecisionAttributes; }
+
+    /**
+     * <p>Provides the details of the <code>CompleteWorkflowExecution</code> decision.
+     * It isn't set for other decision types.</p>
+     */
+    inline bool CompleteWorkflowExecutionDecisionAttributesHasBeenSet() const { return m_completeWorkflowExecutionDecisionAttributesHasBeenSet; }
+
+    /**
+     * <p>Provides the details of the <code>CompleteWorkflowExecution</code> decision.
+     * It isn't set for other decision types.</p>
+     */
+    inline void SetCompleteWorkflowExecutionDecisionAttributes(const CompleteWorkflowExecutionDecisionAttributes& value) { m_completeWorkflowExecutionDecisionAttributesHasBeenSet = true; m_completeWorkflowExecutionDecisionAttributes = value; }
+
+    /**
+     * <p>Provides the details of the <code>CompleteWorkflowExecution</code> decision.
+     * It isn't set for other decision types.</p>
+     */
+    inline void SetCompleteWorkflowExecutionDecisionAttributes(CompleteWorkflowExecutionDecisionAttributes&& value) { m_completeWorkflowExecutionDecisionAttributesHasBeenSet = true; m_completeWorkflowExecutionDecisionAttributes = std::move(value); }
+
+    /**
+     * <p>Provides the details of the <code>CompleteWorkflowExecution</code> decision.
+     * It isn't set for other decision types.</p>
+     */
+    inline Decision& WithCompleteWorkflowExecutionDecisionAttributes(const CompleteWorkflowExecutionDecisionAttributes& value) { SetCompleteWorkflowExecutionDecisionAttributes(value); return *this;}
+
+    /**
+     * <p>Provides the details of the <code>CompleteWorkflowExecution</code> decision.
+     * It isn't set for other decision types.</p>
+     */
+    inline Decision& WithCompleteWorkflowExecutionDecisionAttributes(CompleteWorkflowExecutionDecisionAttributes&& value) { SetCompleteWorkflowExecutionDecisionAttributes(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Provides the details of the <code>FailWorkflowExecution</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline const FailWorkflowExecutionDecisionAttributes& GetFailWorkflowExecutionDecisionAttributes() const{ return m_failWorkflowExecutionDecisionAttributes; }
+
+    /**
+     * <p>Provides the details of the <code>FailWorkflowExecution</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline bool FailWorkflowExecutionDecisionAttributesHasBeenSet() const { return m_failWorkflowExecutionDecisionAttributesHasBeenSet; }
+
+    /**
+     * <p>Provides the details of the <code>FailWorkflowExecution</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline void SetFailWorkflowExecutionDecisionAttributes(const FailWorkflowExecutionDecisionAttributes& value) { m_failWorkflowExecutionDecisionAttributesHasBeenSet = true; m_failWorkflowExecutionDecisionAttributes = value; }
+
+    /**
+     * <p>Provides the details of the <code>FailWorkflowExecution</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline void SetFailWorkflowExecutionDecisionAttributes(FailWorkflowExecutionDecisionAttributes&& value) { m_failWorkflowExecutionDecisionAttributesHasBeenSet = true; m_failWorkflowExecutionDecisionAttributes = std::move(value); }
+
+    /**
+     * <p>Provides the details of the <code>FailWorkflowExecution</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline Decision& WithFailWorkflowExecutionDecisionAttributes(const FailWorkflowExecutionDecisionAttributes& value) { SetFailWorkflowExecutionDecisionAttributes(value); return *this;}
+
+    /**
+     * <p>Provides the details of the <code>FailWorkflowExecution</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline Decision& WithFailWorkflowExecutionDecisionAttributes(FailWorkflowExecutionDecisionAttributes&& value) { SetFailWorkflowExecutionDecisionAttributes(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Provides the details of the <code>CancelWorkflowExecution</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline const CancelWorkflowExecutionDecisionAttributes& GetCancelWorkflowExecutionDecisionAttributes() const{ return m_cancelWorkflowExecutionDecisionAttributes; }
+
+    /**
+     * <p>Provides the details of the <code>CancelWorkflowExecution</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline bool CancelWorkflowExecutionDecisionAttributesHasBeenSet() const { return m_cancelWorkflowExecutionDecisionAttributesHasBeenSet; }
+
+    /**
+     * <p>Provides the details of the <code>CancelWorkflowExecution</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline void SetCancelWorkflowExecutionDecisionAttributes(const CancelWorkflowExecutionDecisionAttributes& value) { m_cancelWorkflowExecutionDecisionAttributesHasBeenSet = true; m_cancelWorkflowExecutionDecisionAttributes = value; }
+
+    /**
+     * <p>Provides the details of the <code>CancelWorkflowExecution</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline void SetCancelWorkflowExecutionDecisionAttributes(CancelWorkflowExecutionDecisionAttributes&& value) { m_cancelWorkflowExecutionDecisionAttributesHasBeenSet = true; m_cancelWorkflowExecutionDecisionAttributes = std::move(value); }
+
+    /**
+     * <p>Provides the details of the <code>CancelWorkflowExecution</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline Decision& WithCancelWorkflowExecutionDecisionAttributes(const CancelWorkflowExecutionDecisionAttributes& value) { SetCancelWorkflowExecutionDecisionAttributes(value); return *this;}
+
+    /**
+     * <p>Provides the details of the <code>CancelWorkflowExecution</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline Decision& WithCancelWorkflowExecutionDecisionAttributes(CancelWorkflowExecutionDecisionAttributes&& value) { SetCancelWorkflowExecutionDecisionAttributes(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Provides the details of the <code>ContinueAsNewWorkflowExecution</code>
+     * decision. It isn't set for other decision types.</p>
+     */
+    inline const ContinueAsNewWorkflowExecutionDecisionAttributes& GetContinueAsNewWorkflowExecutionDecisionAttributes() const{ return m_continueAsNewWorkflowExecutionDecisionAttributes; }
+
+    /**
+     * <p>Provides the details of the <code>ContinueAsNewWorkflowExecution</code>
+     * decision. It isn't set for other decision types.</p>
+     */
+    inline bool ContinueAsNewWorkflowExecutionDecisionAttributesHasBeenSet() const { return m_continueAsNewWorkflowExecutionDecisionAttributesHasBeenSet; }
+
+    /**
+     * <p>Provides the details of the <code>ContinueAsNewWorkflowExecution</code>
+     * decision. It isn't set for other decision types.</p>
+     */
+    inline void SetContinueAsNewWorkflowExecutionDecisionAttributes(const ContinueAsNewWorkflowExecutionDecisionAttributes& value) { m_continueAsNewWorkflowExecutionDecisionAttributesHasBeenSet = true; m_continueAsNewWorkflowExecutionDecisionAttributes = value; }
+
+    /**
+     * <p>Provides the details of the <code>ContinueAsNewWorkflowExecution</code>
+     * decision. It isn't set for other decision types.</p>
+     */
+    inline void SetContinueAsNewWorkflowExecutionDecisionAttributes(ContinueAsNewWorkflowExecutionDecisionAttributes&& value) { m_continueAsNewWorkflowExecutionDecisionAttributesHasBeenSet = true; m_continueAsNewWorkflowExecutionDecisionAttributes = std::move(value); }
+
+    /**
+     * <p>Provides the details of the <code>ContinueAsNewWorkflowExecution</code>
+     * decision. It isn't set for other decision types.</p>
+     */
+    inline Decision& WithContinueAsNewWorkflowExecutionDecisionAttributes(const ContinueAsNewWorkflowExecutionDecisionAttributes& value) { SetContinueAsNewWorkflowExecutionDecisionAttributes(value); return *this;}
+
+    /**
+     * <p>Provides the details of the <code>ContinueAsNewWorkflowExecution</code>
+     * decision. It isn't set for other decision types.</p>
+     */
+    inline Decision& WithContinueAsNewWorkflowExecutionDecisionAttributes(ContinueAsNewWorkflowExecutionDecisionAttributes&& value) { SetContinueAsNewWorkflowExecutionDecisionAttributes(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Provides the details of the <code>RecordMarker</code> decision. It isn't set
+     * for other decision types.</p>
+     */
+    inline const RecordMarkerDecisionAttributes& GetRecordMarkerDecisionAttributes() const{ return m_recordMarkerDecisionAttributes; }
+
+    /**
+     * <p>Provides the details of the <code>RecordMarker</code> decision. It isn't set
+     * for other decision types.</p>
+     */
+    inline bool RecordMarkerDecisionAttributesHasBeenSet() const { return m_recordMarkerDecisionAttributesHasBeenSet; }
+
+    /**
+     * <p>Provides the details of the <code>RecordMarker</code> decision. It isn't set
+     * for other decision types.</p>
+     */
+    inline void SetRecordMarkerDecisionAttributes(const RecordMarkerDecisionAttributes& value) { m_recordMarkerDecisionAttributesHasBeenSet = true; m_recordMarkerDecisionAttributes = value; }
+
+    /**
+     * <p>Provides the details of the <code>RecordMarker</code> decision. It isn't set
+     * for other decision types.</p>
+     */
+    inline void SetRecordMarkerDecisionAttributes(RecordMarkerDecisionAttributes&& value) { m_recordMarkerDecisionAttributesHasBeenSet = true; m_recordMarkerDecisionAttributes = std::move(value); }
+
+    /**
+     * <p>Provides the details of the <code>RecordMarker</code> decision. It isn't set
+     * for other decision types.</p>
+     */
+    inline Decision& WithRecordMarkerDecisionAttributes(const RecordMarkerDecisionAttributes& value) { SetRecordMarkerDecisionAttributes(value); return *this;}
+
+    /**
+     * <p>Provides the details of the <code>RecordMarker</code> decision. It isn't set
+     * for other decision types.</p>
+     */
+    inline Decision& WithRecordMarkerDecisionAttributes(RecordMarkerDecisionAttributes&& value) { SetRecordMarkerDecisionAttributes(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Provides the details of the <code>StartTimer</code> decision. It isn't set
+     * for other decision types.</p>
+     */
+    inline const StartTimerDecisionAttributes& GetStartTimerDecisionAttributes() const{ return m_startTimerDecisionAttributes; }
+
+    /**
+     * <p>Provides the details of the <code>StartTimer</code> decision. It isn't set
+     * for other decision types.</p>
+     */
+    inline bool StartTimerDecisionAttributesHasBeenSet() const { return m_startTimerDecisionAttributesHasBeenSet; }
+
+    /**
+     * <p>Provides the details of the <code>StartTimer</code> decision. It isn't set
+     * for other decision types.</p>
+     */
+    inline void SetStartTimerDecisionAttributes(const StartTimerDecisionAttributes& value) { m_startTimerDecisionAttributesHasBeenSet = true; m_startTimerDecisionAttributes = value; }
+
+    /**
+     * <p>Provides the details of the <code>StartTimer</code> decision. It isn't set
+     * for other decision types.</p>
+     */
+    inline void SetStartTimerDecisionAttributes(StartTimerDecisionAttributes&& value) { m_startTimerDecisionAttributesHasBeenSet = true; m_startTimerDecisionAttributes = std::move(value); }
+
+    /**
+     * <p>Provides the details of the <code>StartTimer</code> decision. It isn't set
+     * for other decision types.</p>
+     */
+    inline Decision& WithStartTimerDecisionAttributes(const StartTimerDecisionAttributes& value) { SetStartTimerDecisionAttributes(value); return *this;}
+
+    /**
+     * <p>Provides the details of the <code>StartTimer</code> decision. It isn't set
+     * for other decision types.</p>
+     */
+    inline Decision& WithStartTimerDecisionAttributes(StartTimerDecisionAttributes&& value) { SetStartTimerDecisionAttributes(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Provides the details of the <code>CancelTimer</code> decision. It isn't set
+     * for other decision types.</p>
+     */
+    inline const CancelTimerDecisionAttributes& GetCancelTimerDecisionAttributes() const{ return m_cancelTimerDecisionAttributes; }
+
+    /**
+     * <p>Provides the details of the <code>CancelTimer</code> decision. It isn't set
+     * for other decision types.</p>
+     */
+    inline bool CancelTimerDecisionAttributesHasBeenSet() const { return m_cancelTimerDecisionAttributesHasBeenSet; }
+
+    /**
+     * <p>Provides the details of the <code>CancelTimer</code> decision. It isn't set
+     * for other decision types.</p>
+     */
+    inline void SetCancelTimerDecisionAttributes(const CancelTimerDecisionAttributes& value) { m_cancelTimerDecisionAttributesHasBeenSet = true; m_cancelTimerDecisionAttributes = value; }
+
+    /**
+     * <p>Provides the details of the <code>CancelTimer</code> decision. It isn't set
+     * for other decision types.</p>
+     */
+    inline void SetCancelTimerDecisionAttributes(CancelTimerDecisionAttributes&& value) { m_cancelTimerDecisionAttributesHasBeenSet = true; m_cancelTimerDecisionAttributes = std::move(value); }
+
+    /**
+     * <p>Provides the details of the <code>CancelTimer</code> decision. It isn't set
+     * for other decision types.</p>
+     */
+    inline Decision& WithCancelTimerDecisionAttributes(const CancelTimerDecisionAttributes& value) { SetCancelTimerDecisionAttributes(value); return *this;}
+
+    /**
+     * <p>Provides the details of the <code>CancelTimer</code> decision. It isn't set
+     * for other decision types.</p>
+     */
+    inline Decision& WithCancelTimerDecisionAttributes(CancelTimerDecisionAttributes&& value) { SetCancelTimerDecisionAttributes(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Provides the details of the <code>SignalExternalWorkflowExecution</code>
+     * decision. It isn't set for other decision types.</p>
+     */
+    inline const SignalExternalWorkflowExecutionDecisionAttributes& GetSignalExternalWorkflowExecutionDecisionAttributes() const{ return m_signalExternalWorkflowExecutionDecisionAttributes; }
+
+    /**
+     * <p>Provides the details of the <code>SignalExternalWorkflowExecution</code>
+     * decision. It isn't set for other decision types.</p>
+     */
+    inline bool SignalExternalWorkflowExecutionDecisionAttributesHasBeenSet() const { return m_signalExternalWorkflowExecutionDecisionAttributesHasBeenSet; }
+
+    /**
+     * <p>Provides the details of the <code>SignalExternalWorkflowExecution</code>
+     * decision. It isn't set for other decision types.</p>
+     */
+    inline void SetSignalExternalWorkflowExecutionDecisionAttributes(const SignalExternalWorkflowExecutionDecisionAttributes& value) { m_signalExternalWorkflowExecutionDecisionAttributesHasBeenSet = true; m_signalExternalWorkflowExecutionDecisionAttributes = value; }
+
+    /**
+     * <p>Provides the details of the <code>SignalExternalWorkflowExecution</code>
+     * decision. It isn't set for other decision types.</p>
+     */
+    inline void SetSignalExternalWorkflowExecutionDecisionAttributes(SignalExternalWorkflowExecutionDecisionAttributes&& value) { m_signalExternalWorkflowExecutionDecisionAttributesHasBeenSet = true; m_signalExternalWorkflowExecutionDecisionAttributes = std::move(value); }
+
+    /**
+     * <p>Provides the details of the <code>SignalExternalWorkflowExecution</code>
+     * decision. It isn't set for other decision types.</p>
+     */
+    inline Decision& WithSignalExternalWorkflowExecutionDecisionAttributes(const SignalExternalWorkflowExecutionDecisionAttributes& value) { SetSignalExternalWorkflowExecutionDecisionAttributes(value); return *this;}
+
+    /**
+     * <p>Provides the details of the <code>SignalExternalWorkflowExecution</code>
+     * decision. It isn't set for other decision types.</p>
+     */
+    inline Decision& WithSignalExternalWorkflowExecutionDecisionAttributes(SignalExternalWorkflowExecutionDecisionAttributes&& value) { SetSignalExternalWorkflowExecutionDecisionAttributes(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Provides the details of the
+     * <code>RequestCancelExternalWorkflowExecution</code> decision. It isn't set for
+     * other decision types.</p>
+     */
+    inline const RequestCancelExternalWorkflowExecutionDecisionAttributes& GetRequestCancelExternalWorkflowExecutionDecisionAttributes() const{ return m_requestCancelExternalWorkflowExecutionDecisionAttributes; }
+
+    /**
+     * <p>Provides the details of the
+     * <code>RequestCancelExternalWorkflowExecution</code> decision. It isn't set for
+     * other decision types.</p>
+     */
+    inline bool RequestCancelExternalWorkflowExecutionDecisionAttributesHasBeenSet() const { return m_requestCancelExternalWorkflowExecutionDecisionAttributesHasBeenSet; }
+
+    /**
+     * <p>Provides the details of the
+     * <code>RequestCancelExternalWorkflowExecution</code> decision. It isn't set for
+     * other decision types.</p>
+     */
+    inline void SetRequestCancelExternalWorkflowExecutionDecisionAttributes(const RequestCancelExternalWorkflowExecutionDecisionAttributes& value) { m_requestCancelExternalWorkflowExecutionDecisionAttributesHasBeenSet = true; m_requestCancelExternalWorkflowExecutionDecisionAttributes = value; }
+
+    /**
+     * <p>Provides the details of the
+     * <code>RequestCancelExternalWorkflowExecution</code> decision. It isn't set for
+     * other decision types.</p>
+     */
+    inline void SetRequestCancelExternalWorkflowExecutionDecisionAttributes(RequestCancelExternalWorkflowExecutionDecisionAttributes&& value) { m_requestCancelExternalWorkflowExecutionDecisionAttributesHasBeenSet = true; m_requestCancelExternalWorkflowExecutionDecisionAttributes = std::move(value); }
+
+    /**
+     * <p>Provides the details of the
+     * <code>RequestCancelExternalWorkflowExecution</code> decision. It isn't set for
+     * other decision types.</p>
+     */
+    inline Decision& WithRequestCancelExternalWorkflowExecutionDecisionAttributes(const RequestCancelExternalWorkflowExecutionDecisionAttributes& value) { SetRequestCancelExternalWorkflowExecutionDecisionAttributes(value); return *this;}
+
+    /**
+     * <p>Provides the details of the
+     * <code>RequestCancelExternalWorkflowExecution</code> decision. It isn't set for
+     * other decision types.</p>
+     */
+    inline Decision& WithRequestCancelExternalWorkflowExecutionDecisionAttributes(RequestCancelExternalWorkflowExecutionDecisionAttributes&& value) { SetRequestCancelExternalWorkflowExecutionDecisionAttributes(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Provides the details of the <code>StartChildWorkflowExecution</code>
+     * decision. It isn't set for other decision types.</p>
+     */
+    inline const StartChildWorkflowExecutionDecisionAttributes& GetStartChildWorkflowExecutionDecisionAttributes() const{ return m_startChildWorkflowExecutionDecisionAttributes; }
+
+    /**
+     * <p>Provides the details of the <code>StartChildWorkflowExecution</code>
+     * decision. It isn't set for other decision types.</p>
+     */
+    inline bool StartChildWorkflowExecutionDecisionAttributesHasBeenSet() const { return m_startChildWorkflowExecutionDecisionAttributesHasBeenSet; }
+
+    /**
+     * <p>Provides the details of the <code>StartChildWorkflowExecution</code>
+     * decision. It isn't set for other decision types.</p>
+     */
+    inline void SetStartChildWorkflowExecutionDecisionAttributes(const StartChildWorkflowExecutionDecisionAttributes& value) { m_startChildWorkflowExecutionDecisionAttributesHasBeenSet = true; m_startChildWorkflowExecutionDecisionAttributes = value; }
+
+    /**
+     * <p>Provides the details of the <code>StartChildWorkflowExecution</code>
+     * decision. It isn't set for other decision types.</p>
+     */
+    inline void SetStartChildWorkflowExecutionDecisionAttributes(StartChildWorkflowExecutionDecisionAttributes&& value) { m_startChildWorkflowExecutionDecisionAttributesHasBeenSet = true; m_startChildWorkflowExecutionDecisionAttributes = std::move(value); }
+
+    /**
+     * <p>Provides the details of the <code>StartChildWorkflowExecution</code>
+     * decision. It isn't set for other decision types.</p>
+     */
+    inline Decision& WithStartChildWorkflowExecutionDecisionAttributes(const StartChildWorkflowExecutionDecisionAttributes& value) { SetStartChildWorkflowExecutionDecisionAttributes(value); return *this;}
+
+    /**
+     * <p>Provides the details of the <code>StartChildWorkflowExecution</code>
+     * decision. It isn't set for other decision types.</p>
+     */
+    inline Decision& WithStartChildWorkflowExecutionDecisionAttributes(StartChildWorkflowExecutionDecisionAttributes&& value) { SetStartChildWorkflowExecutionDecisionAttributes(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Provides the details of the <code>ScheduleLambdaFunction</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline const ScheduleLambdaFunctionDecisionAttributes& GetScheduleLambdaFunctionDecisionAttributes() const{ return m_scheduleLambdaFunctionDecisionAttributes; }
+
+    /**
+     * <p>Provides the details of the <code>ScheduleLambdaFunction</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline bool ScheduleLambdaFunctionDecisionAttributesHasBeenSet() const { return m_scheduleLambdaFunctionDecisionAttributesHasBeenSet; }
+
+    /**
+     * <p>Provides the details of the <code>ScheduleLambdaFunction</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline void SetScheduleLambdaFunctionDecisionAttributes(const ScheduleLambdaFunctionDecisionAttributes& value) { m_scheduleLambdaFunctionDecisionAttributesHasBeenSet = true; m_scheduleLambdaFunctionDecisionAttributes = value; }
+
+    /**
+     * <p>Provides the details of the <code>ScheduleLambdaFunction</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline void SetScheduleLambdaFunctionDecisionAttributes(ScheduleLambdaFunctionDecisionAttributes&& value) { m_scheduleLambdaFunctionDecisionAttributesHasBeenSet = true; m_scheduleLambdaFunctionDecisionAttributes = std::move(value); }
+
+    /**
+     * <p>Provides the details of the <code>ScheduleLambdaFunction</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline Decision& WithScheduleLambdaFunctionDecisionAttributes(const ScheduleLambdaFunctionDecisionAttributes& value) { SetScheduleLambdaFunctionDecisionAttributes(value); return *this;}
+
+    /**
+     * <p>Provides the details of the <code>ScheduleLambdaFunction</code> decision. It
+     * isn't set for other decision types.</p>
+     */
+    inline Decision& WithScheduleLambdaFunctionDecisionAttributes(ScheduleLambdaFunctionDecisionAttributes&& value) { SetScheduleLambdaFunctionDecisionAttributes(std::move(value)); return *this;}
+
+  private:
+
+    DecisionType m_decisionType;
+    bool m_decisionTypeHasBeenSet;
+
+    ScheduleActivityTaskDecisionAttributes m_scheduleActivityTaskDecisionAttributes;
+    bool m_scheduleActivityTaskDecisionAttributesHasBeenSet;
+
+    RequestCancelActivityTaskDecisionAttributes m_requestCancelActivityTaskDecisionAttributes;
+    bool m_requestCancelActivityTaskDecisionAttributesHasBeenSet;
+
+    CompleteWorkflowExecutionDecisionAttributes m_completeWorkflowExecutionDecisionAttributes;
+    bool m_completeWorkflowExecutionDecisionAttributesHasBeenSet;
+
+    FailWorkflowExecutionDecisionAttributes m_failWorkflowExecutionDecisionAttributes;
+    bool m_failWorkflowExecutionDecisionAttributesHasBeenSet;
+
+    CancelWorkflowExecutionDecisionAttributes m_cancelWorkflowExecutionDecisionAttributes;
+    bool m_cancelWorkflowExecutionDecisionAttributesHasBeenSet;
+
+    ContinueAsNewWorkflowExecutionDecisionAttributes m_continueAsNewWorkflowExecutionDecisionAttributes;
+    bool m_continueAsNewWorkflowExecutionDecisionAttributesHasBeenSet;
+
+    RecordMarkerDecisionAttributes m_recordMarkerDecisionAttributes;
+    bool m_recordMarkerDecisionAttributesHasBeenSet;
+
+    StartTimerDecisionAttributes m_startTimerDecisionAttributes;
+    bool m_startTimerDecisionAttributesHasBeenSet;
+
+    CancelTimerDecisionAttributes m_cancelTimerDecisionAttributes;
+    bool m_cancelTimerDecisionAttributesHasBeenSet;
+
+    SignalExternalWorkflowExecutionDecisionAttributes m_signalExternalWorkflowExecutionDecisionAttributes;
+    bool m_signalExternalWorkflowExecutionDecisionAttributesHasBeenSet;
+
+    RequestCancelExternalWorkflowExecutionDecisionAttributes m_requestCancelExternalWorkflowExecutionDecisionAttributes;
+    bool m_requestCancelExternalWorkflowExecutionDecisionAttributesHasBeenSet;
+
+    StartChildWorkflowExecutionDecisionAttributes m_startChildWorkflowExecutionDecisionAttributes;
+    bool m_startChildWorkflowExecutionDecisionAttributesHasBeenSet;
+
+    ScheduleLambdaFunctionDecisionAttributes m_scheduleLambdaFunctionDecisionAttributes;
+    bool m_scheduleLambdaFunctionDecisionAttributesHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/DecisionTaskCompletedEventAttributes.h

@@ -0,0 +1,153 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>DecisionTaskCompleted</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DecisionTaskCompletedEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API DecisionTaskCompletedEventAttributes
+  {
+  public:
+    DecisionTaskCompletedEventAttributes();
+    DecisionTaskCompletedEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    DecisionTaskCompletedEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>User defined context for the workflow execution.</p>
+     */
+    inline const Aws::String& GetExecutionContext() const{ return m_executionContext; }
+
+    /**
+     * <p>User defined context for the workflow execution.</p>
+     */
+    inline bool ExecutionContextHasBeenSet() const { return m_executionContextHasBeenSet; }
+
+    /**
+     * <p>User defined context for the workflow execution.</p>
+     */
+    inline void SetExecutionContext(const Aws::String& value) { m_executionContextHasBeenSet = true; m_executionContext = value; }
+
+    /**
+     * <p>User defined context for the workflow execution.</p>
+     */
+    inline void SetExecutionContext(Aws::String&& value) { m_executionContextHasBeenSet = true; m_executionContext = std::move(value); }
+
+    /**
+     * <p>User defined context for the workflow execution.</p>
+     */
+    inline void SetExecutionContext(const char* value) { m_executionContextHasBeenSet = true; m_executionContext.assign(value); }
+
+    /**
+     * <p>User defined context for the workflow execution.</p>
+     */
+    inline DecisionTaskCompletedEventAttributes& WithExecutionContext(const Aws::String& value) { SetExecutionContext(value); return *this;}
+
+    /**
+     * <p>User defined context for the workflow execution.</p>
+     */
+    inline DecisionTaskCompletedEventAttributes& WithExecutionContext(Aws::String&& value) { SetExecutionContext(std::move(value)); return *this;}
+
+    /**
+     * <p>User defined context for the workflow execution.</p>
+     */
+    inline DecisionTaskCompletedEventAttributes& WithExecutionContext(const char* value) { SetExecutionContext(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>DecisionTaskScheduled</code> event that was recorded when
+     * this decision task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline long long GetScheduledEventId() const{ return m_scheduledEventId; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskScheduled</code> event that was recorded when
+     * this decision task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline bool ScheduledEventIdHasBeenSet() const { return m_scheduledEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskScheduled</code> event that was recorded when
+     * this decision task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline void SetScheduledEventId(long long value) { m_scheduledEventIdHasBeenSet = true; m_scheduledEventId = value; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskScheduled</code> event that was recorded when
+     * this decision task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline DecisionTaskCompletedEventAttributes& WithScheduledEventId(long long value) { SetScheduledEventId(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>DecisionTaskStarted</code> event recorded when this
+     * decision task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline long long GetStartedEventId() const{ return m_startedEventId; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskStarted</code> event recorded when this
+     * decision task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline bool StartedEventIdHasBeenSet() const { return m_startedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskStarted</code> event recorded when this
+     * decision task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline void SetStartedEventId(long long value) { m_startedEventIdHasBeenSet = true; m_startedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskStarted</code> event recorded when this
+     * decision task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline DecisionTaskCompletedEventAttributes& WithStartedEventId(long long value) { SetStartedEventId(value); return *this;}
+
+  private:
+
+    Aws::String m_executionContext;
+    bool m_executionContextHasBeenSet;
+
+    long long m_scheduledEventId;
+    bool m_scheduledEventIdHasBeenSet;
+
+    long long m_startedEventId;
+    bool m_startedEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/DecisionTaskScheduledEventAttributes.h

@@ -0,0 +1,240 @@
+/**
+ * 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/model/TaskList.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides details about the <code>DecisionTaskScheduled</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DecisionTaskScheduledEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API DecisionTaskScheduledEventAttributes
+  {
+  public:
+    DecisionTaskScheduledEventAttributes();
+    DecisionTaskScheduledEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    DecisionTaskScheduledEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the task list in which the decision task was scheduled.</p>
+     */
+    inline const TaskList& GetTaskList() const{ return m_taskList; }
+
+    /**
+     * <p>The name of the task list in which the decision task was scheduled.</p>
+     */
+    inline bool TaskListHasBeenSet() const { return m_taskListHasBeenSet; }
+
+    /**
+     * <p>The name of the task list in which the decision task was scheduled.</p>
+     */
+    inline void SetTaskList(const TaskList& value) { m_taskListHasBeenSet = true; m_taskList = value; }
+
+    /**
+     * <p>The name of the task list in which the decision task was scheduled.</p>
+     */
+    inline void SetTaskList(TaskList&& value) { m_taskListHasBeenSet = true; m_taskList = std::move(value); }
+
+    /**
+     * <p>The name of the task list in which the decision task was scheduled.</p>
+     */
+    inline DecisionTaskScheduledEventAttributes& WithTaskList(const TaskList& value) { SetTaskList(value); return *this;}
+
+    /**
+     * <p>The name of the task list in which the decision task was scheduled.</p>
+     */
+    inline DecisionTaskScheduledEventAttributes& WithTaskList(TaskList&& value) { SetTaskList(std::move(value)); return *this;}
+
+
+    /**
+     * <p> A task priority that, if set, specifies the priority for this decision task.
+     * Valid values are integers that range from Java's <code>Integer.MIN_VALUE</code>
+     * (-2147483648) to <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers
+     * indicate higher priority.</p> <p>For more information about setting task
+     * priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline const Aws::String& GetTaskPriority() const{ return m_taskPriority; }
+
+    /**
+     * <p> A task priority that, if set, specifies the priority for this decision task.
+     * Valid values are integers that range from Java's <code>Integer.MIN_VALUE</code>
+     * (-2147483648) to <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers
+     * indicate higher priority.</p> <p>For more information about setting task
+     * priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline bool TaskPriorityHasBeenSet() const { return m_taskPriorityHasBeenSet; }
+
+    /**
+     * <p> A task priority that, if set, specifies the priority for this decision task.
+     * Valid values are integers that range from Java's <code>Integer.MIN_VALUE</code>
+     * (-2147483648) to <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers
+     * indicate higher priority.</p> <p>For more information about setting task
+     * priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline void SetTaskPriority(const Aws::String& value) { m_taskPriorityHasBeenSet = true; m_taskPriority = value; }
+
+    /**
+     * <p> A task priority that, if set, specifies the priority for this decision task.
+     * Valid values are integers that range from Java's <code>Integer.MIN_VALUE</code>
+     * (-2147483648) to <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers
+     * indicate higher priority.</p> <p>For more information about setting task
+     * priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline void SetTaskPriority(Aws::String&& value) { m_taskPriorityHasBeenSet = true; m_taskPriority = std::move(value); }
+
+    /**
+     * <p> A task priority that, if set, specifies the priority for this decision task.
+     * Valid values are integers that range from Java's <code>Integer.MIN_VALUE</code>
+     * (-2147483648) to <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers
+     * indicate higher priority.</p> <p>For more information about setting task
+     * priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline void SetTaskPriority(const char* value) { m_taskPriorityHasBeenSet = true; m_taskPriority.assign(value); }
+
+    /**
+     * <p> A task priority that, if set, specifies the priority for this decision task.
+     * Valid values are integers that range from Java's <code>Integer.MIN_VALUE</code>
+     * (-2147483648) to <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers
+     * indicate higher priority.</p> <p>For more information about setting task
+     * priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline DecisionTaskScheduledEventAttributes& WithTaskPriority(const Aws::String& value) { SetTaskPriority(value); return *this;}
+
+    /**
+     * <p> A task priority that, if set, specifies the priority for this decision task.
+     * Valid values are integers that range from Java's <code>Integer.MIN_VALUE</code>
+     * (-2147483648) to <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers
+     * indicate higher priority.</p> <p>For more information about setting task
+     * priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline DecisionTaskScheduledEventAttributes& WithTaskPriority(Aws::String&& value) { SetTaskPriority(std::move(value)); return *this;}
+
+    /**
+     * <p> A task priority that, if set, specifies the priority for this decision task.
+     * Valid values are integers that range from Java's <code>Integer.MIN_VALUE</code>
+     * (-2147483648) to <code>Integer.MAX_VALUE</code> (2147483647). Higher numbers
+     * indicate higher priority.</p> <p>For more information about setting task
+     * priority, see <a
+     * href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/programming-priority.html">Setting
+     * Task Priority</a> in the <i>Amazon SWF Developer Guide</i>.</p>
+     */
+    inline DecisionTaskScheduledEventAttributes& WithTaskPriority(const char* value) { SetTaskPriority(value); return *this;}
+
+
+    /**
+     * <p>The maximum duration for this decision task. The task is considered timed out
+     * if it doesn't completed within this duration.</p> <p>The duration is specified
+     * in seconds, an integer greater than or equal to <code>0</code>. You can use
+     * <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline const Aws::String& GetStartToCloseTimeout() const{ return m_startToCloseTimeout; }
+
+    /**
+     * <p>The maximum duration for this decision task. The task is considered timed out
+     * if it doesn't completed within this duration.</p> <p>The duration is specified
+     * in seconds, an integer greater than or equal to <code>0</code>. You can use
+     * <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline bool StartToCloseTimeoutHasBeenSet() const { return m_startToCloseTimeoutHasBeenSet; }
+
+    /**
+     * <p>The maximum duration for this decision task. The task is considered timed out
+     * if it doesn't completed within this duration.</p> <p>The duration is specified
+     * in seconds, an integer greater than or equal to <code>0</code>. You can use
+     * <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline void SetStartToCloseTimeout(const Aws::String& value) { m_startToCloseTimeoutHasBeenSet = true; m_startToCloseTimeout = value; }
+
+    /**
+     * <p>The maximum duration for this decision task. The task is considered timed out
+     * if it doesn't completed within this duration.</p> <p>The duration is specified
+     * in seconds, an integer greater than or equal to <code>0</code>. You can use
+     * <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline void SetStartToCloseTimeout(Aws::String&& value) { m_startToCloseTimeoutHasBeenSet = true; m_startToCloseTimeout = std::move(value); }
+
+    /**
+     * <p>The maximum duration for this decision task. The task is considered timed out
+     * if it doesn't completed within this duration.</p> <p>The duration is specified
+     * in seconds, an integer greater than or equal to <code>0</code>. You can use
+     * <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline void SetStartToCloseTimeout(const char* value) { m_startToCloseTimeoutHasBeenSet = true; m_startToCloseTimeout.assign(value); }
+
+    /**
+     * <p>The maximum duration for this decision task. The task is considered timed out
+     * if it doesn't completed within this duration.</p> <p>The duration is specified
+     * in seconds, an integer greater than or equal to <code>0</code>. You can use
+     * <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline DecisionTaskScheduledEventAttributes& WithStartToCloseTimeout(const Aws::String& value) { SetStartToCloseTimeout(value); return *this;}
+
+    /**
+     * <p>The maximum duration for this decision task. The task is considered timed out
+     * if it doesn't completed within this duration.</p> <p>The duration is specified
+     * in seconds, an integer greater than or equal to <code>0</code>. You can use
+     * <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline DecisionTaskScheduledEventAttributes& WithStartToCloseTimeout(Aws::String&& value) { SetStartToCloseTimeout(std::move(value)); return *this;}
+
+    /**
+     * <p>The maximum duration for this decision task. The task is considered timed out
+     * if it doesn't completed within this duration.</p> <p>The duration is specified
+     * in seconds, an integer greater than or equal to <code>0</code>. You can use
+     * <code>NONE</code> to specify unlimited duration.</p>
+     */
+    inline DecisionTaskScheduledEventAttributes& WithStartToCloseTimeout(const char* value) { SetStartToCloseTimeout(value); return *this;}
+
+  private:
+
+    TaskList m_taskList;
+    bool m_taskListHasBeenSet;
+
+    Aws::String m_taskPriority;
+    bool m_taskPriorityHasBeenSet;
+
+    Aws::String m_startToCloseTimeout;
+    bool m_startToCloseTimeoutHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/DecisionTaskStartedEventAttributes.h

@@ -0,0 +1,129 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>DecisionTaskStarted</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DecisionTaskStartedEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API DecisionTaskStartedEventAttributes
+  {
+  public:
+    DecisionTaskStartedEventAttributes();
+    DecisionTaskStartedEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    DecisionTaskStartedEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Identity of the decider making the request. This enables diagnostic tracing
+     * when problems arise. The form of this identity is user defined.</p>
+     */
+    inline const Aws::String& GetIdentity() const{ return m_identity; }
+
+    /**
+     * <p>Identity of the decider making the request. This enables diagnostic tracing
+     * when problems arise. The form of this identity is user defined.</p>
+     */
+    inline bool IdentityHasBeenSet() const { return m_identityHasBeenSet; }
+
+    /**
+     * <p>Identity of the decider making the request. This enables diagnostic tracing
+     * when problems arise. The form of this identity is user defined.</p>
+     */
+    inline void SetIdentity(const Aws::String& value) { m_identityHasBeenSet = true; m_identity = value; }
+
+    /**
+     * <p>Identity of the decider making the request. This enables diagnostic tracing
+     * when problems arise. The form of this identity is user defined.</p>
+     */
+    inline void SetIdentity(Aws::String&& value) { m_identityHasBeenSet = true; m_identity = std::move(value); }
+
+    /**
+     * <p>Identity of the decider making the request. This enables diagnostic tracing
+     * when problems arise. The form of this identity is user defined.</p>
+     */
+    inline void SetIdentity(const char* value) { m_identityHasBeenSet = true; m_identity.assign(value); }
+
+    /**
+     * <p>Identity of the decider making the request. This enables diagnostic tracing
+     * when problems arise. The form of this identity is user defined.</p>
+     */
+    inline DecisionTaskStartedEventAttributes& WithIdentity(const Aws::String& value) { SetIdentity(value); return *this;}
+
+    /**
+     * <p>Identity of the decider making the request. This enables diagnostic tracing
+     * when problems arise. The form of this identity is user defined.</p>
+     */
+    inline DecisionTaskStartedEventAttributes& WithIdentity(Aws::String&& value) { SetIdentity(std::move(value)); return *this;}
+
+    /**
+     * <p>Identity of the decider making the request. This enables diagnostic tracing
+     * when problems arise. The form of this identity is user defined.</p>
+     */
+    inline DecisionTaskStartedEventAttributes& WithIdentity(const char* value) { SetIdentity(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>DecisionTaskScheduled</code> event that was recorded when
+     * this decision task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline long long GetScheduledEventId() const{ return m_scheduledEventId; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskScheduled</code> event that was recorded when
+     * this decision task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline bool ScheduledEventIdHasBeenSet() const { return m_scheduledEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskScheduled</code> event that was recorded when
+     * this decision task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline void SetScheduledEventId(long long value) { m_scheduledEventIdHasBeenSet = true; m_scheduledEventId = value; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskScheduled</code> event that was recorded when
+     * this decision task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline DecisionTaskStartedEventAttributes& WithScheduledEventId(long long value) { SetScheduledEventId(value); return *this;}
+
+  private:
+
+    Aws::String m_identity;
+    bool m_identityHasBeenSet;
+
+    long long m_scheduledEventId;
+    bool m_scheduledEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/DecisionTaskTimedOutEventAttributes.h

@@ -0,0 +1,149 @@
+/**
+ * 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/model/DecisionTaskTimeoutType.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>DecisionTaskTimedOut</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DecisionTaskTimedOutEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API DecisionTaskTimedOutEventAttributes
+  {
+  public:
+    DecisionTaskTimedOutEventAttributes();
+    DecisionTaskTimedOutEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    DecisionTaskTimedOutEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The type of timeout that expired before the decision task could be
+     * completed.</p>
+     */
+    inline const DecisionTaskTimeoutType& GetTimeoutType() const{ return m_timeoutType; }
+
+    /**
+     * <p>The type of timeout that expired before the decision task could be
+     * completed.</p>
+     */
+    inline bool TimeoutTypeHasBeenSet() const { return m_timeoutTypeHasBeenSet; }
+
+    /**
+     * <p>The type of timeout that expired before the decision task could be
+     * completed.</p>
+     */
+    inline void SetTimeoutType(const DecisionTaskTimeoutType& value) { m_timeoutTypeHasBeenSet = true; m_timeoutType = value; }
+
+    /**
+     * <p>The type of timeout that expired before the decision task could be
+     * completed.</p>
+     */
+    inline void SetTimeoutType(DecisionTaskTimeoutType&& value) { m_timeoutTypeHasBeenSet = true; m_timeoutType = std::move(value); }
+
+    /**
+     * <p>The type of timeout that expired before the decision task could be
+     * completed.</p>
+     */
+    inline DecisionTaskTimedOutEventAttributes& WithTimeoutType(const DecisionTaskTimeoutType& value) { SetTimeoutType(value); return *this;}
+
+    /**
+     * <p>The type of timeout that expired before the decision task could be
+     * completed.</p>
+     */
+    inline DecisionTaskTimedOutEventAttributes& WithTimeoutType(DecisionTaskTimeoutType&& value) { SetTimeoutType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>DecisionTaskScheduled</code> event that was recorded when
+     * this decision task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline long long GetScheduledEventId() const{ return m_scheduledEventId; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskScheduled</code> event that was recorded when
+     * this decision task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline bool ScheduledEventIdHasBeenSet() const { return m_scheduledEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskScheduled</code> event that was recorded when
+     * this decision task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline void SetScheduledEventId(long long value) { m_scheduledEventIdHasBeenSet = true; m_scheduledEventId = value; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskScheduled</code> event that was recorded when
+     * this decision task was scheduled. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline DecisionTaskTimedOutEventAttributes& WithScheduledEventId(long long value) { SetScheduledEventId(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>DecisionTaskStarted</code> event recorded when this
+     * decision task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline long long GetStartedEventId() const{ return m_startedEventId; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskStarted</code> event recorded when this
+     * decision task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline bool StartedEventIdHasBeenSet() const { return m_startedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskStarted</code> event recorded when this
+     * decision task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline void SetStartedEventId(long long value) { m_startedEventIdHasBeenSet = true; m_startedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskStarted</code> event recorded when this
+     * decision task was started. This information can be useful for diagnosing
+     * problems by tracing back the chain of events leading up to this event.</p>
+     */
+    inline DecisionTaskTimedOutEventAttributes& WithStartedEventId(long long value) { SetStartedEventId(value); return *this;}
+
+  private:
+
+    DecisionTaskTimeoutType m_timeoutType;
+    bool m_timeoutTypeHasBeenSet;
+
+    long long m_scheduledEventId;
+    bool m_scheduledEventIdHasBeenSet;
+
+    long long m_startedEventId;
+    bool m_startedEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/DecisionTaskTimeoutType.h

@@ -0,0 +1,30 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+  enum class DecisionTaskTimeoutType
+  {
+    NOT_SET,
+    START_TO_CLOSE
+  };
+
+namespace DecisionTaskTimeoutTypeMapper
+{
+AWS_SWF_API DecisionTaskTimeoutType GetDecisionTaskTimeoutTypeForName(const Aws::String& name);
+
+AWS_SWF_API Aws::String GetNameForDecisionTaskTimeoutType(DecisionTaskTimeoutType value);
+} // namespace DecisionTaskTimeoutTypeMapper
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/DecisionType.h

@@ -0,0 +1,42 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+  enum class DecisionType
+  {
+    NOT_SET,
+    ScheduleActivityTask,
+    RequestCancelActivityTask,
+    CompleteWorkflowExecution,
+    FailWorkflowExecution,
+    CancelWorkflowExecution,
+    ContinueAsNewWorkflowExecution,
+    RecordMarker,
+    StartTimer,
+    CancelTimer,
+    SignalExternalWorkflowExecution,
+    RequestCancelExternalWorkflowExecution,
+    StartChildWorkflowExecution,
+    ScheduleLambdaFunction
+  };
+
+namespace DecisionTypeMapper
+{
+AWS_SWF_API DecisionType GetDecisionTypeForName(const Aws::String& name);
+
+AWS_SWF_API Aws::String GetNameForDecisionType(DecisionType value);
+} // namespace DecisionTypeMapper
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/DeprecateActivityTypeRequest.h

@@ -0,0 +1,120 @@
+/**
+ * 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/SWFRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/ActivityType.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SWF_API DeprecateActivityTypeRequest : public SWFRequest
+  {
+  public:
+    DeprecateActivityTypeRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeprecateActivityType"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the domain in which the activity type is registered.</p>
+     */
+    inline const Aws::String& GetDomain() const{ return m_domain; }
+
+    /**
+     * <p>The name of the domain in which the activity type is registered.</p>
+     */
+    inline bool DomainHasBeenSet() const { return m_domainHasBeenSet; }
+
+    /**
+     * <p>The name of the domain in which the activity type is registered.</p>
+     */
+    inline void SetDomain(const Aws::String& value) { m_domainHasBeenSet = true; m_domain = value; }
+
+    /**
+     * <p>The name of the domain in which the activity type is registered.</p>
+     */
+    inline void SetDomain(Aws::String&& value) { m_domainHasBeenSet = true; m_domain = std::move(value); }
+
+    /**
+     * <p>The name of the domain in which the activity type is registered.</p>
+     */
+    inline void SetDomain(const char* value) { m_domainHasBeenSet = true; m_domain.assign(value); }
+
+    /**
+     * <p>The name of the domain in which the activity type is registered.</p>
+     */
+    inline DeprecateActivityTypeRequest& WithDomain(const Aws::String& value) { SetDomain(value); return *this;}
+
+    /**
+     * <p>The name of the domain in which the activity type is registered.</p>
+     */
+    inline DeprecateActivityTypeRequest& WithDomain(Aws::String&& value) { SetDomain(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the domain in which the activity type is registered.</p>
+     */
+    inline DeprecateActivityTypeRequest& WithDomain(const char* value) { SetDomain(value); return *this;}
+
+
+    /**
+     * <p>The activity type to deprecate.</p>
+     */
+    inline const ActivityType& GetActivityType() const{ return m_activityType; }
+
+    /**
+     * <p>The activity type to deprecate.</p>
+     */
+    inline bool ActivityTypeHasBeenSet() const { return m_activityTypeHasBeenSet; }
+
+    /**
+     * <p>The activity type to deprecate.</p>
+     */
+    inline void SetActivityType(const ActivityType& value) { m_activityTypeHasBeenSet = true; m_activityType = value; }
+
+    /**
+     * <p>The activity type to deprecate.</p>
+     */
+    inline void SetActivityType(ActivityType&& value) { m_activityTypeHasBeenSet = true; m_activityType = std::move(value); }
+
+    /**
+     * <p>The activity type to deprecate.</p>
+     */
+    inline DeprecateActivityTypeRequest& WithActivityType(const ActivityType& value) { SetActivityType(value); return *this;}
+
+    /**
+     * <p>The activity type to deprecate.</p>
+     */
+    inline DeprecateActivityTypeRequest& WithActivityType(ActivityType&& value) { SetActivityType(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_domain;
+    bool m_domainHasBeenSet;
+
+    ActivityType m_activityType;
+    bool m_activityTypeHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/DeprecateDomainRequest.h

@@ -0,0 +1,85 @@
+/**
+ * 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/SWFRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SWF_API DeprecateDomainRequest : public SWFRequest
+  {
+  public:
+    DeprecateDomainRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeprecateDomain"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the domain to deprecate.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>The name of the domain to deprecate.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>The name of the domain to deprecate.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>The name of the domain to deprecate.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>The name of the domain to deprecate.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>The name of the domain to deprecate.</p>
+     */
+    inline DeprecateDomainRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>The name of the domain to deprecate.</p>
+     */
+    inline DeprecateDomainRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the domain to deprecate.</p>
+     */
+    inline DeprecateDomainRequest& WithName(const char* value) { SetName(value); return *this;}
+
+  private:
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/DeprecateWorkflowTypeRequest.h

@@ -0,0 +1,120 @@
+/**
+ * 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/SWFRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/WorkflowType.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SWF_API DeprecateWorkflowTypeRequest : public SWFRequest
+  {
+  public:
+    DeprecateWorkflowTypeRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeprecateWorkflowType"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the domain in which the workflow type is registered.</p>
+     */
+    inline const Aws::String& GetDomain() const{ return m_domain; }
+
+    /**
+     * <p>The name of the domain in which the workflow type is registered.</p>
+     */
+    inline bool DomainHasBeenSet() const { return m_domainHasBeenSet; }
+
+    /**
+     * <p>The name of the domain in which the workflow type is registered.</p>
+     */
+    inline void SetDomain(const Aws::String& value) { m_domainHasBeenSet = true; m_domain = value; }
+
+    /**
+     * <p>The name of the domain in which the workflow type is registered.</p>
+     */
+    inline void SetDomain(Aws::String&& value) { m_domainHasBeenSet = true; m_domain = std::move(value); }
+
+    /**
+     * <p>The name of the domain in which the workflow type is registered.</p>
+     */
+    inline void SetDomain(const char* value) { m_domainHasBeenSet = true; m_domain.assign(value); }
+
+    /**
+     * <p>The name of the domain in which the workflow type is registered.</p>
+     */
+    inline DeprecateWorkflowTypeRequest& WithDomain(const Aws::String& value) { SetDomain(value); return *this;}
+
+    /**
+     * <p>The name of the domain in which the workflow type is registered.</p>
+     */
+    inline DeprecateWorkflowTypeRequest& WithDomain(Aws::String&& value) { SetDomain(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the domain in which the workflow type is registered.</p>
+     */
+    inline DeprecateWorkflowTypeRequest& WithDomain(const char* value) { SetDomain(value); return *this;}
+
+
+    /**
+     * <p>The workflow type to deprecate.</p>
+     */
+    inline const WorkflowType& GetWorkflowType() const{ return m_workflowType; }
+
+    /**
+     * <p>The workflow type to deprecate.</p>
+     */
+    inline bool WorkflowTypeHasBeenSet() const { return m_workflowTypeHasBeenSet; }
+
+    /**
+     * <p>The workflow type to deprecate.</p>
+     */
+    inline void SetWorkflowType(const WorkflowType& value) { m_workflowTypeHasBeenSet = true; m_workflowType = value; }
+
+    /**
+     * <p>The workflow type to deprecate.</p>
+     */
+    inline void SetWorkflowType(WorkflowType&& value) { m_workflowTypeHasBeenSet = true; m_workflowType = std::move(value); }
+
+    /**
+     * <p>The workflow type to deprecate.</p>
+     */
+    inline DeprecateWorkflowTypeRequest& WithWorkflowType(const WorkflowType& value) { SetWorkflowType(value); return *this;}
+
+    /**
+     * <p>The workflow type to deprecate.</p>
+     */
+    inline DeprecateWorkflowTypeRequest& WithWorkflowType(WorkflowType&& value) { SetWorkflowType(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_domain;
+    bool m_domainHasBeenSet;
+
+    WorkflowType m_workflowType;
+    bool m_workflowTypeHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/DescribeActivityTypeRequest.h

@@ -0,0 +1,132 @@
+/**
+ * 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/SWFRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/ActivityType.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SWF_API DescribeActivityTypeRequest : public SWFRequest
+  {
+  public:
+    DescribeActivityTypeRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DescribeActivityType"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the domain in which the activity type is registered.</p>
+     */
+    inline const Aws::String& GetDomain() const{ return m_domain; }
+
+    /**
+     * <p>The name of the domain in which the activity type is registered.</p>
+     */
+    inline bool DomainHasBeenSet() const { return m_domainHasBeenSet; }
+
+    /**
+     * <p>The name of the domain in which the activity type is registered.</p>
+     */
+    inline void SetDomain(const Aws::String& value) { m_domainHasBeenSet = true; m_domain = value; }
+
+    /**
+     * <p>The name of the domain in which the activity type is registered.</p>
+     */
+    inline void SetDomain(Aws::String&& value) { m_domainHasBeenSet = true; m_domain = std::move(value); }
+
+    /**
+     * <p>The name of the domain in which the activity type is registered.</p>
+     */
+    inline void SetDomain(const char* value) { m_domainHasBeenSet = true; m_domain.assign(value); }
+
+    /**
+     * <p>The name of the domain in which the activity type is registered.</p>
+     */
+    inline DescribeActivityTypeRequest& WithDomain(const Aws::String& value) { SetDomain(value); return *this;}
+
+    /**
+     * <p>The name of the domain in which the activity type is registered.</p>
+     */
+    inline DescribeActivityTypeRequest& WithDomain(Aws::String&& value) { SetDomain(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the domain in which the activity type is registered.</p>
+     */
+    inline DescribeActivityTypeRequest& WithDomain(const char* value) { SetDomain(value); return *this;}
+
+
+    /**
+     * <p>The activity type to get information about. Activity types are identified by
+     * the <code>name</code> and <code>version</code> that were supplied when the
+     * activity was registered.</p>
+     */
+    inline const ActivityType& GetActivityType() const{ return m_activityType; }
+
+    /**
+     * <p>The activity type to get information about. Activity types are identified by
+     * the <code>name</code> and <code>version</code> that were supplied when the
+     * activity was registered.</p>
+     */
+    inline bool ActivityTypeHasBeenSet() const { return m_activityTypeHasBeenSet; }
+
+    /**
+     * <p>The activity type to get information about. Activity types are identified by
+     * the <code>name</code> and <code>version</code> that were supplied when the
+     * activity was registered.</p>
+     */
+    inline void SetActivityType(const ActivityType& value) { m_activityTypeHasBeenSet = true; m_activityType = value; }
+
+    /**
+     * <p>The activity type to get information about. Activity types are identified by
+     * the <code>name</code> and <code>version</code> that were supplied when the
+     * activity was registered.</p>
+     */
+    inline void SetActivityType(ActivityType&& value) { m_activityTypeHasBeenSet = true; m_activityType = std::move(value); }
+
+    /**
+     * <p>The activity type to get information about. Activity types are identified by
+     * the <code>name</code> and <code>version</code> that were supplied when the
+     * activity was registered.</p>
+     */
+    inline DescribeActivityTypeRequest& WithActivityType(const ActivityType& value) { SetActivityType(value); return *this;}
+
+    /**
+     * <p>The activity type to get information about. Activity types are identified by
+     * the <code>name</code> and <code>version</code> that were supplied when the
+     * activity was registered.</p>
+     */
+    inline DescribeActivityTypeRequest& WithActivityType(ActivityType&& value) { SetActivityType(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_domain;
+    bool m_domainHasBeenSet;
+
+    ActivityType m_activityType;
+    bool m_activityTypeHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/DescribeActivityTypeResult.h

@@ -0,0 +1,136 @@
+/**
+ * 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/model/ActivityTypeInfo.h>
+#include <aws/swf/model/ActivityTypeConfiguration.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+  /**
+   * <p>Detailed information about an activity type.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ActivityTypeDetail">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API DescribeActivityTypeResult
+  {
+  public:
+    DescribeActivityTypeResult();
+    DescribeActivityTypeResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeActivityTypeResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>General information about the activity type.</p> <p>The status of activity
+     * type (returned in the ActivityTypeInfo structure) can be one of the
+     * following.</p> <ul> <li> <p> <code>REGISTERED</code> – The type is registered
+     * and available. Workers supporting this type should be running. </p> </li> <li>
+     * <p> <code>DEPRECATED</code> – The type was deprecated using
+     * <a>DeprecateActivityType</a>, but is still in use. You should keep workers
+     * supporting this type running. You cannot create new tasks of this type. </p>
+     * </li> </ul>
+     */
+    inline const ActivityTypeInfo& GetTypeInfo() const{ return m_typeInfo; }
+
+    /**
+     * <p>General information about the activity type.</p> <p>The status of activity
+     * type (returned in the ActivityTypeInfo structure) can be one of the
+     * following.</p> <ul> <li> <p> <code>REGISTERED</code> – The type is registered
+     * and available. Workers supporting this type should be running. </p> </li> <li>
+     * <p> <code>DEPRECATED</code> – The type was deprecated using
+     * <a>DeprecateActivityType</a>, but is still in use. You should keep workers
+     * supporting this type running. You cannot create new tasks of this type. </p>
+     * </li> </ul>
+     */
+    inline void SetTypeInfo(const ActivityTypeInfo& value) { m_typeInfo = value; }
+
+    /**
+     * <p>General information about the activity type.</p> <p>The status of activity
+     * type (returned in the ActivityTypeInfo structure) can be one of the
+     * following.</p> <ul> <li> <p> <code>REGISTERED</code> – The type is registered
+     * and available. Workers supporting this type should be running. </p> </li> <li>
+     * <p> <code>DEPRECATED</code> – The type was deprecated using
+     * <a>DeprecateActivityType</a>, but is still in use. You should keep workers
+     * supporting this type running. You cannot create new tasks of this type. </p>
+     * </li> </ul>
+     */
+    inline void SetTypeInfo(ActivityTypeInfo&& value) { m_typeInfo = std::move(value); }
+
+    /**
+     * <p>General information about the activity type.</p> <p>The status of activity
+     * type (returned in the ActivityTypeInfo structure) can be one of the
+     * following.</p> <ul> <li> <p> <code>REGISTERED</code> – The type is registered
+     * and available. Workers supporting this type should be running. </p> </li> <li>
+     * <p> <code>DEPRECATED</code> – The type was deprecated using
+     * <a>DeprecateActivityType</a>, but is still in use. You should keep workers
+     * supporting this type running. You cannot create new tasks of this type. </p>
+     * </li> </ul>
+     */
+    inline DescribeActivityTypeResult& WithTypeInfo(const ActivityTypeInfo& value) { SetTypeInfo(value); return *this;}
+
+    /**
+     * <p>General information about the activity type.</p> <p>The status of activity
+     * type (returned in the ActivityTypeInfo structure) can be one of the
+     * following.</p> <ul> <li> <p> <code>REGISTERED</code> – The type is registered
+     * and available. Workers supporting this type should be running. </p> </li> <li>
+     * <p> <code>DEPRECATED</code> – The type was deprecated using
+     * <a>DeprecateActivityType</a>, but is still in use. You should keep workers
+     * supporting this type running. You cannot create new tasks of this type. </p>
+     * </li> </ul>
+     */
+    inline DescribeActivityTypeResult& WithTypeInfo(ActivityTypeInfo&& value) { SetTypeInfo(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The configuration settings registered with the activity type.</p>
+     */
+    inline const ActivityTypeConfiguration& GetConfiguration() const{ return m_configuration; }
+
+    /**
+     * <p>The configuration settings registered with the activity type.</p>
+     */
+    inline void SetConfiguration(const ActivityTypeConfiguration& value) { m_configuration = value; }
+
+    /**
+     * <p>The configuration settings registered with the activity type.</p>
+     */
+    inline void SetConfiguration(ActivityTypeConfiguration&& value) { m_configuration = std::move(value); }
+
+    /**
+     * <p>The configuration settings registered with the activity type.</p>
+     */
+    inline DescribeActivityTypeResult& WithConfiguration(const ActivityTypeConfiguration& value) { SetConfiguration(value); return *this;}
+
+    /**
+     * <p>The configuration settings registered with the activity type.</p>
+     */
+    inline DescribeActivityTypeResult& WithConfiguration(ActivityTypeConfiguration&& value) { SetConfiguration(std::move(value)); return *this;}
+
+  private:
+
+    ActivityTypeInfo m_typeInfo;
+
+    ActivityTypeConfiguration m_configuration;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/DescribeDomainRequest.h

@@ -0,0 +1,85 @@
+/**
+ * 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/SWFRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SWF_API DescribeDomainRequest : public SWFRequest
+  {
+  public:
+    DescribeDomainRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DescribeDomain"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the domain to describe.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>The name of the domain to describe.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>The name of the domain to describe.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>The name of the domain to describe.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>The name of the domain to describe.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>The name of the domain to describe.</p>
+     */
+    inline DescribeDomainRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>The name of the domain to describe.</p>
+     */
+    inline DescribeDomainRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the domain to describe.</p>
+     */
+    inline DescribeDomainRequest& WithName(const char* value) { SetName(value); return *this;}
+
+  private:
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/DescribeDomainResult.h

@@ -0,0 +1,111 @@
+/**
+ * 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/model/DomainInfo.h>
+#include <aws/swf/model/DomainConfiguration.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+  /**
+   * <p>Contains details of a domain.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DomainDetail">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API DescribeDomainResult
+  {
+  public:
+    DescribeDomainResult();
+    DescribeDomainResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeDomainResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The basic information about a domain, such as its name, status, and
+     * description.</p>
+     */
+    inline const DomainInfo& GetDomainInfo() const{ return m_domainInfo; }
+
+    /**
+     * <p>The basic information about a domain, such as its name, status, and
+     * description.</p>
+     */
+    inline void SetDomainInfo(const DomainInfo& value) { m_domainInfo = value; }
+
+    /**
+     * <p>The basic information about a domain, such as its name, status, and
+     * description.</p>
+     */
+    inline void SetDomainInfo(DomainInfo&& value) { m_domainInfo = std::move(value); }
+
+    /**
+     * <p>The basic information about a domain, such as its name, status, and
+     * description.</p>
+     */
+    inline DescribeDomainResult& WithDomainInfo(const DomainInfo& value) { SetDomainInfo(value); return *this;}
+
+    /**
+     * <p>The basic information about a domain, such as its name, status, and
+     * description.</p>
+     */
+    inline DescribeDomainResult& WithDomainInfo(DomainInfo&& value) { SetDomainInfo(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The domain configuration. Currently, this includes only the domain's
+     * retention period.</p>
+     */
+    inline const DomainConfiguration& GetConfiguration() const{ return m_configuration; }
+
+    /**
+     * <p>The domain configuration. Currently, this includes only the domain's
+     * retention period.</p>
+     */
+    inline void SetConfiguration(const DomainConfiguration& value) { m_configuration = value; }
+
+    /**
+     * <p>The domain configuration. Currently, this includes only the domain's
+     * retention period.</p>
+     */
+    inline void SetConfiguration(DomainConfiguration&& value) { m_configuration = std::move(value); }
+
+    /**
+     * <p>The domain configuration. Currently, this includes only the domain's
+     * retention period.</p>
+     */
+    inline DescribeDomainResult& WithConfiguration(const DomainConfiguration& value) { SetConfiguration(value); return *this;}
+
+    /**
+     * <p>The domain configuration. Currently, this includes only the domain's
+     * retention period.</p>
+     */
+    inline DescribeDomainResult& WithConfiguration(DomainConfiguration&& value) { SetConfiguration(std::move(value)); return *this;}
+
+  private:
+
+    DomainInfo m_domainInfo;
+
+    DomainConfiguration m_configuration;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/DescribeWorkflowExecutionRequest.h

@@ -0,0 +1,120 @@
+/**
+ * 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/SWFRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/WorkflowExecution.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SWF_API DescribeWorkflowExecutionRequest : public SWFRequest
+  {
+  public:
+    DescribeWorkflowExecutionRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DescribeWorkflowExecution"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the domain containing the workflow execution.</p>
+     */
+    inline const Aws::String& GetDomain() const{ return m_domain; }
+
+    /**
+     * <p>The name of the domain containing the workflow execution.</p>
+     */
+    inline bool DomainHasBeenSet() const { return m_domainHasBeenSet; }
+
+    /**
+     * <p>The name of the domain containing the workflow execution.</p>
+     */
+    inline void SetDomain(const Aws::String& value) { m_domainHasBeenSet = true; m_domain = value; }
+
+    /**
+     * <p>The name of the domain containing the workflow execution.</p>
+     */
+    inline void SetDomain(Aws::String&& value) { m_domainHasBeenSet = true; m_domain = std::move(value); }
+
+    /**
+     * <p>The name of the domain containing the workflow execution.</p>
+     */
+    inline void SetDomain(const char* value) { m_domainHasBeenSet = true; m_domain.assign(value); }
+
+    /**
+     * <p>The name of the domain containing the workflow execution.</p>
+     */
+    inline DescribeWorkflowExecutionRequest& WithDomain(const Aws::String& value) { SetDomain(value); return *this;}
+
+    /**
+     * <p>The name of the domain containing the workflow execution.</p>
+     */
+    inline DescribeWorkflowExecutionRequest& WithDomain(Aws::String&& value) { SetDomain(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the domain containing the workflow execution.</p>
+     */
+    inline DescribeWorkflowExecutionRequest& WithDomain(const char* value) { SetDomain(value); return *this;}
+
+
+    /**
+     * <p>The workflow execution to describe.</p>
+     */
+    inline const WorkflowExecution& GetExecution() const{ return m_execution; }
+
+    /**
+     * <p>The workflow execution to describe.</p>
+     */
+    inline bool ExecutionHasBeenSet() const { return m_executionHasBeenSet; }
+
+    /**
+     * <p>The workflow execution to describe.</p>
+     */
+    inline void SetExecution(const WorkflowExecution& value) { m_executionHasBeenSet = true; m_execution = value; }
+
+    /**
+     * <p>The workflow execution to describe.</p>
+     */
+    inline void SetExecution(WorkflowExecution&& value) { m_executionHasBeenSet = true; m_execution = std::move(value); }
+
+    /**
+     * <p>The workflow execution to describe.</p>
+     */
+    inline DescribeWorkflowExecutionRequest& WithExecution(const WorkflowExecution& value) { SetExecution(value); return *this;}
+
+    /**
+     * <p>The workflow execution to describe.</p>
+     */
+    inline DescribeWorkflowExecutionRequest& WithExecution(WorkflowExecution&& value) { SetExecution(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_domain;
+    bool m_domainHasBeenSet;
+
+    WorkflowExecution m_execution;
+    bool m_executionHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/DescribeWorkflowExecutionResult.h

@@ -0,0 +1,237 @@
+/**
+ * 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/model/WorkflowExecutionInfo.h>
+#include <aws/swf/model/WorkflowExecutionConfiguration.h>
+#include <aws/swf/model/WorkflowExecutionOpenCounts.h>
+#include <aws/core/utils/DateTime.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+  /**
+   * <p>Contains details about a workflow execution.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/WorkflowExecutionDetail">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API DescribeWorkflowExecutionResult
+  {
+  public:
+    DescribeWorkflowExecutionResult();
+    DescribeWorkflowExecutionResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeWorkflowExecutionResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Information about the workflow execution.</p>
+     */
+    inline const WorkflowExecutionInfo& GetExecutionInfo() const{ return m_executionInfo; }
+
+    /**
+     * <p>Information about the workflow execution.</p>
+     */
+    inline void SetExecutionInfo(const WorkflowExecutionInfo& value) { m_executionInfo = value; }
+
+    /**
+     * <p>Information about the workflow execution.</p>
+     */
+    inline void SetExecutionInfo(WorkflowExecutionInfo&& value) { m_executionInfo = std::move(value); }
+
+    /**
+     * <p>Information about the workflow execution.</p>
+     */
+    inline DescribeWorkflowExecutionResult& WithExecutionInfo(const WorkflowExecutionInfo& value) { SetExecutionInfo(value); return *this;}
+
+    /**
+     * <p>Information about the workflow execution.</p>
+     */
+    inline DescribeWorkflowExecutionResult& WithExecutionInfo(WorkflowExecutionInfo&& value) { SetExecutionInfo(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The configuration settings for this workflow execution including timeout
+     * values, tasklist etc.</p>
+     */
+    inline const WorkflowExecutionConfiguration& GetExecutionConfiguration() const{ return m_executionConfiguration; }
+
+    /**
+     * <p>The configuration settings for this workflow execution including timeout
+     * values, tasklist etc.</p>
+     */
+    inline void SetExecutionConfiguration(const WorkflowExecutionConfiguration& value) { m_executionConfiguration = value; }
+
+    /**
+     * <p>The configuration settings for this workflow execution including timeout
+     * values, tasklist etc.</p>
+     */
+    inline void SetExecutionConfiguration(WorkflowExecutionConfiguration&& value) { m_executionConfiguration = std::move(value); }
+
+    /**
+     * <p>The configuration settings for this workflow execution including timeout
+     * values, tasklist etc.</p>
+     */
+    inline DescribeWorkflowExecutionResult& WithExecutionConfiguration(const WorkflowExecutionConfiguration& value) { SetExecutionConfiguration(value); return *this;}
+
+    /**
+     * <p>The configuration settings for this workflow execution including timeout
+     * values, tasklist etc.</p>
+     */
+    inline DescribeWorkflowExecutionResult& WithExecutionConfiguration(WorkflowExecutionConfiguration&& value) { SetExecutionConfiguration(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The number of tasks for this workflow execution. This includes open and
+     * closed tasks of all types.</p>
+     */
+    inline const WorkflowExecutionOpenCounts& GetOpenCounts() const{ return m_openCounts; }
+
+    /**
+     * <p>The number of tasks for this workflow execution. This includes open and
+     * closed tasks of all types.</p>
+     */
+    inline void SetOpenCounts(const WorkflowExecutionOpenCounts& value) { m_openCounts = value; }
+
+    /**
+     * <p>The number of tasks for this workflow execution. This includes open and
+     * closed tasks of all types.</p>
+     */
+    inline void SetOpenCounts(WorkflowExecutionOpenCounts&& value) { m_openCounts = std::move(value); }
+
+    /**
+     * <p>The number of tasks for this workflow execution. This includes open and
+     * closed tasks of all types.</p>
+     */
+    inline DescribeWorkflowExecutionResult& WithOpenCounts(const WorkflowExecutionOpenCounts& value) { SetOpenCounts(value); return *this;}
+
+    /**
+     * <p>The number of tasks for this workflow execution. This includes open and
+     * closed tasks of all types.</p>
+     */
+    inline DescribeWorkflowExecutionResult& WithOpenCounts(WorkflowExecutionOpenCounts&& value) { SetOpenCounts(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The time when the last activity task was scheduled for this workflow
+     * execution. You can use this information to determine if the workflow has not
+     * made progress for an unusually long period of time and might require a
+     * corrective action.</p>
+     */
+    inline const Aws::Utils::DateTime& GetLatestActivityTaskTimestamp() const{ return m_latestActivityTaskTimestamp; }
+
+    /**
+     * <p>The time when the last activity task was scheduled for this workflow
+     * execution. You can use this information to determine if the workflow has not
+     * made progress for an unusually long period of time and might require a
+     * corrective action.</p>
+     */
+    inline void SetLatestActivityTaskTimestamp(const Aws::Utils::DateTime& value) { m_latestActivityTaskTimestamp = value; }
+
+    /**
+     * <p>The time when the last activity task was scheduled for this workflow
+     * execution. You can use this information to determine if the workflow has not
+     * made progress for an unusually long period of time and might require a
+     * corrective action.</p>
+     */
+    inline void SetLatestActivityTaskTimestamp(Aws::Utils::DateTime&& value) { m_latestActivityTaskTimestamp = std::move(value); }
+
+    /**
+     * <p>The time when the last activity task was scheduled for this workflow
+     * execution. You can use this information to determine if the workflow has not
+     * made progress for an unusually long period of time and might require a
+     * corrective action.</p>
+     */
+    inline DescribeWorkflowExecutionResult& WithLatestActivityTaskTimestamp(const Aws::Utils::DateTime& value) { SetLatestActivityTaskTimestamp(value); return *this;}
+
+    /**
+     * <p>The time when the last activity task was scheduled for this workflow
+     * execution. You can use this information to determine if the workflow has not
+     * made progress for an unusually long period of time and might require a
+     * corrective action.</p>
+     */
+    inline DescribeWorkflowExecutionResult& WithLatestActivityTaskTimestamp(Aws::Utils::DateTime&& value) { SetLatestActivityTaskTimestamp(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The latest executionContext provided by the decider for this workflow
+     * execution. A decider can provide an executionContext (a free-form string) when
+     * closing a decision task using <a>RespondDecisionTaskCompleted</a>.</p>
+     */
+    inline const Aws::String& GetLatestExecutionContext() const{ return m_latestExecutionContext; }
+
+    /**
+     * <p>The latest executionContext provided by the decider for this workflow
+     * execution. A decider can provide an executionContext (a free-form string) when
+     * closing a decision task using <a>RespondDecisionTaskCompleted</a>.</p>
+     */
+    inline void SetLatestExecutionContext(const Aws::String& value) { m_latestExecutionContext = value; }
+
+    /**
+     * <p>The latest executionContext provided by the decider for this workflow
+     * execution. A decider can provide an executionContext (a free-form string) when
+     * closing a decision task using <a>RespondDecisionTaskCompleted</a>.</p>
+     */
+    inline void SetLatestExecutionContext(Aws::String&& value) { m_latestExecutionContext = std::move(value); }
+
+    /**
+     * <p>The latest executionContext provided by the decider for this workflow
+     * execution. A decider can provide an executionContext (a free-form string) when
+     * closing a decision task using <a>RespondDecisionTaskCompleted</a>.</p>
+     */
+    inline void SetLatestExecutionContext(const char* value) { m_latestExecutionContext.assign(value); }
+
+    /**
+     * <p>The latest executionContext provided by the decider for this workflow
+     * execution. A decider can provide an executionContext (a free-form string) when
+     * closing a decision task using <a>RespondDecisionTaskCompleted</a>.</p>
+     */
+    inline DescribeWorkflowExecutionResult& WithLatestExecutionContext(const Aws::String& value) { SetLatestExecutionContext(value); return *this;}
+
+    /**
+     * <p>The latest executionContext provided by the decider for this workflow
+     * execution. A decider can provide an executionContext (a free-form string) when
+     * closing a decision task using <a>RespondDecisionTaskCompleted</a>.</p>
+     */
+    inline DescribeWorkflowExecutionResult& WithLatestExecutionContext(Aws::String&& value) { SetLatestExecutionContext(std::move(value)); return *this;}
+
+    /**
+     * <p>The latest executionContext provided by the decider for this workflow
+     * execution. A decider can provide an executionContext (a free-form string) when
+     * closing a decision task using <a>RespondDecisionTaskCompleted</a>.</p>
+     */
+    inline DescribeWorkflowExecutionResult& WithLatestExecutionContext(const char* value) { SetLatestExecutionContext(value); return *this;}
+
+  private:
+
+    WorkflowExecutionInfo m_executionInfo;
+
+    WorkflowExecutionConfiguration m_executionConfiguration;
+
+    WorkflowExecutionOpenCounts m_openCounts;
+
+    Aws::Utils::DateTime m_latestActivityTaskTimestamp;
+
+    Aws::String m_latestExecutionContext;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/DescribeWorkflowTypeRequest.h

@@ -0,0 +1,120 @@
+/**
+ * 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/SWFRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/WorkflowType.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SWF_API DescribeWorkflowTypeRequest : public SWFRequest
+  {
+  public:
+    DescribeWorkflowTypeRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DescribeWorkflowType"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the domain in which this workflow type is registered.</p>
+     */
+    inline const Aws::String& GetDomain() const{ return m_domain; }
+
+    /**
+     * <p>The name of the domain in which this workflow type is registered.</p>
+     */
+    inline bool DomainHasBeenSet() const { return m_domainHasBeenSet; }
+
+    /**
+     * <p>The name of the domain in which this workflow type is registered.</p>
+     */
+    inline void SetDomain(const Aws::String& value) { m_domainHasBeenSet = true; m_domain = value; }
+
+    /**
+     * <p>The name of the domain in which this workflow type is registered.</p>
+     */
+    inline void SetDomain(Aws::String&& value) { m_domainHasBeenSet = true; m_domain = std::move(value); }
+
+    /**
+     * <p>The name of the domain in which this workflow type is registered.</p>
+     */
+    inline void SetDomain(const char* value) { m_domainHasBeenSet = true; m_domain.assign(value); }
+
+    /**
+     * <p>The name of the domain in which this workflow type is registered.</p>
+     */
+    inline DescribeWorkflowTypeRequest& WithDomain(const Aws::String& value) { SetDomain(value); return *this;}
+
+    /**
+     * <p>The name of the domain in which this workflow type is registered.</p>
+     */
+    inline DescribeWorkflowTypeRequest& WithDomain(Aws::String&& value) { SetDomain(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the domain in which this workflow type is registered.</p>
+     */
+    inline DescribeWorkflowTypeRequest& WithDomain(const char* value) { SetDomain(value); return *this;}
+
+
+    /**
+     * <p>The workflow type to describe.</p>
+     */
+    inline const WorkflowType& GetWorkflowType() const{ return m_workflowType; }
+
+    /**
+     * <p>The workflow type to describe.</p>
+     */
+    inline bool WorkflowTypeHasBeenSet() const { return m_workflowTypeHasBeenSet; }
+
+    /**
+     * <p>The workflow type to describe.</p>
+     */
+    inline void SetWorkflowType(const WorkflowType& value) { m_workflowTypeHasBeenSet = true; m_workflowType = value; }
+
+    /**
+     * <p>The workflow type to describe.</p>
+     */
+    inline void SetWorkflowType(WorkflowType&& value) { m_workflowTypeHasBeenSet = true; m_workflowType = std::move(value); }
+
+    /**
+     * <p>The workflow type to describe.</p>
+     */
+    inline DescribeWorkflowTypeRequest& WithWorkflowType(const WorkflowType& value) { SetWorkflowType(value); return *this;}
+
+    /**
+     * <p>The workflow type to describe.</p>
+     */
+    inline DescribeWorkflowTypeRequest& WithWorkflowType(WorkflowType&& value) { SetWorkflowType(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_domain;
+    bool m_domainHasBeenSet;
+
+    WorkflowType m_workflowType;
+    bool m_workflowTypeHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/DescribeWorkflowTypeResult.h

@@ -0,0 +1,141 @@
+/**
+ * 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/model/WorkflowTypeInfo.h>
+#include <aws/swf/model/WorkflowTypeConfiguration.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+  /**
+   * <p>Contains details about a workflow type.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/WorkflowTypeDetail">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API DescribeWorkflowTypeResult
+  {
+  public:
+    DescribeWorkflowTypeResult();
+    DescribeWorkflowTypeResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeWorkflowTypeResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>General information about the workflow type.</p> <p>The status of the
+     * workflow type (returned in the WorkflowTypeInfo structure) can be one of the
+     * following.</p> <ul> <li> <p> <code>REGISTERED</code> – The type is registered
+     * and available. Workers supporting this type should be running.</p> </li> <li>
+     * <p> <code>DEPRECATED</code> – The type was deprecated using
+     * <a>DeprecateWorkflowType</a>, but is still in use. You should keep workers
+     * supporting this type running. You cannot create new workflow executions of this
+     * type.</p> </li> </ul>
+     */
+    inline const WorkflowTypeInfo& GetTypeInfo() const{ return m_typeInfo; }
+
+    /**
+     * <p>General information about the workflow type.</p> <p>The status of the
+     * workflow type (returned in the WorkflowTypeInfo structure) can be one of the
+     * following.</p> <ul> <li> <p> <code>REGISTERED</code> – The type is registered
+     * and available. Workers supporting this type should be running.</p> </li> <li>
+     * <p> <code>DEPRECATED</code> – The type was deprecated using
+     * <a>DeprecateWorkflowType</a>, but is still in use. You should keep workers
+     * supporting this type running. You cannot create new workflow executions of this
+     * type.</p> </li> </ul>
+     */
+    inline void SetTypeInfo(const WorkflowTypeInfo& value) { m_typeInfo = value; }
+
+    /**
+     * <p>General information about the workflow type.</p> <p>The status of the
+     * workflow type (returned in the WorkflowTypeInfo structure) can be one of the
+     * following.</p> <ul> <li> <p> <code>REGISTERED</code> – The type is registered
+     * and available. Workers supporting this type should be running.</p> </li> <li>
+     * <p> <code>DEPRECATED</code> – The type was deprecated using
+     * <a>DeprecateWorkflowType</a>, but is still in use. You should keep workers
+     * supporting this type running. You cannot create new workflow executions of this
+     * type.</p> </li> </ul>
+     */
+    inline void SetTypeInfo(WorkflowTypeInfo&& value) { m_typeInfo = std::move(value); }
+
+    /**
+     * <p>General information about the workflow type.</p> <p>The status of the
+     * workflow type (returned in the WorkflowTypeInfo structure) can be one of the
+     * following.</p> <ul> <li> <p> <code>REGISTERED</code> – The type is registered
+     * and available. Workers supporting this type should be running.</p> </li> <li>
+     * <p> <code>DEPRECATED</code> – The type was deprecated using
+     * <a>DeprecateWorkflowType</a>, but is still in use. You should keep workers
+     * supporting this type running. You cannot create new workflow executions of this
+     * type.</p> </li> </ul>
+     */
+    inline DescribeWorkflowTypeResult& WithTypeInfo(const WorkflowTypeInfo& value) { SetTypeInfo(value); return *this;}
+
+    /**
+     * <p>General information about the workflow type.</p> <p>The status of the
+     * workflow type (returned in the WorkflowTypeInfo structure) can be one of the
+     * following.</p> <ul> <li> <p> <code>REGISTERED</code> – The type is registered
+     * and available. Workers supporting this type should be running.</p> </li> <li>
+     * <p> <code>DEPRECATED</code> – The type was deprecated using
+     * <a>DeprecateWorkflowType</a>, but is still in use. You should keep workers
+     * supporting this type running. You cannot create new workflow executions of this
+     * type.</p> </li> </ul>
+     */
+    inline DescribeWorkflowTypeResult& WithTypeInfo(WorkflowTypeInfo&& value) { SetTypeInfo(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Configuration settings of the workflow type registered through
+     * <a>RegisterWorkflowType</a> </p>
+     */
+    inline const WorkflowTypeConfiguration& GetConfiguration() const{ return m_configuration; }
+
+    /**
+     * <p>Configuration settings of the workflow type registered through
+     * <a>RegisterWorkflowType</a> </p>
+     */
+    inline void SetConfiguration(const WorkflowTypeConfiguration& value) { m_configuration = value; }
+
+    /**
+     * <p>Configuration settings of the workflow type registered through
+     * <a>RegisterWorkflowType</a> </p>
+     */
+    inline void SetConfiguration(WorkflowTypeConfiguration&& value) { m_configuration = std::move(value); }
+
+    /**
+     * <p>Configuration settings of the workflow type registered through
+     * <a>RegisterWorkflowType</a> </p>
+     */
+    inline DescribeWorkflowTypeResult& WithConfiguration(const WorkflowTypeConfiguration& value) { SetConfiguration(value); return *this;}
+
+    /**
+     * <p>Configuration settings of the workflow type registered through
+     * <a>RegisterWorkflowType</a> </p>
+     */
+    inline DescribeWorkflowTypeResult& WithConfiguration(WorkflowTypeConfiguration&& value) { SetConfiguration(std::move(value)); return *this;}
+
+  private:
+
+    WorkflowTypeInfo m_typeInfo;
+
+    WorkflowTypeConfiguration m_configuration;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/DomainConfiguration.h

@@ -0,0 +1,89 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Contains the configuration settings of a domain.</p><p><h3>See Also:</h3>  
+   * <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DomainConfiguration">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API DomainConfiguration
+  {
+  public:
+    DomainConfiguration();
+    DomainConfiguration(Aws::Utils::Json::JsonView jsonValue);
+    DomainConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The retention period for workflow executions in this domain.</p>
+     */
+    inline const Aws::String& GetWorkflowExecutionRetentionPeriodInDays() const{ return m_workflowExecutionRetentionPeriodInDays; }
+
+    /**
+     * <p>The retention period for workflow executions in this domain.</p>
+     */
+    inline bool WorkflowExecutionRetentionPeriodInDaysHasBeenSet() const { return m_workflowExecutionRetentionPeriodInDaysHasBeenSet; }
+
+    /**
+     * <p>The retention period for workflow executions in this domain.</p>
+     */
+    inline void SetWorkflowExecutionRetentionPeriodInDays(const Aws::String& value) { m_workflowExecutionRetentionPeriodInDaysHasBeenSet = true; m_workflowExecutionRetentionPeriodInDays = value; }
+
+    /**
+     * <p>The retention period for workflow executions in this domain.</p>
+     */
+    inline void SetWorkflowExecutionRetentionPeriodInDays(Aws::String&& value) { m_workflowExecutionRetentionPeriodInDaysHasBeenSet = true; m_workflowExecutionRetentionPeriodInDays = std::move(value); }
+
+    /**
+     * <p>The retention period for workflow executions in this domain.</p>
+     */
+    inline void SetWorkflowExecutionRetentionPeriodInDays(const char* value) { m_workflowExecutionRetentionPeriodInDaysHasBeenSet = true; m_workflowExecutionRetentionPeriodInDays.assign(value); }
+
+    /**
+     * <p>The retention period for workflow executions in this domain.</p>
+     */
+    inline DomainConfiguration& WithWorkflowExecutionRetentionPeriodInDays(const Aws::String& value) { SetWorkflowExecutionRetentionPeriodInDays(value); return *this;}
+
+    /**
+     * <p>The retention period for workflow executions in this domain.</p>
+     */
+    inline DomainConfiguration& WithWorkflowExecutionRetentionPeriodInDays(Aws::String&& value) { SetWorkflowExecutionRetentionPeriodInDays(std::move(value)); return *this;}
+
+    /**
+     * <p>The retention period for workflow executions in this domain.</p>
+     */
+    inline DomainConfiguration& WithWorkflowExecutionRetentionPeriodInDays(const char* value) { SetWorkflowExecutionRetentionPeriodInDays(value); return *this;}
+
+  private:
+
+    Aws::String m_workflowExecutionRetentionPeriodInDays;
+    bool m_workflowExecutionRetentionPeriodInDaysHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/DomainInfo.h

@@ -0,0 +1,241 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/RegistrationStatus.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Contains general information about a domain.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DomainInfo">AWS API
+   * Reference</a></p>
+   */
+  class AWS_SWF_API DomainInfo
+  {
+  public:
+    DomainInfo();
+    DomainInfo(Aws::Utils::Json::JsonView jsonValue);
+    DomainInfo& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the domain. This name is unique within the account.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>The name of the domain. This name is unique within the account.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>The name of the domain. This name is unique within the account.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>The name of the domain. This name is unique within the account.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>The name of the domain. This name is unique within the account.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>The name of the domain. This name is unique within the account.</p>
+     */
+    inline DomainInfo& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>The name of the domain. This name is unique within the account.</p>
+     */
+    inline DomainInfo& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the domain. This name is unique within the account.</p>
+     */
+    inline DomainInfo& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>The status of the domain:</p> <ul> <li> <p> <code>REGISTERED</code> – The
+     * domain is properly registered and available. You can use this domain for
+     * registering types and creating new workflow executions. </p> </li> <li> <p>
+     * <code>DEPRECATED</code> – The domain was deprecated using
+     * <a>DeprecateDomain</a>, but is still in use. You should not create new workflow
+     * executions in this domain. </p> </li> </ul>
+     */
+    inline const RegistrationStatus& GetStatus() const{ return m_status; }
+
+    /**
+     * <p>The status of the domain:</p> <ul> <li> <p> <code>REGISTERED</code> – The
+     * domain is properly registered and available. You can use this domain for
+     * registering types and creating new workflow executions. </p> </li> <li> <p>
+     * <code>DEPRECATED</code> – The domain was deprecated using
+     * <a>DeprecateDomain</a>, but is still in use. You should not create new workflow
+     * executions in this domain. </p> </li> </ul>
+     */
+    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
+
+    /**
+     * <p>The status of the domain:</p> <ul> <li> <p> <code>REGISTERED</code> – The
+     * domain is properly registered and available. You can use this domain for
+     * registering types and creating new workflow executions. </p> </li> <li> <p>
+     * <code>DEPRECATED</code> – The domain was deprecated using
+     * <a>DeprecateDomain</a>, but is still in use. You should not create new workflow
+     * executions in this domain. </p> </li> </ul>
+     */
+    inline void SetStatus(const RegistrationStatus& value) { m_statusHasBeenSet = true; m_status = value; }
+
+    /**
+     * <p>The status of the domain:</p> <ul> <li> <p> <code>REGISTERED</code> – The
+     * domain is properly registered and available. You can use this domain for
+     * registering types and creating new workflow executions. </p> </li> <li> <p>
+     * <code>DEPRECATED</code> – The domain was deprecated using
+     * <a>DeprecateDomain</a>, but is still in use. You should not create new workflow
+     * executions in this domain. </p> </li> </ul>
+     */
+    inline void SetStatus(RegistrationStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
+
+    /**
+     * <p>The status of the domain:</p> <ul> <li> <p> <code>REGISTERED</code> – The
+     * domain is properly registered and available. You can use this domain for
+     * registering types and creating new workflow executions. </p> </li> <li> <p>
+     * <code>DEPRECATED</code> – The domain was deprecated using
+     * <a>DeprecateDomain</a>, but is still in use. You should not create new workflow
+     * executions in this domain. </p> </li> </ul>
+     */
+    inline DomainInfo& WithStatus(const RegistrationStatus& value) { SetStatus(value); return *this;}
+
+    /**
+     * <p>The status of the domain:</p> <ul> <li> <p> <code>REGISTERED</code> – The
+     * domain is properly registered and available. You can use this domain for
+     * registering types and creating new workflow executions. </p> </li> <li> <p>
+     * <code>DEPRECATED</code> – The domain was deprecated using
+     * <a>DeprecateDomain</a>, but is still in use. You should not create new workflow
+     * executions in this domain. </p> </li> </ul>
+     */
+    inline DomainInfo& WithStatus(RegistrationStatus&& value) { SetStatus(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The description of the domain provided through <a>RegisterDomain</a>.</p>
+     */
+    inline const Aws::String& GetDescription() const{ return m_description; }
+
+    /**
+     * <p>The description of the domain provided through <a>RegisterDomain</a>.</p>
+     */
+    inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
+
+    /**
+     * <p>The description of the domain provided through <a>RegisterDomain</a>.</p>
+     */
+    inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
+
+    /**
+     * <p>The description of the domain provided through <a>RegisterDomain</a>.</p>
+     */
+    inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
+
+    /**
+     * <p>The description of the domain provided through <a>RegisterDomain</a>.</p>
+     */
+    inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
+
+    /**
+     * <p>The description of the domain provided through <a>RegisterDomain</a>.</p>
+     */
+    inline DomainInfo& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
+
+    /**
+     * <p>The description of the domain provided through <a>RegisterDomain</a>.</p>
+     */
+    inline DomainInfo& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
+
+    /**
+     * <p>The description of the domain provided through <a>RegisterDomain</a>.</p>
+     */
+    inline DomainInfo& WithDescription(const char* value) { SetDescription(value); return *this;}
+
+
+    /**
+     * <p>The ARN of the domain.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>The ARN of the domain.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>The ARN of the domain.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>The ARN of the domain.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>The ARN of the domain.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>The ARN of the domain.</p>
+     */
+    inline DomainInfo& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>The ARN of the domain.</p>
+     */
+    inline DomainInfo& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The ARN of the domain.</p>
+     */
+    inline DomainInfo& WithArn(const char* value) { SetArn(value); return *this;}
+
+  private:
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    RegistrationStatus m_status;
+    bool m_statusHasBeenSet;
+
+    Aws::String m_description;
+    bool m_descriptionHasBeenSet;
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/EventType.h

@@ -0,0 +1,83 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+  enum class EventType
+  {
+    NOT_SET,
+    WorkflowExecutionStarted,
+    WorkflowExecutionCancelRequested,
+    WorkflowExecutionCompleted,
+    CompleteWorkflowExecutionFailed,
+    WorkflowExecutionFailed,
+    FailWorkflowExecutionFailed,
+    WorkflowExecutionTimedOut,
+    WorkflowExecutionCanceled,
+    CancelWorkflowExecutionFailed,
+    WorkflowExecutionContinuedAsNew,
+    ContinueAsNewWorkflowExecutionFailed,
+    WorkflowExecutionTerminated,
+    DecisionTaskScheduled,
+    DecisionTaskStarted,
+    DecisionTaskCompleted,
+    DecisionTaskTimedOut,
+    ActivityTaskScheduled,
+    ScheduleActivityTaskFailed,
+    ActivityTaskStarted,
+    ActivityTaskCompleted,
+    ActivityTaskFailed,
+    ActivityTaskTimedOut,
+    ActivityTaskCanceled,
+    ActivityTaskCancelRequested,
+    RequestCancelActivityTaskFailed,
+    WorkflowExecutionSignaled,
+    MarkerRecorded,
+    RecordMarkerFailed,
+    TimerStarted,
+    StartTimerFailed,
+    TimerFired,
+    TimerCanceled,
+    CancelTimerFailed,
+    StartChildWorkflowExecutionInitiated,
+    StartChildWorkflowExecutionFailed,
+    ChildWorkflowExecutionStarted,
+    ChildWorkflowExecutionCompleted,
+    ChildWorkflowExecutionFailed,
+    ChildWorkflowExecutionTimedOut,
+    ChildWorkflowExecutionCanceled,
+    ChildWorkflowExecutionTerminated,
+    SignalExternalWorkflowExecutionInitiated,
+    SignalExternalWorkflowExecutionFailed,
+    ExternalWorkflowExecutionSignaled,
+    RequestCancelExternalWorkflowExecutionInitiated,
+    RequestCancelExternalWorkflowExecutionFailed,
+    ExternalWorkflowExecutionCancelRequested,
+    LambdaFunctionScheduled,
+    LambdaFunctionStarted,
+    LambdaFunctionCompleted,
+    LambdaFunctionFailed,
+    LambdaFunctionTimedOut,
+    ScheduleLambdaFunctionFailed,
+    StartLambdaFunctionFailed
+  };
+
+namespace EventTypeMapper
+{
+AWS_SWF_API EventType GetEventTypeForName(const Aws::String& name);
+
+AWS_SWF_API Aws::String GetNameForEventType(EventType value);
+} // namespace EventTypeMapper
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ExecutionStatus.h

@@ -0,0 +1,31 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+  enum class ExecutionStatus
+  {
+    NOT_SET,
+    OPEN,
+    CLOSED
+  };
+
+namespace ExecutionStatusMapper
+{
+AWS_SWF_API ExecutionStatus GetExecutionStatusForName(const Aws::String& name);
+
+AWS_SWF_API Aws::String GetNameForExecutionStatus(ExecutionStatus value);
+} // namespace ExecutionStatusMapper
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ExecutionTimeFilter.h

@@ -0,0 +1,116 @@
+/**
+ * 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/core/utils/DateTime.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Used to filter the workflow executions in visibility APIs by various
+   * time-based rules. Each parameter, if specified, defines a rule that must be
+   * satisfied by each returned query result. The parameter values are in the <a
+   * href="https://en.wikipedia.org/wiki/Unix_time">Unix Time format</a>. For
+   * example: <code>"oldestDate": 1325376070.</code> </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ExecutionTimeFilter">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ExecutionTimeFilter
+  {
+  public:
+    ExecutionTimeFilter();
+    ExecutionTimeFilter(Aws::Utils::Json::JsonView jsonValue);
+    ExecutionTimeFilter& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Specifies the oldest start or close date and time to return.</p>
+     */
+    inline const Aws::Utils::DateTime& GetOldestDate() const{ return m_oldestDate; }
+
+    /**
+     * <p>Specifies the oldest start or close date and time to return.</p>
+     */
+    inline bool OldestDateHasBeenSet() const { return m_oldestDateHasBeenSet; }
+
+    /**
+     * <p>Specifies the oldest start or close date and time to return.</p>
+     */
+    inline void SetOldestDate(const Aws::Utils::DateTime& value) { m_oldestDateHasBeenSet = true; m_oldestDate = value; }
+
+    /**
+     * <p>Specifies the oldest start or close date and time to return.</p>
+     */
+    inline void SetOldestDate(Aws::Utils::DateTime&& value) { m_oldestDateHasBeenSet = true; m_oldestDate = std::move(value); }
+
+    /**
+     * <p>Specifies the oldest start or close date and time to return.</p>
+     */
+    inline ExecutionTimeFilter& WithOldestDate(const Aws::Utils::DateTime& value) { SetOldestDate(value); return *this;}
+
+    /**
+     * <p>Specifies the oldest start or close date and time to return.</p>
+     */
+    inline ExecutionTimeFilter& WithOldestDate(Aws::Utils::DateTime&& value) { SetOldestDate(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Specifies the latest start or close date and time to return.</p>
+     */
+    inline const Aws::Utils::DateTime& GetLatestDate() const{ return m_latestDate; }
+
+    /**
+     * <p>Specifies the latest start or close date and time to return.</p>
+     */
+    inline bool LatestDateHasBeenSet() const { return m_latestDateHasBeenSet; }
+
+    /**
+     * <p>Specifies the latest start or close date and time to return.</p>
+     */
+    inline void SetLatestDate(const Aws::Utils::DateTime& value) { m_latestDateHasBeenSet = true; m_latestDate = value; }
+
+    /**
+     * <p>Specifies the latest start or close date and time to return.</p>
+     */
+    inline void SetLatestDate(Aws::Utils::DateTime&& value) { m_latestDateHasBeenSet = true; m_latestDate = std::move(value); }
+
+    /**
+     * <p>Specifies the latest start or close date and time to return.</p>
+     */
+    inline ExecutionTimeFilter& WithLatestDate(const Aws::Utils::DateTime& value) { SetLatestDate(value); return *this;}
+
+    /**
+     * <p>Specifies the latest start or close date and time to return.</p>
+     */
+    inline ExecutionTimeFilter& WithLatestDate(Aws::Utils::DateTime&& value) { SetLatestDate(std::move(value)); return *this;}
+
+  private:
+
+    Aws::Utils::DateTime m_oldestDate;
+    bool m_oldestDateHasBeenSet;
+
+    Aws::Utils::DateTime m_latestDate;
+    bool m_latestDateHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ExternalWorkflowExecutionCancelRequestedEventAttributes.h

@@ -0,0 +1,126 @@
+/**
+ * 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/model/WorkflowExecution.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the
+   * <code>ExternalWorkflowExecutionCancelRequested</code> event.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ExternalWorkflowExecutionCancelRequestedEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ExternalWorkflowExecutionCancelRequestedEventAttributes
+  {
+  public:
+    ExternalWorkflowExecutionCancelRequestedEventAttributes();
+    ExternalWorkflowExecutionCancelRequestedEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    ExternalWorkflowExecutionCancelRequestedEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The external workflow execution to which the cancellation request was
+     * delivered.</p>
+     */
+    inline const WorkflowExecution& GetWorkflowExecution() const{ return m_workflowExecution; }
+
+    /**
+     * <p>The external workflow execution to which the cancellation request was
+     * delivered.</p>
+     */
+    inline bool WorkflowExecutionHasBeenSet() const { return m_workflowExecutionHasBeenSet; }
+
+    /**
+     * <p>The external workflow execution to which the cancellation request was
+     * delivered.</p>
+     */
+    inline void SetWorkflowExecution(const WorkflowExecution& value) { m_workflowExecutionHasBeenSet = true; m_workflowExecution = value; }
+
+    /**
+     * <p>The external workflow execution to which the cancellation request was
+     * delivered.</p>
+     */
+    inline void SetWorkflowExecution(WorkflowExecution&& value) { m_workflowExecutionHasBeenSet = true; m_workflowExecution = std::move(value); }
+
+    /**
+     * <p>The external workflow execution to which the cancellation request was
+     * delivered.</p>
+     */
+    inline ExternalWorkflowExecutionCancelRequestedEventAttributes& WithWorkflowExecution(const WorkflowExecution& value) { SetWorkflowExecution(value); return *this;}
+
+    /**
+     * <p>The external workflow execution to which the cancellation request was
+     * delivered.</p>
+     */
+    inline ExternalWorkflowExecutionCancelRequestedEventAttributes& WithWorkflowExecution(WorkflowExecution&& value) { SetWorkflowExecution(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>RequestCancelExternalWorkflowExecutionInitiated</code>
+     * event corresponding to the <code>RequestCancelExternalWorkflowExecution</code>
+     * decision to cancel this external workflow execution. This information can be
+     * useful for diagnosing problems by tracing back the chain of events leading up to
+     * this event.</p>
+     */
+    inline long long GetInitiatedEventId() const{ return m_initiatedEventId; }
+
+    /**
+     * <p>The ID of the <code>RequestCancelExternalWorkflowExecutionInitiated</code>
+     * event corresponding to the <code>RequestCancelExternalWorkflowExecution</code>
+     * decision to cancel this external workflow execution. This information can be
+     * useful for diagnosing problems by tracing back the chain of events leading up to
+     * this event.</p>
+     */
+    inline bool InitiatedEventIdHasBeenSet() const { return m_initiatedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>RequestCancelExternalWorkflowExecutionInitiated</code>
+     * event corresponding to the <code>RequestCancelExternalWorkflowExecution</code>
+     * decision to cancel this external workflow execution. This information can be
+     * useful for diagnosing problems by tracing back the chain of events leading up to
+     * this event.</p>
+     */
+    inline void SetInitiatedEventId(long long value) { m_initiatedEventIdHasBeenSet = true; m_initiatedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>RequestCancelExternalWorkflowExecutionInitiated</code>
+     * event corresponding to the <code>RequestCancelExternalWorkflowExecution</code>
+     * decision to cancel this external workflow execution. This information can be
+     * useful for diagnosing problems by tracing back the chain of events leading up to
+     * this event.</p>
+     */
+    inline ExternalWorkflowExecutionCancelRequestedEventAttributes& WithInitiatedEventId(long long value) { SetInitiatedEventId(value); return *this;}
+
+  private:
+
+    WorkflowExecution m_workflowExecution;
+    bool m_workflowExecutionHasBeenSet;
+
+    long long m_initiatedEventId;
+    bool m_initiatedEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ExternalWorkflowExecutionSignaledEventAttributes.h

@@ -0,0 +1,115 @@
+/**
+ * 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/model/WorkflowExecution.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>ExternalWorkflowExecutionSignaled</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ExternalWorkflowExecutionSignaledEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ExternalWorkflowExecutionSignaledEventAttributes
+  {
+  public:
+    ExternalWorkflowExecutionSignaledEventAttributes();
+    ExternalWorkflowExecutionSignaledEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    ExternalWorkflowExecutionSignaledEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The external workflow execution that the signal was delivered to.</p>
+     */
+    inline const WorkflowExecution& GetWorkflowExecution() const{ return m_workflowExecution; }
+
+    /**
+     * <p>The external workflow execution that the signal was delivered to.</p>
+     */
+    inline bool WorkflowExecutionHasBeenSet() const { return m_workflowExecutionHasBeenSet; }
+
+    /**
+     * <p>The external workflow execution that the signal was delivered to.</p>
+     */
+    inline void SetWorkflowExecution(const WorkflowExecution& value) { m_workflowExecutionHasBeenSet = true; m_workflowExecution = value; }
+
+    /**
+     * <p>The external workflow execution that the signal was delivered to.</p>
+     */
+    inline void SetWorkflowExecution(WorkflowExecution&& value) { m_workflowExecutionHasBeenSet = true; m_workflowExecution = std::move(value); }
+
+    /**
+     * <p>The external workflow execution that the signal was delivered to.</p>
+     */
+    inline ExternalWorkflowExecutionSignaledEventAttributes& WithWorkflowExecution(const WorkflowExecution& value) { SetWorkflowExecution(value); return *this;}
+
+    /**
+     * <p>The external workflow execution that the signal was delivered to.</p>
+     */
+    inline ExternalWorkflowExecutionSignaledEventAttributes& WithWorkflowExecution(WorkflowExecution&& value) { SetWorkflowExecution(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>SignalExternalWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>SignalExternalWorkflowExecution</code> decision to
+     * request this signal. This information can be useful for diagnosing problems by
+     * tracing back the chain of events leading up to this event.</p>
+     */
+    inline long long GetInitiatedEventId() const{ return m_initiatedEventId; }
+
+    /**
+     * <p>The ID of the <code>SignalExternalWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>SignalExternalWorkflowExecution</code> decision to
+     * request this signal. This information can be useful for diagnosing problems by
+     * tracing back the chain of events leading up to this event.</p>
+     */
+    inline bool InitiatedEventIdHasBeenSet() const { return m_initiatedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>SignalExternalWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>SignalExternalWorkflowExecution</code> decision to
+     * request this signal. This information can be useful for diagnosing problems by
+     * tracing back the chain of events leading up to this event.</p>
+     */
+    inline void SetInitiatedEventId(long long value) { m_initiatedEventIdHasBeenSet = true; m_initiatedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>SignalExternalWorkflowExecutionInitiated</code> event
+     * corresponding to the <code>SignalExternalWorkflowExecution</code> decision to
+     * request this signal. This information can be useful for diagnosing problems by
+     * tracing back the chain of events leading up to this event.</p>
+     */
+    inline ExternalWorkflowExecutionSignaledEventAttributes& WithInitiatedEventId(long long value) { SetInitiatedEventId(value); return *this;}
+
+  private:
+
+    WorkflowExecution m_workflowExecution;
+    bool m_workflowExecutionHasBeenSet;
+
+    long long m_initiatedEventId;
+    bool m_initiatedEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/FailWorkflowExecutionDecisionAttributes.h

@@ -0,0 +1,146 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>FailWorkflowExecution</code> decision.</p>
+   * <p> <b>Access Control</b> </p> <p>You can use IAM policies to control this
+   * decision'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/FailWorkflowExecutionDecisionAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API FailWorkflowExecutionDecisionAttributes
+  {
+  public:
+    FailWorkflowExecutionDecisionAttributes();
+    FailWorkflowExecutionDecisionAttributes(Aws::Utils::Json::JsonView jsonValue);
+    FailWorkflowExecutionDecisionAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>A descriptive reason for the failure that may help in diagnostics.</p>
+     */
+    inline const Aws::String& GetReason() const{ return m_reason; }
+
+    /**
+     * <p>A descriptive reason for the failure that may help in diagnostics.</p>
+     */
+    inline bool ReasonHasBeenSet() const { return m_reasonHasBeenSet; }
+
+    /**
+     * <p>A descriptive reason for the failure that may help in diagnostics.</p>
+     */
+    inline void SetReason(const Aws::String& value) { m_reasonHasBeenSet = true; m_reason = value; }
+
+    /**
+     * <p>A descriptive reason for the failure that may help in diagnostics.</p>
+     */
+    inline void SetReason(Aws::String&& value) { m_reasonHasBeenSet = true; m_reason = std::move(value); }
+
+    /**
+     * <p>A descriptive reason for the failure that may help in diagnostics.</p>
+     */
+    inline void SetReason(const char* value) { m_reasonHasBeenSet = true; m_reason.assign(value); }
+
+    /**
+     * <p>A descriptive reason for the failure that may help in diagnostics.</p>
+     */
+    inline FailWorkflowExecutionDecisionAttributes& WithReason(const Aws::String& value) { SetReason(value); return *this;}
+
+    /**
+     * <p>A descriptive reason for the failure that may help in diagnostics.</p>
+     */
+    inline FailWorkflowExecutionDecisionAttributes& WithReason(Aws::String&& value) { SetReason(std::move(value)); return *this;}
+
+    /**
+     * <p>A descriptive reason for the failure that may help in diagnostics.</p>
+     */
+    inline FailWorkflowExecutionDecisionAttributes& WithReason(const char* value) { SetReason(value); return *this;}
+
+
+    /**
+     * <p> Details of the failure.</p>
+     */
+    inline const Aws::String& GetDetails() const{ return m_details; }
+
+    /**
+     * <p> Details of the failure.</p>
+     */
+    inline bool DetailsHasBeenSet() const { return m_detailsHasBeenSet; }
+
+    /**
+     * <p> Details of the failure.</p>
+     */
+    inline void SetDetails(const Aws::String& value) { m_detailsHasBeenSet = true; m_details = value; }
+
+    /**
+     * <p> Details of the failure.</p>
+     */
+    inline void SetDetails(Aws::String&& value) { m_detailsHasBeenSet = true; m_details = std::move(value); }
+
+    /**
+     * <p> Details of the failure.</p>
+     */
+    inline void SetDetails(const char* value) { m_detailsHasBeenSet = true; m_details.assign(value); }
+
+    /**
+     * <p> Details of the failure.</p>
+     */
+    inline FailWorkflowExecutionDecisionAttributes& WithDetails(const Aws::String& value) { SetDetails(value); return *this;}
+
+    /**
+     * <p> Details of the failure.</p>
+     */
+    inline FailWorkflowExecutionDecisionAttributes& WithDetails(Aws::String&& value) { SetDetails(std::move(value)); return *this;}
+
+    /**
+     * <p> Details of the failure.</p>
+     */
+    inline FailWorkflowExecutionDecisionAttributes& WithDetails(const char* value) { SetDetails(value); return *this;}
+
+  private:
+
+    Aws::String m_reason;
+    bool m_reasonHasBeenSet;
+
+    Aws::String m_details;
+    bool m_detailsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/FailWorkflowExecutionFailedCause.h

@@ -0,0 +1,31 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+  enum class FailWorkflowExecutionFailedCause
+  {
+    NOT_SET,
+    UNHANDLED_DECISION,
+    OPERATION_NOT_PERMITTED
+  };
+
+namespace FailWorkflowExecutionFailedCauseMapper
+{
+AWS_SWF_API FailWorkflowExecutionFailedCause GetFailWorkflowExecutionFailedCauseForName(const Aws::String& name);
+
+AWS_SWF_API Aws::String GetNameForFailWorkflowExecutionFailedCause(FailWorkflowExecutionFailedCause value);
+} // namespace FailWorkflowExecutionFailedCauseMapper
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/FailWorkflowExecutionFailedEventAttributes.h

@@ -0,0 +1,151 @@
+/**
+ * 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/model/FailWorkflowExecutionFailedCause.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>FailWorkflowExecutionFailed</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/FailWorkflowExecutionFailedEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API FailWorkflowExecutionFailedEventAttributes
+  {
+  public:
+    FailWorkflowExecutionFailedEventAttributes();
+    FailWorkflowExecutionFailedEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    FailWorkflowExecutionFailedEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline const FailWorkflowExecutionFailedCause& GetCause() const{ return m_cause; }
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline bool CauseHasBeenSet() const { return m_causeHasBeenSet; }
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline void SetCause(const FailWorkflowExecutionFailedCause& value) { m_causeHasBeenSet = true; m_cause = value; }
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline void SetCause(FailWorkflowExecutionFailedCause&& value) { m_causeHasBeenSet = true; m_cause = std::move(value); }
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline FailWorkflowExecutionFailedEventAttributes& WithCause(const FailWorkflowExecutionFailedCause& value) { SetCause(value); return *this;}
+
+    /**
+     * <p>The cause of the failure. This information is generated by the system and can
+     * be useful for diagnostic purposes.</p>  <p>If <code>cause</code> is set to
+     * <code>OPERATION_NOT_PERMITTED</code>, the decision failed because it lacked
+     * sufficient permissions. 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> 
+     */
+    inline FailWorkflowExecutionFailedEventAttributes& WithCause(FailWorkflowExecutionFailedCause&& value) { SetCause(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>FailWorkflowExecution</code> decision
+     * to fail this execution. This information can be useful for diagnosing problems
+     * by tracing back the chain of events leading up to this event.</p>
+     */
+    inline long long GetDecisionTaskCompletedEventId() const{ return m_decisionTaskCompletedEventId; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>FailWorkflowExecution</code> decision
+     * to fail this execution. This information can be useful for diagnosing problems
+     * by tracing back the chain of events leading up to this event.</p>
+     */
+    inline bool DecisionTaskCompletedEventIdHasBeenSet() const { return m_decisionTaskCompletedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>FailWorkflowExecution</code> decision
+     * to fail this execution. This information can be useful for diagnosing problems
+     * by tracing back the chain of events leading up to this event.</p>
+     */
+    inline void SetDecisionTaskCompletedEventId(long long value) { m_decisionTaskCompletedEventIdHasBeenSet = true; m_decisionTaskCompletedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>FailWorkflowExecution</code> decision
+     * to fail this execution. This information can be useful for diagnosing problems
+     * by tracing back the chain of events leading up to this event.</p>
+     */
+    inline FailWorkflowExecutionFailedEventAttributes& WithDecisionTaskCompletedEventId(long long value) { SetDecisionTaskCompletedEventId(value); return *this;}
+
+  private:
+
+    FailWorkflowExecutionFailedCause m_cause;
+    bool m_causeHasBeenSet;
+
+    long long m_decisionTaskCompletedEventId;
+    bool m_decisionTaskCompletedEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/GetWorkflowExecutionHistoryRequest.h

@@ -0,0 +1,280 @@
+/**
+ * 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/SWFRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/WorkflowExecution.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SWF_API GetWorkflowExecutionHistoryRequest : public SWFRequest
+  {
+  public:
+    GetWorkflowExecutionHistoryRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "GetWorkflowExecutionHistory"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the domain containing the workflow execution.</p>
+     */
+    inline const Aws::String& GetDomain() const{ return m_domain; }
+
+    /**
+     * <p>The name of the domain containing the workflow execution.</p>
+     */
+    inline bool DomainHasBeenSet() const { return m_domainHasBeenSet; }
+
+    /**
+     * <p>The name of the domain containing the workflow execution.</p>
+     */
+    inline void SetDomain(const Aws::String& value) { m_domainHasBeenSet = true; m_domain = value; }
+
+    /**
+     * <p>The name of the domain containing the workflow execution.</p>
+     */
+    inline void SetDomain(Aws::String&& value) { m_domainHasBeenSet = true; m_domain = std::move(value); }
+
+    /**
+     * <p>The name of the domain containing the workflow execution.</p>
+     */
+    inline void SetDomain(const char* value) { m_domainHasBeenSet = true; m_domain.assign(value); }
+
+    /**
+     * <p>The name of the domain containing the workflow execution.</p>
+     */
+    inline GetWorkflowExecutionHistoryRequest& WithDomain(const Aws::String& value) { SetDomain(value); return *this;}
+
+    /**
+     * <p>The name of the domain containing the workflow execution.</p>
+     */
+    inline GetWorkflowExecutionHistoryRequest& WithDomain(Aws::String&& value) { SetDomain(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the domain containing the workflow execution.</p>
+     */
+    inline GetWorkflowExecutionHistoryRequest& WithDomain(const char* value) { SetDomain(value); return *this;}
+
+
+    /**
+     * <p>Specifies the workflow execution for which to return the history.</p>
+     */
+    inline const WorkflowExecution& GetExecution() const{ return m_execution; }
+
+    /**
+     * <p>Specifies the workflow execution for which to return the history.</p>
+     */
+    inline bool ExecutionHasBeenSet() const { return m_executionHasBeenSet; }
+
+    /**
+     * <p>Specifies the workflow execution for which to return the history.</p>
+     */
+    inline void SetExecution(const WorkflowExecution& value) { m_executionHasBeenSet = true; m_execution = value; }
+
+    /**
+     * <p>Specifies the workflow execution for which to return the history.</p>
+     */
+    inline void SetExecution(WorkflowExecution&& value) { m_executionHasBeenSet = true; m_execution = std::move(value); }
+
+    /**
+     * <p>Specifies the workflow execution for which to return the history.</p>
+     */
+    inline GetWorkflowExecutionHistoryRequest& WithExecution(const WorkflowExecution& value) { SetExecution(value); return *this;}
+
+    /**
+     * <p>Specifies the workflow execution for which to return the history.</p>
+     */
+    inline GetWorkflowExecutionHistoryRequest& WithExecution(WorkflowExecution&& value) { SetExecution(std::move(value)); return *this;}
+
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline const Aws::String& GetNextPageToken() const{ return m_nextPageToken; }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline bool NextPageTokenHasBeenSet() const { return m_nextPageTokenHasBeenSet; }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline void SetNextPageToken(const Aws::String& value) { m_nextPageTokenHasBeenSet = true; m_nextPageToken = value; }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline void SetNextPageToken(Aws::String&& value) { m_nextPageTokenHasBeenSet = true; m_nextPageToken = std::move(value); }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline void SetNextPageToken(const char* value) { m_nextPageTokenHasBeenSet = true; m_nextPageToken.assign(value); }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline GetWorkflowExecutionHistoryRequest& WithNextPageToken(const Aws::String& value) { SetNextPageToken(value); return *this;}
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline GetWorkflowExecutionHistoryRequest& WithNextPageToken(Aws::String&& value) { SetNextPageToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline GetWorkflowExecutionHistoryRequest& WithNextPageToken(const char* value) { SetNextPageToken(value); return *this;}
+
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline int GetMaximumPageSize() const{ return m_maximumPageSize; }
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline bool MaximumPageSizeHasBeenSet() const { return m_maximumPageSizeHasBeenSet; }
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline void SetMaximumPageSize(int value) { m_maximumPageSizeHasBeenSet = true; m_maximumPageSize = value; }
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline GetWorkflowExecutionHistoryRequest& WithMaximumPageSize(int value) { SetMaximumPageSize(value); return *this;}
+
+
+    /**
+     * <p>When set to <code>true</code>, returns the events in reverse order. By
+     * default the results are returned in ascending order of the
+     * <code>eventTimeStamp</code> of the events.</p>
+     */
+    inline bool GetReverseOrder() const{ return m_reverseOrder; }
+
+    /**
+     * <p>When set to <code>true</code>, returns the events in reverse order. By
+     * default the results are returned in ascending order of the
+     * <code>eventTimeStamp</code> of the events.</p>
+     */
+    inline bool ReverseOrderHasBeenSet() const { return m_reverseOrderHasBeenSet; }
+
+    /**
+     * <p>When set to <code>true</code>, returns the events in reverse order. By
+     * default the results are returned in ascending order of the
+     * <code>eventTimeStamp</code> of the events.</p>
+     */
+    inline void SetReverseOrder(bool value) { m_reverseOrderHasBeenSet = true; m_reverseOrder = value; }
+
+    /**
+     * <p>When set to <code>true</code>, returns the events in reverse order. By
+     * default the results are returned in ascending order of the
+     * <code>eventTimeStamp</code> of the events.</p>
+     */
+    inline GetWorkflowExecutionHistoryRequest& WithReverseOrder(bool value) { SetReverseOrder(value); return *this;}
+
+  private:
+
+    Aws::String m_domain;
+    bool m_domainHasBeenSet;
+
+    WorkflowExecution m_execution;
+    bool m_executionHasBeenSet;
+
+    Aws::String m_nextPageToken;
+    bool m_nextPageTokenHasBeenSet;
+
+    int m_maximumPageSize;
+    bool m_maximumPageSizeHasBeenSet;
+
+    bool m_reverseOrder;
+    bool m_reverseOrderHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/GetWorkflowExecutionHistoryResult.h

@@ -0,0 +1,153 @@
+/**
+ * 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/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/HistoryEvent.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+  /**
+   * <p>Paginated representation of a workflow history for a workflow execution. This
+   * is the up to date, complete and authoritative record of the events related to
+   * all tasks and events in the life of the workflow execution.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/History">AWS API
+   * Reference</a></p>
+   */
+  class AWS_SWF_API GetWorkflowExecutionHistoryResult
+  {
+  public:
+    GetWorkflowExecutionHistoryResult();
+    GetWorkflowExecutionHistoryResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    GetWorkflowExecutionHistoryResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The list of history events.</p>
+     */
+    inline const Aws::Vector<HistoryEvent>& GetEvents() const{ return m_events; }
+
+    /**
+     * <p>The list of history events.</p>
+     */
+    inline void SetEvents(const Aws::Vector<HistoryEvent>& value) { m_events = value; }
+
+    /**
+     * <p>The list of history events.</p>
+     */
+    inline void SetEvents(Aws::Vector<HistoryEvent>&& value) { m_events = std::move(value); }
+
+    /**
+     * <p>The list of history events.</p>
+     */
+    inline GetWorkflowExecutionHistoryResult& WithEvents(const Aws::Vector<HistoryEvent>& value) { SetEvents(value); return *this;}
+
+    /**
+     * <p>The list of history events.</p>
+     */
+    inline GetWorkflowExecutionHistoryResult& WithEvents(Aws::Vector<HistoryEvent>&& value) { SetEvents(std::move(value)); return *this;}
+
+    /**
+     * <p>The list of history events.</p>
+     */
+    inline GetWorkflowExecutionHistoryResult& AddEvents(const HistoryEvent& value) { m_events.push_back(value); return *this; }
+
+    /**
+     * <p>The list of history events.</p>
+     */
+    inline GetWorkflowExecutionHistoryResult& AddEvents(HistoryEvent&& value) { m_events.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline const Aws::String& GetNextPageToken() const{ return m_nextPageToken; }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline void SetNextPageToken(const Aws::String& value) { m_nextPageToken = value; }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline void SetNextPageToken(Aws::String&& value) { m_nextPageToken = std::move(value); }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline void SetNextPageToken(const char* value) { m_nextPageToken.assign(value); }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline GetWorkflowExecutionHistoryResult& WithNextPageToken(const Aws::String& value) { SetNextPageToken(value); return *this;}
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline GetWorkflowExecutionHistoryResult& WithNextPageToken(Aws::String&& value) { SetNextPageToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline GetWorkflowExecutionHistoryResult& WithNextPageToken(const char* value) { SetNextPageToken(value); return *this;}
+
+  private:
+
+    Aws::Vector<HistoryEvent> m_events;
+
+    Aws::String m_nextPageToken;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/LambdaFunctionCompletedEventAttributes.h

@@ -0,0 +1,153 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>LambdaFunctionCompleted</code> event. It
+   * isn't set for other event types.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/LambdaFunctionCompletedEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API LambdaFunctionCompletedEventAttributes
+  {
+  public:
+    LambdaFunctionCompletedEventAttributes();
+    LambdaFunctionCompletedEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    LambdaFunctionCompletedEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionScheduled</code> event that was recorded
+     * when this Lambda task was scheduled. To help diagnose issues, use this
+     * information to trace back the chain of events leading up to this event.</p>
+     */
+    inline long long GetScheduledEventId() const{ return m_scheduledEventId; }
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionScheduled</code> event that was recorded
+     * when this Lambda task was scheduled. To help diagnose issues, use this
+     * information to trace back the chain of events leading up to this event.</p>
+     */
+    inline bool ScheduledEventIdHasBeenSet() const { return m_scheduledEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionScheduled</code> event that was recorded
+     * when this Lambda task was scheduled. To help diagnose issues, use this
+     * information to trace back the chain of events leading up to this event.</p>
+     */
+    inline void SetScheduledEventId(long long value) { m_scheduledEventIdHasBeenSet = true; m_scheduledEventId = value; }
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionScheduled</code> event that was recorded
+     * when this Lambda task was scheduled. To help diagnose issues, use this
+     * information to trace back the chain of events leading up to this event.</p>
+     */
+    inline LambdaFunctionCompletedEventAttributes& WithScheduledEventId(long long value) { SetScheduledEventId(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionStarted</code> event recorded when this
+     * activity task started. To help diagnose issues, use this information to trace
+     * back the chain of events leading up to this event.</p>
+     */
+    inline long long GetStartedEventId() const{ return m_startedEventId; }
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionStarted</code> event recorded when this
+     * activity task started. To help diagnose issues, use this information to trace
+     * back the chain of events leading up to this event.</p>
+     */
+    inline bool StartedEventIdHasBeenSet() const { return m_startedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionStarted</code> event recorded when this
+     * activity task started. To help diagnose issues, use this information to trace
+     * back the chain of events leading up to this event.</p>
+     */
+    inline void SetStartedEventId(long long value) { m_startedEventIdHasBeenSet = true; m_startedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionStarted</code> event recorded when this
+     * activity task started. To help diagnose issues, use this information to trace
+     * back the chain of events leading up to this event.</p>
+     */
+    inline LambdaFunctionCompletedEventAttributes& WithStartedEventId(long long value) { SetStartedEventId(value); return *this;}
+
+
+    /**
+     * <p>The results of the Lambda task.</p>
+     */
+    inline const Aws::String& GetResult() const{ return m_result; }
+
+    /**
+     * <p>The results of the Lambda task.</p>
+     */
+    inline bool ResultHasBeenSet() const { return m_resultHasBeenSet; }
+
+    /**
+     * <p>The results of the Lambda task.</p>
+     */
+    inline void SetResult(const Aws::String& value) { m_resultHasBeenSet = true; m_result = value; }
+
+    /**
+     * <p>The results of the Lambda task.</p>
+     */
+    inline void SetResult(Aws::String&& value) { m_resultHasBeenSet = true; m_result = std::move(value); }
+
+    /**
+     * <p>The results of the Lambda task.</p>
+     */
+    inline void SetResult(const char* value) { m_resultHasBeenSet = true; m_result.assign(value); }
+
+    /**
+     * <p>The results of the Lambda task.</p>
+     */
+    inline LambdaFunctionCompletedEventAttributes& WithResult(const Aws::String& value) { SetResult(value); return *this;}
+
+    /**
+     * <p>The results of the Lambda task.</p>
+     */
+    inline LambdaFunctionCompletedEventAttributes& WithResult(Aws::String&& value) { SetResult(std::move(value)); return *this;}
+
+    /**
+     * <p>The results of the Lambda task.</p>
+     */
+    inline LambdaFunctionCompletedEventAttributes& WithResult(const char* value) { SetResult(value); return *this;}
+
+  private:
+
+    long long m_scheduledEventId;
+    bool m_scheduledEventIdHasBeenSet;
+
+    long long m_startedEventId;
+    bool m_startedEventIdHasBeenSet;
+
+    Aws::String m_result;
+    bool m_resultHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/LambdaFunctionFailedEventAttributes.h

@@ -0,0 +1,197 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>LambdaFunctionFailed</code> event. It isn't
+   * set for other event types.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/LambdaFunctionFailedEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API LambdaFunctionFailedEventAttributes
+  {
+  public:
+    LambdaFunctionFailedEventAttributes();
+    LambdaFunctionFailedEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    LambdaFunctionFailedEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionScheduled</code> event that was recorded
+     * when this activity task was scheduled. To help diagnose issues, use this
+     * information to trace back the chain of events leading up to this event.</p>
+     */
+    inline long long GetScheduledEventId() const{ return m_scheduledEventId; }
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionScheduled</code> event that was recorded
+     * when this activity task was scheduled. To help diagnose issues, use this
+     * information to trace back the chain of events leading up to this event.</p>
+     */
+    inline bool ScheduledEventIdHasBeenSet() const { return m_scheduledEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionScheduled</code> event that was recorded
+     * when this activity task was scheduled. To help diagnose issues, use this
+     * information to trace back the chain of events leading up to this event.</p>
+     */
+    inline void SetScheduledEventId(long long value) { m_scheduledEventIdHasBeenSet = true; m_scheduledEventId = value; }
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionScheduled</code> event that was recorded
+     * when this activity task was scheduled. To help diagnose issues, use this
+     * information to trace back the chain of events leading up to this event.</p>
+     */
+    inline LambdaFunctionFailedEventAttributes& WithScheduledEventId(long long value) { SetScheduledEventId(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionStarted</code> event recorded when this
+     * activity task started. To help diagnose issues, use this information to trace
+     * back the chain of events leading up to this event.</p>
+     */
+    inline long long GetStartedEventId() const{ return m_startedEventId; }
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionStarted</code> event recorded when this
+     * activity task started. To help diagnose issues, use this information to trace
+     * back the chain of events leading up to this event.</p>
+     */
+    inline bool StartedEventIdHasBeenSet() const { return m_startedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionStarted</code> event recorded when this
+     * activity task started. To help diagnose issues, use this information to trace
+     * back the chain of events leading up to this event.</p>
+     */
+    inline void SetStartedEventId(long long value) { m_startedEventIdHasBeenSet = true; m_startedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionStarted</code> event recorded when this
+     * activity task started. To help diagnose issues, use this information to trace
+     * back the chain of events leading up to this event.</p>
+     */
+    inline LambdaFunctionFailedEventAttributes& WithStartedEventId(long long value) { SetStartedEventId(value); return *this;}
+
+
+    /**
+     * <p>The reason provided for the failure.</p>
+     */
+    inline const Aws::String& GetReason() const{ return m_reason; }
+
+    /**
+     * <p>The reason provided for the failure.</p>
+     */
+    inline bool ReasonHasBeenSet() const { return m_reasonHasBeenSet; }
+
+    /**
+     * <p>The reason provided for the failure.</p>
+     */
+    inline void SetReason(const Aws::String& value) { m_reasonHasBeenSet = true; m_reason = value; }
+
+    /**
+     * <p>The reason provided for the failure.</p>
+     */
+    inline void SetReason(Aws::String&& value) { m_reasonHasBeenSet = true; m_reason = std::move(value); }
+
+    /**
+     * <p>The reason provided for the failure.</p>
+     */
+    inline void SetReason(const char* value) { m_reasonHasBeenSet = true; m_reason.assign(value); }
+
+    /**
+     * <p>The reason provided for the failure.</p>
+     */
+    inline LambdaFunctionFailedEventAttributes& WithReason(const Aws::String& value) { SetReason(value); return *this;}
+
+    /**
+     * <p>The reason provided for the failure.</p>
+     */
+    inline LambdaFunctionFailedEventAttributes& WithReason(Aws::String&& value) { SetReason(std::move(value)); return *this;}
+
+    /**
+     * <p>The reason provided for the failure.</p>
+     */
+    inline LambdaFunctionFailedEventAttributes& WithReason(const char* value) { SetReason(value); return *this;}
+
+
+    /**
+     * <p>The details of the failure.</p>
+     */
+    inline const Aws::String& GetDetails() const{ return m_details; }
+
+    /**
+     * <p>The details of the failure.</p>
+     */
+    inline bool DetailsHasBeenSet() const { return m_detailsHasBeenSet; }
+
+    /**
+     * <p>The details of the failure.</p>
+     */
+    inline void SetDetails(const Aws::String& value) { m_detailsHasBeenSet = true; m_details = value; }
+
+    /**
+     * <p>The details of the failure.</p>
+     */
+    inline void SetDetails(Aws::String&& value) { m_detailsHasBeenSet = true; m_details = std::move(value); }
+
+    /**
+     * <p>The details of the failure.</p>
+     */
+    inline void SetDetails(const char* value) { m_detailsHasBeenSet = true; m_details.assign(value); }
+
+    /**
+     * <p>The details of the failure.</p>
+     */
+    inline LambdaFunctionFailedEventAttributes& WithDetails(const Aws::String& value) { SetDetails(value); return *this;}
+
+    /**
+     * <p>The details of the failure.</p>
+     */
+    inline LambdaFunctionFailedEventAttributes& WithDetails(Aws::String&& value) { SetDetails(std::move(value)); return *this;}
+
+    /**
+     * <p>The details of the failure.</p>
+     */
+    inline LambdaFunctionFailedEventAttributes& WithDetails(const char* value) { SetDetails(value); return *this;}
+
+  private:
+
+    long long m_scheduledEventId;
+    bool m_scheduledEventIdHasBeenSet;
+
+    long long m_startedEventId;
+    bool m_startedEventIdHasBeenSet;
+
+    Aws::String m_reason;
+    bool m_reasonHasBeenSet;
+
+    Aws::String m_details;
+    bool m_detailsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/LambdaFunctionScheduledEventAttributes.h

@@ -0,0 +1,309 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>LambdaFunctionScheduled</code> event. It
+   * isn't set for other event types.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/LambdaFunctionScheduledEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API LambdaFunctionScheduledEventAttributes
+  {
+  public:
+    LambdaFunctionScheduledEventAttributes();
+    LambdaFunctionScheduledEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    LambdaFunctionScheduledEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The unique ID of the Lambda task.</p>
+     */
+    inline const Aws::String& GetId() const{ return m_id; }
+
+    /**
+     * <p>The unique ID of the Lambda task.</p>
+     */
+    inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
+
+    /**
+     * <p>The unique ID of the Lambda task.</p>
+     */
+    inline void SetId(const Aws::String& value) { m_idHasBeenSet = true; m_id = value; }
+
+    /**
+     * <p>The unique ID of the Lambda task.</p>
+     */
+    inline void SetId(Aws::String&& value) { m_idHasBeenSet = true; m_id = std::move(value); }
+
+    /**
+     * <p>The unique ID of the Lambda task.</p>
+     */
+    inline void SetId(const char* value) { m_idHasBeenSet = true; m_id.assign(value); }
+
+    /**
+     * <p>The unique ID of the Lambda task.</p>
+     */
+    inline LambdaFunctionScheduledEventAttributes& WithId(const Aws::String& value) { SetId(value); return *this;}
+
+    /**
+     * <p>The unique ID of the Lambda task.</p>
+     */
+    inline LambdaFunctionScheduledEventAttributes& WithId(Aws::String&& value) { SetId(std::move(value)); return *this;}
+
+    /**
+     * <p>The unique ID of the Lambda task.</p>
+     */
+    inline LambdaFunctionScheduledEventAttributes& WithId(const char* value) { SetId(value); return *this;}
+
+
+    /**
+     * <p>The name of the Lambda function.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>The name of the Lambda function.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>The name of the Lambda function.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>The name of the Lambda function.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>The name of the Lambda function.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>The name of the Lambda function.</p>
+     */
+    inline LambdaFunctionScheduledEventAttributes& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>The name of the Lambda function.</p>
+     */
+    inline LambdaFunctionScheduledEventAttributes& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the Lambda function.</p>
+     */
+    inline LambdaFunctionScheduledEventAttributes& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>Data attached to the event that the decider can use in subsequent workflow
+     * tasks. This data isn't sent to the Lambda task.</p>
+     */
+    inline const Aws::String& GetControl() const{ return m_control; }
+
+    /**
+     * <p>Data attached to the event that the decider can use in subsequent workflow
+     * tasks. This data isn't sent to the Lambda task.</p>
+     */
+    inline bool ControlHasBeenSet() const { return m_controlHasBeenSet; }
+
+    /**
+     * <p>Data attached to the event that the decider can use in subsequent workflow
+     * tasks. This data isn't sent to the Lambda task.</p>
+     */
+    inline void SetControl(const Aws::String& value) { m_controlHasBeenSet = true; m_control = value; }
+
+    /**
+     * <p>Data attached to the event that the decider can use in subsequent workflow
+     * tasks. This data isn't sent to the Lambda task.</p>
+     */
+    inline void SetControl(Aws::String&& value) { m_controlHasBeenSet = true; m_control = std::move(value); }
+
+    /**
+     * <p>Data attached to the event that the decider can use in subsequent workflow
+     * tasks. This data isn't sent to the Lambda task.</p>
+     */
+    inline void SetControl(const char* value) { m_controlHasBeenSet = true; m_control.assign(value); }
+
+    /**
+     * <p>Data attached to the event that the decider can use in subsequent workflow
+     * tasks. This data isn't sent to the Lambda task.</p>
+     */
+    inline LambdaFunctionScheduledEventAttributes& WithControl(const Aws::String& value) { SetControl(value); return *this;}
+
+    /**
+     * <p>Data attached to the event that the decider can use in subsequent workflow
+     * tasks. This data isn't sent to the Lambda task.</p>
+     */
+    inline LambdaFunctionScheduledEventAttributes& WithControl(Aws::String&& value) { SetControl(std::move(value)); return *this;}
+
+    /**
+     * <p>Data attached to the event that the decider can use in subsequent workflow
+     * tasks. This data isn't sent to the Lambda task.</p>
+     */
+    inline LambdaFunctionScheduledEventAttributes& WithControl(const char* value) { SetControl(value); return *this;}
+
+
+    /**
+     * <p>The input provided to the Lambda task.</p>
+     */
+    inline const Aws::String& GetInput() const{ return m_input; }
+
+    /**
+     * <p>The input provided to the Lambda task.</p>
+     */
+    inline bool InputHasBeenSet() const { return m_inputHasBeenSet; }
+
+    /**
+     * <p>The input provided to the Lambda task.</p>
+     */
+    inline void SetInput(const Aws::String& value) { m_inputHasBeenSet = true; m_input = value; }
+
+    /**
+     * <p>The input provided to the Lambda task.</p>
+     */
+    inline void SetInput(Aws::String&& value) { m_inputHasBeenSet = true; m_input = std::move(value); }
+
+    /**
+     * <p>The input provided to the Lambda task.</p>
+     */
+    inline void SetInput(const char* value) { m_inputHasBeenSet = true; m_input.assign(value); }
+
+    /**
+     * <p>The input provided to the Lambda task.</p>
+     */
+    inline LambdaFunctionScheduledEventAttributes& WithInput(const Aws::String& value) { SetInput(value); return *this;}
+
+    /**
+     * <p>The input provided to the Lambda task.</p>
+     */
+    inline LambdaFunctionScheduledEventAttributes& WithInput(Aws::String&& value) { SetInput(std::move(value)); return *this;}
+
+    /**
+     * <p>The input provided to the Lambda task.</p>
+     */
+    inline LambdaFunctionScheduledEventAttributes& WithInput(const char* value) { SetInput(value); return *this;}
+
+
+    /**
+     * <p>The maximum amount of time a worker can take to process the Lambda task.</p>
+     */
+    inline const Aws::String& GetStartToCloseTimeout() const{ return m_startToCloseTimeout; }
+
+    /**
+     * <p>The maximum amount of time a worker can take to process the Lambda task.</p>
+     */
+    inline bool StartToCloseTimeoutHasBeenSet() const { return m_startToCloseTimeoutHasBeenSet; }
+
+    /**
+     * <p>The maximum amount of time a worker can take to process the Lambda task.</p>
+     */
+    inline void SetStartToCloseTimeout(const Aws::String& value) { m_startToCloseTimeoutHasBeenSet = true; m_startToCloseTimeout = value; }
+
+    /**
+     * <p>The maximum amount of time a worker can take to process the Lambda task.</p>
+     */
+    inline void SetStartToCloseTimeout(Aws::String&& value) { m_startToCloseTimeoutHasBeenSet = true; m_startToCloseTimeout = std::move(value); }
+
+    /**
+     * <p>The maximum amount of time a worker can take to process the Lambda task.</p>
+     */
+    inline void SetStartToCloseTimeout(const char* value) { m_startToCloseTimeoutHasBeenSet = true; m_startToCloseTimeout.assign(value); }
+
+    /**
+     * <p>The maximum amount of time a worker can take to process the Lambda task.</p>
+     */
+    inline LambdaFunctionScheduledEventAttributes& WithStartToCloseTimeout(const Aws::String& value) { SetStartToCloseTimeout(value); return *this;}
+
+    /**
+     * <p>The maximum amount of time a worker can take to process the Lambda task.</p>
+     */
+    inline LambdaFunctionScheduledEventAttributes& WithStartToCloseTimeout(Aws::String&& value) { SetStartToCloseTimeout(std::move(value)); return *this;}
+
+    /**
+     * <p>The maximum amount of time a worker can take to process the Lambda task.</p>
+     */
+    inline LambdaFunctionScheduledEventAttributes& WithStartToCloseTimeout(const char* value) { SetStartToCloseTimeout(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionCompleted</code> event corresponding to the
+     * decision that resulted in scheduling this activity task. To help diagnose
+     * issues, use this information to trace back the chain of events leading up to
+     * this event.</p>
+     */
+    inline long long GetDecisionTaskCompletedEventId() const{ return m_decisionTaskCompletedEventId; }
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionCompleted</code> event corresponding to the
+     * decision that resulted in scheduling this activity task. To help diagnose
+     * issues, use this information to trace back the chain of events leading up to
+     * this event.</p>
+     */
+    inline bool DecisionTaskCompletedEventIdHasBeenSet() const { return m_decisionTaskCompletedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionCompleted</code> event corresponding to the
+     * decision that resulted in scheduling this activity task. To help diagnose
+     * issues, use this information to trace back the chain of events leading up to
+     * this event.</p>
+     */
+    inline void SetDecisionTaskCompletedEventId(long long value) { m_decisionTaskCompletedEventIdHasBeenSet = true; m_decisionTaskCompletedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionCompleted</code> event corresponding to the
+     * decision that resulted in scheduling this activity task. To help diagnose
+     * issues, use this information to trace back the chain of events leading up to
+     * this event.</p>
+     */
+    inline LambdaFunctionScheduledEventAttributes& WithDecisionTaskCompletedEventId(long long value) { SetDecisionTaskCompletedEventId(value); return *this;}
+
+  private:
+
+    Aws::String m_id;
+    bool m_idHasBeenSet;
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::String m_control;
+    bool m_controlHasBeenSet;
+
+    Aws::String m_input;
+    bool m_inputHasBeenSet;
+
+    Aws::String m_startToCloseTimeout;
+    bool m_startToCloseTimeoutHasBeenSet;
+
+    long long m_decisionTaskCompletedEventId;
+    bool m_decisionTaskCompletedEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/LambdaFunctionStartedEventAttributes.h

@@ -0,0 +1,75 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/swf/SWF_EXPORTS.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>LambdaFunctionStarted</code> event. It
+   * isn't set for other event types.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/LambdaFunctionStartedEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API LambdaFunctionStartedEventAttributes
+  {
+  public:
+    LambdaFunctionStartedEventAttributes();
+    LambdaFunctionStartedEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    LambdaFunctionStartedEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionScheduled</code> event that was recorded
+     * when this activity task was scheduled. To help diagnose issues, use this
+     * information to trace back the chain of events leading up to this event.</p>
+     */
+    inline long long GetScheduledEventId() const{ return m_scheduledEventId; }
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionScheduled</code> event that was recorded
+     * when this activity task was scheduled. To help diagnose issues, use this
+     * information to trace back the chain of events leading up to this event.</p>
+     */
+    inline bool ScheduledEventIdHasBeenSet() const { return m_scheduledEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionScheduled</code> event that was recorded
+     * when this activity task was scheduled. To help diagnose issues, use this
+     * information to trace back the chain of events leading up to this event.</p>
+     */
+    inline void SetScheduledEventId(long long value) { m_scheduledEventIdHasBeenSet = true; m_scheduledEventId = value; }
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionScheduled</code> event that was recorded
+     * when this activity task was scheduled. To help diagnose issues, use this
+     * information to trace back the chain of events leading up to this event.</p>
+     */
+    inline LambdaFunctionStartedEventAttributes& WithScheduledEventId(long long value) { SetScheduledEventId(value); return *this;}
+
+  private:
+
+    long long m_scheduledEventId;
+    bool m_scheduledEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/LambdaFunctionTimedOutEventAttributes.h

@@ -0,0 +1,143 @@
+/**
+ * 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/model/LambdaFunctionTimeoutType.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides details of the <code>LambdaFunctionTimedOut</code>
+   * event.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/LambdaFunctionTimedOutEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API LambdaFunctionTimedOutEventAttributes
+  {
+  public:
+    LambdaFunctionTimedOutEventAttributes();
+    LambdaFunctionTimedOutEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    LambdaFunctionTimedOutEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionScheduled</code> event that was recorded
+     * when this activity task was scheduled. To help diagnose issues, use this
+     * information to trace back the chain of events leading up to this event.</p>
+     */
+    inline long long GetScheduledEventId() const{ return m_scheduledEventId; }
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionScheduled</code> event that was recorded
+     * when this activity task was scheduled. To help diagnose issues, use this
+     * information to trace back the chain of events leading up to this event.</p>
+     */
+    inline bool ScheduledEventIdHasBeenSet() const { return m_scheduledEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionScheduled</code> event that was recorded
+     * when this activity task was scheduled. To help diagnose issues, use this
+     * information to trace back the chain of events leading up to this event.</p>
+     */
+    inline void SetScheduledEventId(long long value) { m_scheduledEventIdHasBeenSet = true; m_scheduledEventId = value; }
+
+    /**
+     * <p>The ID of the <code>LambdaFunctionScheduled</code> event that was recorded
+     * when this activity task was scheduled. To help diagnose issues, use this
+     * information to trace back the chain of events leading up to this event.</p>
+     */
+    inline LambdaFunctionTimedOutEventAttributes& WithScheduledEventId(long long value) { SetScheduledEventId(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event that was recorded when
+     * this activity task started. To help diagnose issues, use this information to
+     * trace back the chain of events leading up to this event.</p>
+     */
+    inline long long GetStartedEventId() const{ return m_startedEventId; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event that was recorded when
+     * this activity task started. To help diagnose issues, use this information to
+     * trace back the chain of events leading up to this event.</p>
+     */
+    inline bool StartedEventIdHasBeenSet() const { return m_startedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event that was recorded when
+     * this activity task started. To help diagnose issues, use this information to
+     * trace back the chain of events leading up to this event.</p>
+     */
+    inline void SetStartedEventId(long long value) { m_startedEventIdHasBeenSet = true; m_startedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event that was recorded when
+     * this activity task started. To help diagnose issues, use this information to
+     * trace back the chain of events leading up to this event.</p>
+     */
+    inline LambdaFunctionTimedOutEventAttributes& WithStartedEventId(long long value) { SetStartedEventId(value); return *this;}
+
+
+    /**
+     * <p>The type of the timeout that caused this event.</p>
+     */
+    inline const LambdaFunctionTimeoutType& GetTimeoutType() const{ return m_timeoutType; }
+
+    /**
+     * <p>The type of the timeout that caused this event.</p>
+     */
+    inline bool TimeoutTypeHasBeenSet() const { return m_timeoutTypeHasBeenSet; }
+
+    /**
+     * <p>The type of the timeout that caused this event.</p>
+     */
+    inline void SetTimeoutType(const LambdaFunctionTimeoutType& value) { m_timeoutTypeHasBeenSet = true; m_timeoutType = value; }
+
+    /**
+     * <p>The type of the timeout that caused this event.</p>
+     */
+    inline void SetTimeoutType(LambdaFunctionTimeoutType&& value) { m_timeoutTypeHasBeenSet = true; m_timeoutType = std::move(value); }
+
+    /**
+     * <p>The type of the timeout that caused this event.</p>
+     */
+    inline LambdaFunctionTimedOutEventAttributes& WithTimeoutType(const LambdaFunctionTimeoutType& value) { SetTimeoutType(value); return *this;}
+
+    /**
+     * <p>The type of the timeout that caused this event.</p>
+     */
+    inline LambdaFunctionTimedOutEventAttributes& WithTimeoutType(LambdaFunctionTimeoutType&& value) { SetTimeoutType(std::move(value)); return *this;}
+
+  private:
+
+    long long m_scheduledEventId;
+    bool m_scheduledEventIdHasBeenSet;
+
+    long long m_startedEventId;
+    bool m_startedEventIdHasBeenSet;
+
+    LambdaFunctionTimeoutType m_timeoutType;
+    bool m_timeoutTypeHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/LambdaFunctionTimeoutType.h

@@ -0,0 +1,30 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+  enum class LambdaFunctionTimeoutType
+  {
+    NOT_SET,
+    START_TO_CLOSE
+  };
+
+namespace LambdaFunctionTimeoutTypeMapper
+{
+AWS_SWF_API LambdaFunctionTimeoutType GetLambdaFunctionTimeoutTypeForName(const Aws::String& name);
+
+AWS_SWF_API Aws::String GetNameForLambdaFunctionTimeoutType(LambdaFunctionTimeoutType value);
+} // namespace LambdaFunctionTimeoutTypeMapper
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ListActivityTypesRequest.h

@@ -0,0 +1,324 @@
+/**
+ * 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/SWFRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/RegistrationStatus.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SWF_API ListActivityTypesRequest : public SWFRequest
+  {
+  public:
+    ListActivityTypesRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "ListActivityTypes"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the domain in which the activity types have been registered.</p>
+     */
+    inline const Aws::String& GetDomain() const{ return m_domain; }
+
+    /**
+     * <p>The name of the domain in which the activity types have been registered.</p>
+     */
+    inline bool DomainHasBeenSet() const { return m_domainHasBeenSet; }
+
+    /**
+     * <p>The name of the domain in which the activity types have been registered.</p>
+     */
+    inline void SetDomain(const Aws::String& value) { m_domainHasBeenSet = true; m_domain = value; }
+
+    /**
+     * <p>The name of the domain in which the activity types have been registered.</p>
+     */
+    inline void SetDomain(Aws::String&& value) { m_domainHasBeenSet = true; m_domain = std::move(value); }
+
+    /**
+     * <p>The name of the domain in which the activity types have been registered.</p>
+     */
+    inline void SetDomain(const char* value) { m_domainHasBeenSet = true; m_domain.assign(value); }
+
+    /**
+     * <p>The name of the domain in which the activity types have been registered.</p>
+     */
+    inline ListActivityTypesRequest& WithDomain(const Aws::String& value) { SetDomain(value); return *this;}
+
+    /**
+     * <p>The name of the domain in which the activity types have been registered.</p>
+     */
+    inline ListActivityTypesRequest& WithDomain(Aws::String&& value) { SetDomain(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the domain in which the activity types have been registered.</p>
+     */
+    inline ListActivityTypesRequest& WithDomain(const char* value) { SetDomain(value); return *this;}
+
+
+    /**
+     * <p>If specified, only lists the activity types that have this name.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>If specified, only lists the activity types that have this name.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>If specified, only lists the activity types that have this name.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>If specified, only lists the activity types that have this name.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>If specified, only lists the activity types that have this name.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>If specified, only lists the activity types that have this name.</p>
+     */
+    inline ListActivityTypesRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>If specified, only lists the activity types that have this name.</p>
+     */
+    inline ListActivityTypesRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>If specified, only lists the activity types that have this name.</p>
+     */
+    inline ListActivityTypesRequest& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>Specifies the registration status of the activity types to list.</p>
+     */
+    inline const RegistrationStatus& GetRegistrationStatus() const{ return m_registrationStatus; }
+
+    /**
+     * <p>Specifies the registration status of the activity types to list.</p>
+     */
+    inline bool RegistrationStatusHasBeenSet() const { return m_registrationStatusHasBeenSet; }
+
+    /**
+     * <p>Specifies the registration status of the activity types to list.</p>
+     */
+    inline void SetRegistrationStatus(const RegistrationStatus& value) { m_registrationStatusHasBeenSet = true; m_registrationStatus = value; }
+
+    /**
+     * <p>Specifies the registration status of the activity types to list.</p>
+     */
+    inline void SetRegistrationStatus(RegistrationStatus&& value) { m_registrationStatusHasBeenSet = true; m_registrationStatus = std::move(value); }
+
+    /**
+     * <p>Specifies the registration status of the activity types to list.</p>
+     */
+    inline ListActivityTypesRequest& WithRegistrationStatus(const RegistrationStatus& value) { SetRegistrationStatus(value); return *this;}
+
+    /**
+     * <p>Specifies the registration status of the activity types to list.</p>
+     */
+    inline ListActivityTypesRequest& WithRegistrationStatus(RegistrationStatus&& value) { SetRegistrationStatus(std::move(value)); return *this;}
+
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline const Aws::String& GetNextPageToken() const{ return m_nextPageToken; }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline bool NextPageTokenHasBeenSet() const { return m_nextPageTokenHasBeenSet; }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline void SetNextPageToken(const Aws::String& value) { m_nextPageTokenHasBeenSet = true; m_nextPageToken = value; }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline void SetNextPageToken(Aws::String&& value) { m_nextPageTokenHasBeenSet = true; m_nextPageToken = std::move(value); }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline void SetNextPageToken(const char* value) { m_nextPageTokenHasBeenSet = true; m_nextPageToken.assign(value); }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline ListActivityTypesRequest& WithNextPageToken(const Aws::String& value) { SetNextPageToken(value); return *this;}
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline ListActivityTypesRequest& WithNextPageToken(Aws::String&& value) { SetNextPageToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline ListActivityTypesRequest& WithNextPageToken(const char* value) { SetNextPageToken(value); return *this;}
+
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline int GetMaximumPageSize() const{ return m_maximumPageSize; }
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline bool MaximumPageSizeHasBeenSet() const { return m_maximumPageSizeHasBeenSet; }
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline void SetMaximumPageSize(int value) { m_maximumPageSizeHasBeenSet = true; m_maximumPageSize = value; }
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline ListActivityTypesRequest& WithMaximumPageSize(int value) { SetMaximumPageSize(value); return *this;}
+
+
+    /**
+     * <p>When set to <code>true</code>, returns the results in reverse order. By
+     * default, the results are returned in ascending alphabetical order by
+     * <code>name</code> of the activity types.</p>
+     */
+    inline bool GetReverseOrder() const{ return m_reverseOrder; }
+
+    /**
+     * <p>When set to <code>true</code>, returns the results in reverse order. By
+     * default, the results are returned in ascending alphabetical order by
+     * <code>name</code> of the activity types.</p>
+     */
+    inline bool ReverseOrderHasBeenSet() const { return m_reverseOrderHasBeenSet; }
+
+    /**
+     * <p>When set to <code>true</code>, returns the results in reverse order. By
+     * default, the results are returned in ascending alphabetical order by
+     * <code>name</code> of the activity types.</p>
+     */
+    inline void SetReverseOrder(bool value) { m_reverseOrderHasBeenSet = true; m_reverseOrder = value; }
+
+    /**
+     * <p>When set to <code>true</code>, returns the results in reverse order. By
+     * default, the results are returned in ascending alphabetical order by
+     * <code>name</code> of the activity types.</p>
+     */
+    inline ListActivityTypesRequest& WithReverseOrder(bool value) { SetReverseOrder(value); return *this;}
+
+  private:
+
+    Aws::String m_domain;
+    bool m_domainHasBeenSet;
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    RegistrationStatus m_registrationStatus;
+    bool m_registrationStatusHasBeenSet;
+
+    Aws::String m_nextPageToken;
+    bool m_nextPageTokenHasBeenSet;
+
+    int m_maximumPageSize;
+    bool m_maximumPageSizeHasBeenSet;
+
+    bool m_reverseOrder;
+    bool m_reverseOrderHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ListActivityTypesResult.h

@@ -0,0 +1,151 @@
+/**
+ * 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/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/ActivityTypeInfo.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+  /**
+   * <p>Contains a paginated list of activity type information
+   * structures.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ActivityTypeInfos">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ListActivityTypesResult
+  {
+  public:
+    ListActivityTypesResult();
+    ListActivityTypesResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListActivityTypesResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>List of activity type information.</p>
+     */
+    inline const Aws::Vector<ActivityTypeInfo>& GetTypeInfos() const{ return m_typeInfos; }
+
+    /**
+     * <p>List of activity type information.</p>
+     */
+    inline void SetTypeInfos(const Aws::Vector<ActivityTypeInfo>& value) { m_typeInfos = value; }
+
+    /**
+     * <p>List of activity type information.</p>
+     */
+    inline void SetTypeInfos(Aws::Vector<ActivityTypeInfo>&& value) { m_typeInfos = std::move(value); }
+
+    /**
+     * <p>List of activity type information.</p>
+     */
+    inline ListActivityTypesResult& WithTypeInfos(const Aws::Vector<ActivityTypeInfo>& value) { SetTypeInfos(value); return *this;}
+
+    /**
+     * <p>List of activity type information.</p>
+     */
+    inline ListActivityTypesResult& WithTypeInfos(Aws::Vector<ActivityTypeInfo>&& value) { SetTypeInfos(std::move(value)); return *this;}
+
+    /**
+     * <p>List of activity type information.</p>
+     */
+    inline ListActivityTypesResult& AddTypeInfos(const ActivityTypeInfo& value) { m_typeInfos.push_back(value); return *this; }
+
+    /**
+     * <p>List of activity type information.</p>
+     */
+    inline ListActivityTypesResult& AddTypeInfos(ActivityTypeInfo&& value) { m_typeInfos.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline const Aws::String& GetNextPageToken() const{ return m_nextPageToken; }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline void SetNextPageToken(const Aws::String& value) { m_nextPageToken = value; }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline void SetNextPageToken(Aws::String&& value) { m_nextPageToken = std::move(value); }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline void SetNextPageToken(const char* value) { m_nextPageToken.assign(value); }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline ListActivityTypesResult& WithNextPageToken(const Aws::String& value) { SetNextPageToken(value); return *this;}
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline ListActivityTypesResult& WithNextPageToken(Aws::String&& value) { SetNextPageToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline ListActivityTypesResult& WithNextPageToken(const char* value) { SetNextPageToken(value); return *this;}
+
+  private:
+
+    Aws::Vector<ActivityTypeInfo> m_typeInfos;
+
+    Aws::String m_nextPageToken;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ListClosedWorkflowExecutionsRequest.h

@@ -0,0 +1,610 @@
+/**
+ * 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/SWFRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/ExecutionTimeFilter.h>
+#include <aws/swf/model/WorkflowExecutionFilter.h>
+#include <aws/swf/model/CloseStatusFilter.h>
+#include <aws/swf/model/WorkflowTypeFilter.h>
+#include <aws/swf/model/TagFilter.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SWF_API ListClosedWorkflowExecutionsRequest : public SWFRequest
+  {
+  public:
+    ListClosedWorkflowExecutionsRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "ListClosedWorkflowExecutions"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the domain that contains the workflow executions to list.</p>
+     */
+    inline const Aws::String& GetDomain() const{ return m_domain; }
+
+    /**
+     * <p>The name of the domain that contains the workflow executions to list.</p>
+     */
+    inline bool DomainHasBeenSet() const { return m_domainHasBeenSet; }
+
+    /**
+     * <p>The name of the domain that contains the workflow executions to list.</p>
+     */
+    inline void SetDomain(const Aws::String& value) { m_domainHasBeenSet = true; m_domain = value; }
+
+    /**
+     * <p>The name of the domain that contains the workflow executions to list.</p>
+     */
+    inline void SetDomain(Aws::String&& value) { m_domainHasBeenSet = true; m_domain = std::move(value); }
+
+    /**
+     * <p>The name of the domain that contains the workflow executions to list.</p>
+     */
+    inline void SetDomain(const char* value) { m_domainHasBeenSet = true; m_domain.assign(value); }
+
+    /**
+     * <p>The name of the domain that contains the workflow executions to list.</p>
+     */
+    inline ListClosedWorkflowExecutionsRequest& WithDomain(const Aws::String& value) { SetDomain(value); return *this;}
+
+    /**
+     * <p>The name of the domain that contains the workflow executions to list.</p>
+     */
+    inline ListClosedWorkflowExecutionsRequest& WithDomain(Aws::String&& value) { SetDomain(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the domain that contains the workflow executions to list.</p>
+     */
+    inline ListClosedWorkflowExecutionsRequest& WithDomain(const char* value) { SetDomain(value); return *this;}
+
+
+    /**
+     * <p>If specified, the workflow executions are included in the returned results
+     * based on whether their start times are within the range specified by this
+     * filter. Also, if this parameter is specified, the returned results are ordered
+     * by their start times.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline const ExecutionTimeFilter& GetStartTimeFilter() const{ return m_startTimeFilter; }
+
+    /**
+     * <p>If specified, the workflow executions are included in the returned results
+     * based on whether their start times are within the range specified by this
+     * filter. Also, if this parameter is specified, the returned results are ordered
+     * by their start times.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline bool StartTimeFilterHasBeenSet() const { return m_startTimeFilterHasBeenSet; }
+
+    /**
+     * <p>If specified, the workflow executions are included in the returned results
+     * based on whether their start times are within the range specified by this
+     * filter. Also, if this parameter is specified, the returned results are ordered
+     * by their start times.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline void SetStartTimeFilter(const ExecutionTimeFilter& value) { m_startTimeFilterHasBeenSet = true; m_startTimeFilter = value; }
+
+    /**
+     * <p>If specified, the workflow executions are included in the returned results
+     * based on whether their start times are within the range specified by this
+     * filter. Also, if this parameter is specified, the returned results are ordered
+     * by their start times.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline void SetStartTimeFilter(ExecutionTimeFilter&& value) { m_startTimeFilterHasBeenSet = true; m_startTimeFilter = std::move(value); }
+
+    /**
+     * <p>If specified, the workflow executions are included in the returned results
+     * based on whether their start times are within the range specified by this
+     * filter. Also, if this parameter is specified, the returned results are ordered
+     * by their start times.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline ListClosedWorkflowExecutionsRequest& WithStartTimeFilter(const ExecutionTimeFilter& value) { SetStartTimeFilter(value); return *this;}
+
+    /**
+     * <p>If specified, the workflow executions are included in the returned results
+     * based on whether their start times are within the range specified by this
+     * filter. Also, if this parameter is specified, the returned results are ordered
+     * by their start times.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline ListClosedWorkflowExecutionsRequest& WithStartTimeFilter(ExecutionTimeFilter&& value) { SetStartTimeFilter(std::move(value)); return *this;}
+
+
+    /**
+     * <p>If specified, the workflow executions are included in the returned results
+     * based on whether their close times are within the range specified by this
+     * filter. Also, if this parameter is specified, the returned results are ordered
+     * by their close times.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline const ExecutionTimeFilter& GetCloseTimeFilter() const{ return m_closeTimeFilter; }
+
+    /**
+     * <p>If specified, the workflow executions are included in the returned results
+     * based on whether their close times are within the range specified by this
+     * filter. Also, if this parameter is specified, the returned results are ordered
+     * by their close times.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline bool CloseTimeFilterHasBeenSet() const { return m_closeTimeFilterHasBeenSet; }
+
+    /**
+     * <p>If specified, the workflow executions are included in the returned results
+     * based on whether their close times are within the range specified by this
+     * filter. Also, if this parameter is specified, the returned results are ordered
+     * by their close times.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline void SetCloseTimeFilter(const ExecutionTimeFilter& value) { m_closeTimeFilterHasBeenSet = true; m_closeTimeFilter = value; }
+
+    /**
+     * <p>If specified, the workflow executions are included in the returned results
+     * based on whether their close times are within the range specified by this
+     * filter. Also, if this parameter is specified, the returned results are ordered
+     * by their close times.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline void SetCloseTimeFilter(ExecutionTimeFilter&& value) { m_closeTimeFilterHasBeenSet = true; m_closeTimeFilter = std::move(value); }
+
+    /**
+     * <p>If specified, the workflow executions are included in the returned results
+     * based on whether their close times are within the range specified by this
+     * filter. Also, if this parameter is specified, the returned results are ordered
+     * by their close times.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline ListClosedWorkflowExecutionsRequest& WithCloseTimeFilter(const ExecutionTimeFilter& value) { SetCloseTimeFilter(value); return *this;}
+
+    /**
+     * <p>If specified, the workflow executions are included in the returned results
+     * based on whether their close times are within the range specified by this
+     * filter. Also, if this parameter is specified, the returned results are ordered
+     * by their close times.</p>  <p> <code>startTimeFilter</code> and
+     * <code>closeTimeFilter</code> are mutually exclusive. You must specify one of
+     * these in a request but not both.</p> 
+     */
+    inline ListClosedWorkflowExecutionsRequest& WithCloseTimeFilter(ExecutionTimeFilter&& value) { SetCloseTimeFilter(std::move(value)); return *this;}
+
+
+    /**
+     * <p>If specified, only workflow executions matching the workflow ID specified in
+     * the filter are returned.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline const WorkflowExecutionFilter& GetExecutionFilter() const{ return m_executionFilter; }
+
+    /**
+     * <p>If specified, only workflow executions matching the workflow ID specified in
+     * the filter are returned.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline bool ExecutionFilterHasBeenSet() const { return m_executionFilterHasBeenSet; }
+
+    /**
+     * <p>If specified, only workflow executions matching the workflow ID specified in
+     * the filter are returned.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline void SetExecutionFilter(const WorkflowExecutionFilter& value) { m_executionFilterHasBeenSet = true; m_executionFilter = value; }
+
+    /**
+     * <p>If specified, only workflow executions matching the workflow ID specified in
+     * the filter are returned.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline void SetExecutionFilter(WorkflowExecutionFilter&& value) { m_executionFilterHasBeenSet = true; m_executionFilter = std::move(value); }
+
+    /**
+     * <p>If specified, only workflow executions matching the workflow ID specified in
+     * the filter are returned.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline ListClosedWorkflowExecutionsRequest& WithExecutionFilter(const WorkflowExecutionFilter& value) { SetExecutionFilter(value); return *this;}
+
+    /**
+     * <p>If specified, only workflow executions matching the workflow ID specified in
+     * the filter are returned.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline ListClosedWorkflowExecutionsRequest& WithExecutionFilter(WorkflowExecutionFilter&& value) { SetExecutionFilter(std::move(value)); return *this;}
+
+
+    /**
+     * <p>If specified, only workflow executions that match this <i>close status</i>
+     * are listed. For example, if TERMINATED is specified, then only TERMINATED
+     * workflow executions are listed.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline const CloseStatusFilter& GetCloseStatusFilter() const{ return m_closeStatusFilter; }
+
+    /**
+     * <p>If specified, only workflow executions that match this <i>close status</i>
+     * are listed. For example, if TERMINATED is specified, then only TERMINATED
+     * workflow executions are listed.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline bool CloseStatusFilterHasBeenSet() const { return m_closeStatusFilterHasBeenSet; }
+
+    /**
+     * <p>If specified, only workflow executions that match this <i>close status</i>
+     * are listed. For example, if TERMINATED is specified, then only TERMINATED
+     * workflow executions are listed.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline void SetCloseStatusFilter(const CloseStatusFilter& value) { m_closeStatusFilterHasBeenSet = true; m_closeStatusFilter = value; }
+
+    /**
+     * <p>If specified, only workflow executions that match this <i>close status</i>
+     * are listed. For example, if TERMINATED is specified, then only TERMINATED
+     * workflow executions are listed.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline void SetCloseStatusFilter(CloseStatusFilter&& value) { m_closeStatusFilterHasBeenSet = true; m_closeStatusFilter = std::move(value); }
+
+    /**
+     * <p>If specified, only workflow executions that match this <i>close status</i>
+     * are listed. For example, if TERMINATED is specified, then only TERMINATED
+     * workflow executions are listed.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline ListClosedWorkflowExecutionsRequest& WithCloseStatusFilter(const CloseStatusFilter& value) { SetCloseStatusFilter(value); return *this;}
+
+    /**
+     * <p>If specified, only workflow executions that match this <i>close status</i>
+     * are listed. For example, if TERMINATED is specified, then only TERMINATED
+     * workflow executions are listed.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline ListClosedWorkflowExecutionsRequest& WithCloseStatusFilter(CloseStatusFilter&& value) { SetCloseStatusFilter(std::move(value)); return *this;}
+
+
+    /**
+     * <p>If specified, only executions of the type specified in the filter are
+     * returned.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline const WorkflowTypeFilter& GetTypeFilter() const{ return m_typeFilter; }
+
+    /**
+     * <p>If specified, only executions of the type specified in the filter are
+     * returned.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline bool TypeFilterHasBeenSet() const { return m_typeFilterHasBeenSet; }
+
+    /**
+     * <p>If specified, only executions of the type specified in the filter are
+     * returned.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline void SetTypeFilter(const WorkflowTypeFilter& value) { m_typeFilterHasBeenSet = true; m_typeFilter = value; }
+
+    /**
+     * <p>If specified, only executions of the type specified in the filter are
+     * returned.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline void SetTypeFilter(WorkflowTypeFilter&& value) { m_typeFilterHasBeenSet = true; m_typeFilter = std::move(value); }
+
+    /**
+     * <p>If specified, only executions of the type specified in the filter are
+     * returned.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline ListClosedWorkflowExecutionsRequest& WithTypeFilter(const WorkflowTypeFilter& value) { SetTypeFilter(value); return *this;}
+
+    /**
+     * <p>If specified, only executions of the type specified in the filter are
+     * returned.</p>  <p> <code>closeStatusFilter</code>,
+     * <code>executionFilter</code>, <code>typeFilter</code> and <code>tagFilter</code>
+     * are mutually exclusive. You can specify at most one of these in a request.</p>
+     * 
+     */
+    inline ListClosedWorkflowExecutionsRequest& WithTypeFilter(WorkflowTypeFilter&& value) { SetTypeFilter(std::move(value)); return *this;}
+
+
+    /**
+     * <p>If specified, only executions that have the matching tag are listed.</p>
+     *  <p> <code>closeStatusFilter</code>, <code>executionFilter</code>,
+     * <code>typeFilter</code> and <code>tagFilter</code> are mutually exclusive. You
+     * can specify at most one of these in a request.</p> 
+     */
+    inline const TagFilter& GetTagFilter() const{ return m_tagFilter; }
+
+    /**
+     * <p>If specified, only executions that have the matching tag are listed.</p>
+     *  <p> <code>closeStatusFilter</code>, <code>executionFilter</code>,
+     * <code>typeFilter</code> and <code>tagFilter</code> are mutually exclusive. You
+     * can specify at most one of these in a request.</p> 
+     */
+    inline bool TagFilterHasBeenSet() const { return m_tagFilterHasBeenSet; }
+
+    /**
+     * <p>If specified, only executions that have the matching tag are listed.</p>
+     *  <p> <code>closeStatusFilter</code>, <code>executionFilter</code>,
+     * <code>typeFilter</code> and <code>tagFilter</code> are mutually exclusive. You
+     * can specify at most one of these in a request.</p> 
+     */
+    inline void SetTagFilter(const TagFilter& value) { m_tagFilterHasBeenSet = true; m_tagFilter = value; }
+
+    /**
+     * <p>If specified, only executions that have the matching tag are listed.</p>
+     *  <p> <code>closeStatusFilter</code>, <code>executionFilter</code>,
+     * <code>typeFilter</code> and <code>tagFilter</code> are mutually exclusive. You
+     * can specify at most one of these in a request.</p> 
+     */
+    inline void SetTagFilter(TagFilter&& value) { m_tagFilterHasBeenSet = true; m_tagFilter = std::move(value); }
+
+    /**
+     * <p>If specified, only executions that have the matching tag are listed.</p>
+     *  <p> <code>closeStatusFilter</code>, <code>executionFilter</code>,
+     * <code>typeFilter</code> and <code>tagFilter</code> are mutually exclusive. You
+     * can specify at most one of these in a request.</p> 
+     */
+    inline ListClosedWorkflowExecutionsRequest& WithTagFilter(const TagFilter& value) { SetTagFilter(value); return *this;}
+
+    /**
+     * <p>If specified, only executions that have the matching tag are listed.</p>
+     *  <p> <code>closeStatusFilter</code>, <code>executionFilter</code>,
+     * <code>typeFilter</code> and <code>tagFilter</code> are mutually exclusive. You
+     * can specify at most one of these in a request.</p> 
+     */
+    inline ListClosedWorkflowExecutionsRequest& WithTagFilter(TagFilter&& value) { SetTagFilter(std::move(value)); return *this;}
+
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline const Aws::String& GetNextPageToken() const{ return m_nextPageToken; }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline bool NextPageTokenHasBeenSet() const { return m_nextPageTokenHasBeenSet; }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline void SetNextPageToken(const Aws::String& value) { m_nextPageTokenHasBeenSet = true; m_nextPageToken = value; }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline void SetNextPageToken(Aws::String&& value) { m_nextPageTokenHasBeenSet = true; m_nextPageToken = std::move(value); }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline void SetNextPageToken(const char* value) { m_nextPageTokenHasBeenSet = true; m_nextPageToken.assign(value); }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline ListClosedWorkflowExecutionsRequest& WithNextPageToken(const Aws::String& value) { SetNextPageToken(value); return *this;}
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline ListClosedWorkflowExecutionsRequest& WithNextPageToken(Aws::String&& value) { SetNextPageToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline ListClosedWorkflowExecutionsRequest& WithNextPageToken(const char* value) { SetNextPageToken(value); return *this;}
+
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline int GetMaximumPageSize() const{ return m_maximumPageSize; }
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline bool MaximumPageSizeHasBeenSet() const { return m_maximumPageSizeHasBeenSet; }
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline void SetMaximumPageSize(int value) { m_maximumPageSizeHasBeenSet = true; m_maximumPageSize = value; }
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline ListClosedWorkflowExecutionsRequest& WithMaximumPageSize(int value) { SetMaximumPageSize(value); return *this;}
+
+
+    /**
+     * <p>When set to <code>true</code>, returns the results in reverse order. By
+     * default the results are returned in descending order of the start or the close
+     * time of the executions.</p>
+     */
+    inline bool GetReverseOrder() const{ return m_reverseOrder; }
+
+    /**
+     * <p>When set to <code>true</code>, returns the results in reverse order. By
+     * default the results are returned in descending order of the start or the close
+     * time of the executions.</p>
+     */
+    inline bool ReverseOrderHasBeenSet() const { return m_reverseOrderHasBeenSet; }
+
+    /**
+     * <p>When set to <code>true</code>, returns the results in reverse order. By
+     * default the results are returned in descending order of the start or the close
+     * time of the executions.</p>
+     */
+    inline void SetReverseOrder(bool value) { m_reverseOrderHasBeenSet = true; m_reverseOrder = value; }
+
+    /**
+     * <p>When set to <code>true</code>, returns the results in reverse order. By
+     * default the results are returned in descending order of the start or the close
+     * time of the executions.</p>
+     */
+    inline ListClosedWorkflowExecutionsRequest& WithReverseOrder(bool value) { SetReverseOrder(value); return *this;}
+
+  private:
+
+    Aws::String m_domain;
+    bool m_domainHasBeenSet;
+
+    ExecutionTimeFilter m_startTimeFilter;
+    bool m_startTimeFilterHasBeenSet;
+
+    ExecutionTimeFilter m_closeTimeFilter;
+    bool m_closeTimeFilterHasBeenSet;
+
+    WorkflowExecutionFilter m_executionFilter;
+    bool m_executionFilterHasBeenSet;
+
+    CloseStatusFilter m_closeStatusFilter;
+    bool m_closeStatusFilterHasBeenSet;
+
+    WorkflowTypeFilter m_typeFilter;
+    bool m_typeFilterHasBeenSet;
+
+    TagFilter m_tagFilter;
+    bool m_tagFilterHasBeenSet;
+
+    Aws::String m_nextPageToken;
+    bool m_nextPageTokenHasBeenSet;
+
+    int m_maximumPageSize;
+    bool m_maximumPageSizeHasBeenSet;
+
+    bool m_reverseOrder;
+    bool m_reverseOrderHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ListClosedWorkflowExecutionsResult.h

@@ -0,0 +1,151 @@
+/**
+ * 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/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/WorkflowExecutionInfo.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+  /**
+   * <p>Contains a paginated list of information about workflow
+   * executions.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/WorkflowExecutionInfos">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ListClosedWorkflowExecutionsResult
+  {
+  public:
+    ListClosedWorkflowExecutionsResult();
+    ListClosedWorkflowExecutionsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListClosedWorkflowExecutionsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The list of workflow information structures.</p>
+     */
+    inline const Aws::Vector<WorkflowExecutionInfo>& GetExecutionInfos() const{ return m_executionInfos; }
+
+    /**
+     * <p>The list of workflow information structures.</p>
+     */
+    inline void SetExecutionInfos(const Aws::Vector<WorkflowExecutionInfo>& value) { m_executionInfos = value; }
+
+    /**
+     * <p>The list of workflow information structures.</p>
+     */
+    inline void SetExecutionInfos(Aws::Vector<WorkflowExecutionInfo>&& value) { m_executionInfos = std::move(value); }
+
+    /**
+     * <p>The list of workflow information structures.</p>
+     */
+    inline ListClosedWorkflowExecutionsResult& WithExecutionInfos(const Aws::Vector<WorkflowExecutionInfo>& value) { SetExecutionInfos(value); return *this;}
+
+    /**
+     * <p>The list of workflow information structures.</p>
+     */
+    inline ListClosedWorkflowExecutionsResult& WithExecutionInfos(Aws::Vector<WorkflowExecutionInfo>&& value) { SetExecutionInfos(std::move(value)); return *this;}
+
+    /**
+     * <p>The list of workflow information structures.</p>
+     */
+    inline ListClosedWorkflowExecutionsResult& AddExecutionInfos(const WorkflowExecutionInfo& value) { m_executionInfos.push_back(value); return *this; }
+
+    /**
+     * <p>The list of workflow information structures.</p>
+     */
+    inline ListClosedWorkflowExecutionsResult& AddExecutionInfos(WorkflowExecutionInfo&& value) { m_executionInfos.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline const Aws::String& GetNextPageToken() const{ return m_nextPageToken; }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline void SetNextPageToken(const Aws::String& value) { m_nextPageToken = value; }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline void SetNextPageToken(Aws::String&& value) { m_nextPageToken = std::move(value); }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline void SetNextPageToken(const char* value) { m_nextPageToken.assign(value); }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline ListClosedWorkflowExecutionsResult& WithNextPageToken(const Aws::String& value) { SetNextPageToken(value); return *this;}
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline ListClosedWorkflowExecutionsResult& WithNextPageToken(Aws::String&& value) { SetNextPageToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline ListClosedWorkflowExecutionsResult& WithNextPageToken(const char* value) { SetNextPageToken(value); return *this;}
+
+  private:
+
+    Aws::Vector<WorkflowExecutionInfo> m_executionInfos;
+
+    Aws::String m_nextPageToken;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ListDomainsRequest.h

@@ -0,0 +1,236 @@
+/**
+ * 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/SWFRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/RegistrationStatus.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SWF_API ListDomainsRequest : public SWFRequest
+  {
+  public:
+    ListDomainsRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "ListDomains"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline const Aws::String& GetNextPageToken() const{ return m_nextPageToken; }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline bool NextPageTokenHasBeenSet() const { return m_nextPageTokenHasBeenSet; }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline void SetNextPageToken(const Aws::String& value) { m_nextPageTokenHasBeenSet = true; m_nextPageToken = value; }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline void SetNextPageToken(Aws::String&& value) { m_nextPageTokenHasBeenSet = true; m_nextPageToken = std::move(value); }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline void SetNextPageToken(const char* value) { m_nextPageTokenHasBeenSet = true; m_nextPageToken.assign(value); }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline ListDomainsRequest& WithNextPageToken(const Aws::String& value) { SetNextPageToken(value); return *this;}
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline ListDomainsRequest& WithNextPageToken(Aws::String&& value) { SetNextPageToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline ListDomainsRequest& WithNextPageToken(const char* value) { SetNextPageToken(value); return *this;}
+
+
+    /**
+     * <p>Specifies the registration status of the domains to list.</p>
+     */
+    inline const RegistrationStatus& GetRegistrationStatus() const{ return m_registrationStatus; }
+
+    /**
+     * <p>Specifies the registration status of the domains to list.</p>
+     */
+    inline bool RegistrationStatusHasBeenSet() const { return m_registrationStatusHasBeenSet; }
+
+    /**
+     * <p>Specifies the registration status of the domains to list.</p>
+     */
+    inline void SetRegistrationStatus(const RegistrationStatus& value) { m_registrationStatusHasBeenSet = true; m_registrationStatus = value; }
+
+    /**
+     * <p>Specifies the registration status of the domains to list.</p>
+     */
+    inline void SetRegistrationStatus(RegistrationStatus&& value) { m_registrationStatusHasBeenSet = true; m_registrationStatus = std::move(value); }
+
+    /**
+     * <p>Specifies the registration status of the domains to list.</p>
+     */
+    inline ListDomainsRequest& WithRegistrationStatus(const RegistrationStatus& value) { SetRegistrationStatus(value); return *this;}
+
+    /**
+     * <p>Specifies the registration status of the domains to list.</p>
+     */
+    inline ListDomainsRequest& WithRegistrationStatus(RegistrationStatus&& value) { SetRegistrationStatus(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline int GetMaximumPageSize() const{ return m_maximumPageSize; }
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline bool MaximumPageSizeHasBeenSet() const { return m_maximumPageSizeHasBeenSet; }
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline void SetMaximumPageSize(int value) { m_maximumPageSizeHasBeenSet = true; m_maximumPageSize = value; }
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline ListDomainsRequest& WithMaximumPageSize(int value) { SetMaximumPageSize(value); return *this;}
+
+
+    /**
+     * <p>When set to <code>true</code>, returns the results in reverse order. By
+     * default, the results are returned in ascending alphabetical order by
+     * <code>name</code> of the domains.</p>
+     */
+    inline bool GetReverseOrder() const{ return m_reverseOrder; }
+
+    /**
+     * <p>When set to <code>true</code>, returns the results in reverse order. By
+     * default, the results are returned in ascending alphabetical order by
+     * <code>name</code> of the domains.</p>
+     */
+    inline bool ReverseOrderHasBeenSet() const { return m_reverseOrderHasBeenSet; }
+
+    /**
+     * <p>When set to <code>true</code>, returns the results in reverse order. By
+     * default, the results are returned in ascending alphabetical order by
+     * <code>name</code> of the domains.</p>
+     */
+    inline void SetReverseOrder(bool value) { m_reverseOrderHasBeenSet = true; m_reverseOrder = value; }
+
+    /**
+     * <p>When set to <code>true</code>, returns the results in reverse order. By
+     * default, the results are returned in ascending alphabetical order by
+     * <code>name</code> of the domains.</p>
+     */
+    inline ListDomainsRequest& WithReverseOrder(bool value) { SetReverseOrder(value); return *this;}
+
+  private:
+
+    Aws::String m_nextPageToken;
+    bool m_nextPageTokenHasBeenSet;
+
+    RegistrationStatus m_registrationStatus;
+    bool m_registrationStatusHasBeenSet;
+
+    int m_maximumPageSize;
+    bool m_maximumPageSizeHasBeenSet;
+
+    bool m_reverseOrder;
+    bool m_reverseOrderHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ListDomainsResult.h

@@ -0,0 +1,151 @@
+/**
+ * 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/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/DomainInfo.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+  /**
+   * <p>Contains a paginated collection of DomainInfo structures.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DomainInfos">AWS API
+   * Reference</a></p>
+   */
+  class AWS_SWF_API ListDomainsResult
+  {
+  public:
+    ListDomainsResult();
+    ListDomainsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListDomainsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>A list of DomainInfo structures.</p>
+     */
+    inline const Aws::Vector<DomainInfo>& GetDomainInfos() const{ return m_domainInfos; }
+
+    /**
+     * <p>A list of DomainInfo structures.</p>
+     */
+    inline void SetDomainInfos(const Aws::Vector<DomainInfo>& value) { m_domainInfos = value; }
+
+    /**
+     * <p>A list of DomainInfo structures.</p>
+     */
+    inline void SetDomainInfos(Aws::Vector<DomainInfo>&& value) { m_domainInfos = std::move(value); }
+
+    /**
+     * <p>A list of DomainInfo structures.</p>
+     */
+    inline ListDomainsResult& WithDomainInfos(const Aws::Vector<DomainInfo>& value) { SetDomainInfos(value); return *this;}
+
+    /**
+     * <p>A list of DomainInfo structures.</p>
+     */
+    inline ListDomainsResult& WithDomainInfos(Aws::Vector<DomainInfo>&& value) { SetDomainInfos(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of DomainInfo structures.</p>
+     */
+    inline ListDomainsResult& AddDomainInfos(const DomainInfo& value) { m_domainInfos.push_back(value); return *this; }
+
+    /**
+     * <p>A list of DomainInfo structures.</p>
+     */
+    inline ListDomainsResult& AddDomainInfos(DomainInfo&& value) { m_domainInfos.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline const Aws::String& GetNextPageToken() const{ return m_nextPageToken; }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline void SetNextPageToken(const Aws::String& value) { m_nextPageToken = value; }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline void SetNextPageToken(Aws::String&& value) { m_nextPageToken = std::move(value); }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline void SetNextPageToken(const char* value) { m_nextPageToken.assign(value); }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline ListDomainsResult& WithNextPageToken(const Aws::String& value) { SetNextPageToken(value); return *this;}
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline ListDomainsResult& WithNextPageToken(Aws::String&& value) { SetNextPageToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline ListDomainsResult& WithNextPageToken(const char* value) { SetNextPageToken(value); return *this;}
+
+  private:
+
+    Aws::Vector<DomainInfo> m_domainInfos;
+
+    Aws::String m_nextPageToken;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ListOpenWorkflowExecutionsRequest.h

@@ -0,0 +1,445 @@
+/**
+ * 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/SWFRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/ExecutionTimeFilter.h>
+#include <aws/swf/model/WorkflowTypeFilter.h>
+#include <aws/swf/model/TagFilter.h>
+#include <aws/swf/model/WorkflowExecutionFilter.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SWF_API ListOpenWorkflowExecutionsRequest : public SWFRequest
+  {
+  public:
+    ListOpenWorkflowExecutionsRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "ListOpenWorkflowExecutions"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the domain that contains the workflow executions to list.</p>
+     */
+    inline const Aws::String& GetDomain() const{ return m_domain; }
+
+    /**
+     * <p>The name of the domain that contains the workflow executions to list.</p>
+     */
+    inline bool DomainHasBeenSet() const { return m_domainHasBeenSet; }
+
+    /**
+     * <p>The name of the domain that contains the workflow executions to list.</p>
+     */
+    inline void SetDomain(const Aws::String& value) { m_domainHasBeenSet = true; m_domain = value; }
+
+    /**
+     * <p>The name of the domain that contains the workflow executions to list.</p>
+     */
+    inline void SetDomain(Aws::String&& value) { m_domainHasBeenSet = true; m_domain = std::move(value); }
+
+    /**
+     * <p>The name of the domain that contains the workflow executions to list.</p>
+     */
+    inline void SetDomain(const char* value) { m_domainHasBeenSet = true; m_domain.assign(value); }
+
+    /**
+     * <p>The name of the domain that contains the workflow executions to list.</p>
+     */
+    inline ListOpenWorkflowExecutionsRequest& WithDomain(const Aws::String& value) { SetDomain(value); return *this;}
+
+    /**
+     * <p>The name of the domain that contains the workflow executions to list.</p>
+     */
+    inline ListOpenWorkflowExecutionsRequest& WithDomain(Aws::String&& value) { SetDomain(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the domain that contains the workflow executions to list.</p>
+     */
+    inline ListOpenWorkflowExecutionsRequest& WithDomain(const char* value) { SetDomain(value); return *this;}
+
+
+    /**
+     * <p>Workflow executions are included in the returned results based on whether
+     * their start times are within the range specified by this filter.</p>
+     */
+    inline const ExecutionTimeFilter& GetStartTimeFilter() const{ return m_startTimeFilter; }
+
+    /**
+     * <p>Workflow executions are included in the returned results based on whether
+     * their start times are within the range specified by this filter.</p>
+     */
+    inline bool StartTimeFilterHasBeenSet() const { return m_startTimeFilterHasBeenSet; }
+
+    /**
+     * <p>Workflow executions are included in the returned results based on whether
+     * their start times are within the range specified by this filter.</p>
+     */
+    inline void SetStartTimeFilter(const ExecutionTimeFilter& value) { m_startTimeFilterHasBeenSet = true; m_startTimeFilter = value; }
+
+    /**
+     * <p>Workflow executions are included in the returned results based on whether
+     * their start times are within the range specified by this filter.</p>
+     */
+    inline void SetStartTimeFilter(ExecutionTimeFilter&& value) { m_startTimeFilterHasBeenSet = true; m_startTimeFilter = std::move(value); }
+
+    /**
+     * <p>Workflow executions are included in the returned results based on whether
+     * their start times are within the range specified by this filter.</p>
+     */
+    inline ListOpenWorkflowExecutionsRequest& WithStartTimeFilter(const ExecutionTimeFilter& value) { SetStartTimeFilter(value); return *this;}
+
+    /**
+     * <p>Workflow executions are included in the returned results based on whether
+     * their start times are within the range specified by this filter.</p>
+     */
+    inline ListOpenWorkflowExecutionsRequest& WithStartTimeFilter(ExecutionTimeFilter&& value) { SetStartTimeFilter(std::move(value)); return *this;}
+
+
+    /**
+     * <p>If specified, only executions of the type specified in the filter are
+     * returned.</p>  <p> <code>executionFilter</code>, <code>typeFilter</code>
+     * and <code>tagFilter</code> are mutually exclusive. You can specify at most one
+     * of these in a request.</p> 
+     */
+    inline const WorkflowTypeFilter& GetTypeFilter() const{ return m_typeFilter; }
+
+    /**
+     * <p>If specified, only executions of the type specified in the filter are
+     * returned.</p>  <p> <code>executionFilter</code>, <code>typeFilter</code>
+     * and <code>tagFilter</code> are mutually exclusive. You can specify at most one
+     * of these in a request.</p> 
+     */
+    inline bool TypeFilterHasBeenSet() const { return m_typeFilterHasBeenSet; }
+
+    /**
+     * <p>If specified, only executions of the type specified in the filter are
+     * returned.</p>  <p> <code>executionFilter</code>, <code>typeFilter</code>
+     * and <code>tagFilter</code> are mutually exclusive. You can specify at most one
+     * of these in a request.</p> 
+     */
+    inline void SetTypeFilter(const WorkflowTypeFilter& value) { m_typeFilterHasBeenSet = true; m_typeFilter = value; }
+
+    /**
+     * <p>If specified, only executions of the type specified in the filter are
+     * returned.</p>  <p> <code>executionFilter</code>, <code>typeFilter</code>
+     * and <code>tagFilter</code> are mutually exclusive. You can specify at most one
+     * of these in a request.</p> 
+     */
+    inline void SetTypeFilter(WorkflowTypeFilter&& value) { m_typeFilterHasBeenSet = true; m_typeFilter = std::move(value); }
+
+    /**
+     * <p>If specified, only executions of the type specified in the filter are
+     * returned.</p>  <p> <code>executionFilter</code>, <code>typeFilter</code>
+     * and <code>tagFilter</code> are mutually exclusive. You can specify at most one
+     * of these in a request.</p> 
+     */
+    inline ListOpenWorkflowExecutionsRequest& WithTypeFilter(const WorkflowTypeFilter& value) { SetTypeFilter(value); return *this;}
+
+    /**
+     * <p>If specified, only executions of the type specified in the filter are
+     * returned.</p>  <p> <code>executionFilter</code>, <code>typeFilter</code>
+     * and <code>tagFilter</code> are mutually exclusive. You can specify at most one
+     * of these in a request.</p> 
+     */
+    inline ListOpenWorkflowExecutionsRequest& WithTypeFilter(WorkflowTypeFilter&& value) { SetTypeFilter(std::move(value)); return *this;}
+
+
+    /**
+     * <p>If specified, only executions that have the matching tag are listed.</p>
+     *  <p> <code>executionFilter</code>, <code>typeFilter</code> and
+     * <code>tagFilter</code> are mutually exclusive. You can specify at most one of
+     * these in a request.</p> 
+     */
+    inline const TagFilter& GetTagFilter() const{ return m_tagFilter; }
+
+    /**
+     * <p>If specified, only executions that have the matching tag are listed.</p>
+     *  <p> <code>executionFilter</code>, <code>typeFilter</code> and
+     * <code>tagFilter</code> are mutually exclusive. You can specify at most one of
+     * these in a request.</p> 
+     */
+    inline bool TagFilterHasBeenSet() const { return m_tagFilterHasBeenSet; }
+
+    /**
+     * <p>If specified, only executions that have the matching tag are listed.</p>
+     *  <p> <code>executionFilter</code>, <code>typeFilter</code> and
+     * <code>tagFilter</code> are mutually exclusive. You can specify at most one of
+     * these in a request.</p> 
+     */
+    inline void SetTagFilter(const TagFilter& value) { m_tagFilterHasBeenSet = true; m_tagFilter = value; }
+
+    /**
+     * <p>If specified, only executions that have the matching tag are listed.</p>
+     *  <p> <code>executionFilter</code>, <code>typeFilter</code> and
+     * <code>tagFilter</code> are mutually exclusive. You can specify at most one of
+     * these in a request.</p> 
+     */
+    inline void SetTagFilter(TagFilter&& value) { m_tagFilterHasBeenSet = true; m_tagFilter = std::move(value); }
+
+    /**
+     * <p>If specified, only executions that have the matching tag are listed.</p>
+     *  <p> <code>executionFilter</code>, <code>typeFilter</code> and
+     * <code>tagFilter</code> are mutually exclusive. You can specify at most one of
+     * these in a request.</p> 
+     */
+    inline ListOpenWorkflowExecutionsRequest& WithTagFilter(const TagFilter& value) { SetTagFilter(value); return *this;}
+
+    /**
+     * <p>If specified, only executions that have the matching tag are listed.</p>
+     *  <p> <code>executionFilter</code>, <code>typeFilter</code> and
+     * <code>tagFilter</code> are mutually exclusive. You can specify at most one of
+     * these in a request.</p> 
+     */
+    inline ListOpenWorkflowExecutionsRequest& WithTagFilter(TagFilter&& value) { SetTagFilter(std::move(value)); return *this;}
+
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline const Aws::String& GetNextPageToken() const{ return m_nextPageToken; }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline bool NextPageTokenHasBeenSet() const { return m_nextPageTokenHasBeenSet; }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline void SetNextPageToken(const Aws::String& value) { m_nextPageTokenHasBeenSet = true; m_nextPageToken = value; }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline void SetNextPageToken(Aws::String&& value) { m_nextPageTokenHasBeenSet = true; m_nextPageToken = std::move(value); }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline void SetNextPageToken(const char* value) { m_nextPageTokenHasBeenSet = true; m_nextPageToken.assign(value); }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline ListOpenWorkflowExecutionsRequest& WithNextPageToken(const Aws::String& value) { SetNextPageToken(value); return *this;}
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline ListOpenWorkflowExecutionsRequest& WithNextPageToken(Aws::String&& value) { SetNextPageToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline ListOpenWorkflowExecutionsRequest& WithNextPageToken(const char* value) { SetNextPageToken(value); return *this;}
+
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline int GetMaximumPageSize() const{ return m_maximumPageSize; }
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline bool MaximumPageSizeHasBeenSet() const { return m_maximumPageSizeHasBeenSet; }
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline void SetMaximumPageSize(int value) { m_maximumPageSizeHasBeenSet = true; m_maximumPageSize = value; }
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline ListOpenWorkflowExecutionsRequest& WithMaximumPageSize(int value) { SetMaximumPageSize(value); return *this;}
+
+
+    /**
+     * <p>When set to <code>true</code>, returns the results in reverse order. By
+     * default the results are returned in descending order of the start time of the
+     * executions.</p>
+     */
+    inline bool GetReverseOrder() const{ return m_reverseOrder; }
+
+    /**
+     * <p>When set to <code>true</code>, returns the results in reverse order. By
+     * default the results are returned in descending order of the start time of the
+     * executions.</p>
+     */
+    inline bool ReverseOrderHasBeenSet() const { return m_reverseOrderHasBeenSet; }
+
+    /**
+     * <p>When set to <code>true</code>, returns the results in reverse order. By
+     * default the results are returned in descending order of the start time of the
+     * executions.</p>
+     */
+    inline void SetReverseOrder(bool value) { m_reverseOrderHasBeenSet = true; m_reverseOrder = value; }
+
+    /**
+     * <p>When set to <code>true</code>, returns the results in reverse order. By
+     * default the results are returned in descending order of the start time of the
+     * executions.</p>
+     */
+    inline ListOpenWorkflowExecutionsRequest& WithReverseOrder(bool value) { SetReverseOrder(value); return *this;}
+
+
+    /**
+     * <p>If specified, only workflow executions matching the workflow ID specified in
+     * the filter are returned.</p>  <p> <code>executionFilter</code>,
+     * <code>typeFilter</code> and <code>tagFilter</code> are mutually exclusive. You
+     * can specify at most one of these in a request.</p> 
+     */
+    inline const WorkflowExecutionFilter& GetExecutionFilter() const{ return m_executionFilter; }
+
+    /**
+     * <p>If specified, only workflow executions matching the workflow ID specified in
+     * the filter are returned.</p>  <p> <code>executionFilter</code>,
+     * <code>typeFilter</code> and <code>tagFilter</code> are mutually exclusive. You
+     * can specify at most one of these in a request.</p> 
+     */
+    inline bool ExecutionFilterHasBeenSet() const { return m_executionFilterHasBeenSet; }
+
+    /**
+     * <p>If specified, only workflow executions matching the workflow ID specified in
+     * the filter are returned.</p>  <p> <code>executionFilter</code>,
+     * <code>typeFilter</code> and <code>tagFilter</code> are mutually exclusive. You
+     * can specify at most one of these in a request.</p> 
+     */
+    inline void SetExecutionFilter(const WorkflowExecutionFilter& value) { m_executionFilterHasBeenSet = true; m_executionFilter = value; }
+
+    /**
+     * <p>If specified, only workflow executions matching the workflow ID specified in
+     * the filter are returned.</p>  <p> <code>executionFilter</code>,
+     * <code>typeFilter</code> and <code>tagFilter</code> are mutually exclusive. You
+     * can specify at most one of these in a request.</p> 
+     */
+    inline void SetExecutionFilter(WorkflowExecutionFilter&& value) { m_executionFilterHasBeenSet = true; m_executionFilter = std::move(value); }
+
+    /**
+     * <p>If specified, only workflow executions matching the workflow ID specified in
+     * the filter are returned.</p>  <p> <code>executionFilter</code>,
+     * <code>typeFilter</code> and <code>tagFilter</code> are mutually exclusive. You
+     * can specify at most one of these in a request.</p> 
+     */
+    inline ListOpenWorkflowExecutionsRequest& WithExecutionFilter(const WorkflowExecutionFilter& value) { SetExecutionFilter(value); return *this;}
+
+    /**
+     * <p>If specified, only workflow executions matching the workflow ID specified in
+     * the filter are returned.</p>  <p> <code>executionFilter</code>,
+     * <code>typeFilter</code> and <code>tagFilter</code> are mutually exclusive. You
+     * can specify at most one of these in a request.</p> 
+     */
+    inline ListOpenWorkflowExecutionsRequest& WithExecutionFilter(WorkflowExecutionFilter&& value) { SetExecutionFilter(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_domain;
+    bool m_domainHasBeenSet;
+
+    ExecutionTimeFilter m_startTimeFilter;
+    bool m_startTimeFilterHasBeenSet;
+
+    WorkflowTypeFilter m_typeFilter;
+    bool m_typeFilterHasBeenSet;
+
+    TagFilter m_tagFilter;
+    bool m_tagFilterHasBeenSet;
+
+    Aws::String m_nextPageToken;
+    bool m_nextPageTokenHasBeenSet;
+
+    int m_maximumPageSize;
+    bool m_maximumPageSizeHasBeenSet;
+
+    bool m_reverseOrder;
+    bool m_reverseOrderHasBeenSet;
+
+    WorkflowExecutionFilter m_executionFilter;
+    bool m_executionFilterHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ListOpenWorkflowExecutionsResult.h

@@ -0,0 +1,151 @@
+/**
+ * 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/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/WorkflowExecutionInfo.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+  /**
+   * <p>Contains a paginated list of information about workflow
+   * executions.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/WorkflowExecutionInfos">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ListOpenWorkflowExecutionsResult
+  {
+  public:
+    ListOpenWorkflowExecutionsResult();
+    ListOpenWorkflowExecutionsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListOpenWorkflowExecutionsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The list of workflow information structures.</p>
+     */
+    inline const Aws::Vector<WorkflowExecutionInfo>& GetExecutionInfos() const{ return m_executionInfos; }
+
+    /**
+     * <p>The list of workflow information structures.</p>
+     */
+    inline void SetExecutionInfos(const Aws::Vector<WorkflowExecutionInfo>& value) { m_executionInfos = value; }
+
+    /**
+     * <p>The list of workflow information structures.</p>
+     */
+    inline void SetExecutionInfos(Aws::Vector<WorkflowExecutionInfo>&& value) { m_executionInfos = std::move(value); }
+
+    /**
+     * <p>The list of workflow information structures.</p>
+     */
+    inline ListOpenWorkflowExecutionsResult& WithExecutionInfos(const Aws::Vector<WorkflowExecutionInfo>& value) { SetExecutionInfos(value); return *this;}
+
+    /**
+     * <p>The list of workflow information structures.</p>
+     */
+    inline ListOpenWorkflowExecutionsResult& WithExecutionInfos(Aws::Vector<WorkflowExecutionInfo>&& value) { SetExecutionInfos(std::move(value)); return *this;}
+
+    /**
+     * <p>The list of workflow information structures.</p>
+     */
+    inline ListOpenWorkflowExecutionsResult& AddExecutionInfos(const WorkflowExecutionInfo& value) { m_executionInfos.push_back(value); return *this; }
+
+    /**
+     * <p>The list of workflow information structures.</p>
+     */
+    inline ListOpenWorkflowExecutionsResult& AddExecutionInfos(WorkflowExecutionInfo&& value) { m_executionInfos.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline const Aws::String& GetNextPageToken() const{ return m_nextPageToken; }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline void SetNextPageToken(const Aws::String& value) { m_nextPageToken = value; }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline void SetNextPageToken(Aws::String&& value) { m_nextPageToken = std::move(value); }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline void SetNextPageToken(const char* value) { m_nextPageToken.assign(value); }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline ListOpenWorkflowExecutionsResult& WithNextPageToken(const Aws::String& value) { SetNextPageToken(value); return *this;}
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline ListOpenWorkflowExecutionsResult& WithNextPageToken(Aws::String&& value) { SetNextPageToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline ListOpenWorkflowExecutionsResult& WithNextPageToken(const char* value) { SetNextPageToken(value); return *this;}
+
+  private:
+
+    Aws::Vector<WorkflowExecutionInfo> m_executionInfos;
+
+    Aws::String m_nextPageToken;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ListTagsForResourceRequest.h

@@ -0,0 +1,85 @@
+/**
+ * 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/SWFRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SWF_API ListTagsForResourceRequest : public SWFRequest
+  {
+  public:
+    ListTagsForResourceRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "ListTagsForResource"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the Amazon SWF domain.</p>
+     */
+    inline const Aws::String& GetResourceArn() const{ return m_resourceArn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the Amazon SWF domain.</p>
+     */
+    inline bool ResourceArnHasBeenSet() const { return m_resourceArnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the Amazon SWF domain.</p>
+     */
+    inline void SetResourceArn(const Aws::String& value) { m_resourceArnHasBeenSet = true; m_resourceArn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the Amazon SWF domain.</p>
+     */
+    inline void SetResourceArn(Aws::String&& value) { m_resourceArnHasBeenSet = true; m_resourceArn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the Amazon SWF domain.</p>
+     */
+    inline void SetResourceArn(const char* value) { m_resourceArnHasBeenSet = true; m_resourceArn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the Amazon SWF domain.</p>
+     */
+    inline ListTagsForResourceRequest& WithResourceArn(const Aws::String& value) { SetResourceArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the Amazon SWF domain.</p>
+     */
+    inline ListTagsForResourceRequest& WithResourceArn(Aws::String&& value) { SetResourceArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the Amazon SWF domain.</p>
+     */
+    inline ListTagsForResourceRequest& WithResourceArn(const char* value) { SetResourceArn(value); return *this;}
+
+  private:
+
+    Aws::String m_resourceArn;
+    bool m_resourceArnHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ListTagsForResourceResult.h

@@ -0,0 +1,78 @@
+/**
+ * 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/core/utils/memory/stl/AWSVector.h>
+#include <aws/swf/model/ResourceTag.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+  class AWS_SWF_API ListTagsForResourceResult
+  {
+  public:
+    ListTagsForResourceResult();
+    ListTagsForResourceResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListTagsForResourceResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>An array of tags associated with the domain.</p>
+     */
+    inline const Aws::Vector<ResourceTag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>An array of tags associated with the domain.</p>
+     */
+    inline void SetTags(const Aws::Vector<ResourceTag>& value) { m_tags = value; }
+
+    /**
+     * <p>An array of tags associated with the domain.</p>
+     */
+    inline void SetTags(Aws::Vector<ResourceTag>&& value) { m_tags = std::move(value); }
+
+    /**
+     * <p>An array of tags associated with the domain.</p>
+     */
+    inline ListTagsForResourceResult& WithTags(const Aws::Vector<ResourceTag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>An array of tags associated with the domain.</p>
+     */
+    inline ListTagsForResourceResult& WithTags(Aws::Vector<ResourceTag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>An array of tags associated with the domain.</p>
+     */
+    inline ListTagsForResourceResult& AddTags(const ResourceTag& value) { m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>An array of tags associated with the domain.</p>
+     */
+    inline ListTagsForResourceResult& AddTags(ResourceTag&& value) { m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::Vector<ResourceTag> m_tags;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ListWorkflowTypesRequest.h

@@ -0,0 +1,324 @@
+/**
+ * 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/SWFRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/RegistrationStatus.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SWF_API ListWorkflowTypesRequest : public SWFRequest
+  {
+  public:
+    ListWorkflowTypesRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "ListWorkflowTypes"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the domain in which the workflow types have been registered.</p>
+     */
+    inline const Aws::String& GetDomain() const{ return m_domain; }
+
+    /**
+     * <p>The name of the domain in which the workflow types have been registered.</p>
+     */
+    inline bool DomainHasBeenSet() const { return m_domainHasBeenSet; }
+
+    /**
+     * <p>The name of the domain in which the workflow types have been registered.</p>
+     */
+    inline void SetDomain(const Aws::String& value) { m_domainHasBeenSet = true; m_domain = value; }
+
+    /**
+     * <p>The name of the domain in which the workflow types have been registered.</p>
+     */
+    inline void SetDomain(Aws::String&& value) { m_domainHasBeenSet = true; m_domain = std::move(value); }
+
+    /**
+     * <p>The name of the domain in which the workflow types have been registered.</p>
+     */
+    inline void SetDomain(const char* value) { m_domainHasBeenSet = true; m_domain.assign(value); }
+
+    /**
+     * <p>The name of the domain in which the workflow types have been registered.</p>
+     */
+    inline ListWorkflowTypesRequest& WithDomain(const Aws::String& value) { SetDomain(value); return *this;}
+
+    /**
+     * <p>The name of the domain in which the workflow types have been registered.</p>
+     */
+    inline ListWorkflowTypesRequest& WithDomain(Aws::String&& value) { SetDomain(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the domain in which the workflow types have been registered.</p>
+     */
+    inline ListWorkflowTypesRequest& WithDomain(const char* value) { SetDomain(value); return *this;}
+
+
+    /**
+     * <p>If specified, lists the workflow type with this name.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>If specified, lists the workflow type with this name.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>If specified, lists the workflow type with this name.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>If specified, lists the workflow type with this name.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>If specified, lists the workflow type with this name.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>If specified, lists the workflow type with this name.</p>
+     */
+    inline ListWorkflowTypesRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>If specified, lists the workflow type with this name.</p>
+     */
+    inline ListWorkflowTypesRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>If specified, lists the workflow type with this name.</p>
+     */
+    inline ListWorkflowTypesRequest& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>Specifies the registration status of the workflow types to list.</p>
+     */
+    inline const RegistrationStatus& GetRegistrationStatus() const{ return m_registrationStatus; }
+
+    /**
+     * <p>Specifies the registration status of the workflow types to list.</p>
+     */
+    inline bool RegistrationStatusHasBeenSet() const { return m_registrationStatusHasBeenSet; }
+
+    /**
+     * <p>Specifies the registration status of the workflow types to list.</p>
+     */
+    inline void SetRegistrationStatus(const RegistrationStatus& value) { m_registrationStatusHasBeenSet = true; m_registrationStatus = value; }
+
+    /**
+     * <p>Specifies the registration status of the workflow types to list.</p>
+     */
+    inline void SetRegistrationStatus(RegistrationStatus&& value) { m_registrationStatusHasBeenSet = true; m_registrationStatus = std::move(value); }
+
+    /**
+     * <p>Specifies the registration status of the workflow types to list.</p>
+     */
+    inline ListWorkflowTypesRequest& WithRegistrationStatus(const RegistrationStatus& value) { SetRegistrationStatus(value); return *this;}
+
+    /**
+     * <p>Specifies the registration status of the workflow types to list.</p>
+     */
+    inline ListWorkflowTypesRequest& WithRegistrationStatus(RegistrationStatus&& value) { SetRegistrationStatus(std::move(value)); return *this;}
+
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline const Aws::String& GetNextPageToken() const{ return m_nextPageToken; }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline bool NextPageTokenHasBeenSet() const { return m_nextPageTokenHasBeenSet; }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline void SetNextPageToken(const Aws::String& value) { m_nextPageTokenHasBeenSet = true; m_nextPageToken = value; }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline void SetNextPageToken(Aws::String&& value) { m_nextPageTokenHasBeenSet = true; m_nextPageToken = std::move(value); }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline void SetNextPageToken(const char* value) { m_nextPageTokenHasBeenSet = true; m_nextPageToken.assign(value); }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline ListWorkflowTypesRequest& WithNextPageToken(const Aws::String& value) { SetNextPageToken(value); return *this;}
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline ListWorkflowTypesRequest& WithNextPageToken(Aws::String&& value) { SetNextPageToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>
+     */
+    inline ListWorkflowTypesRequest& WithNextPageToken(const char* value) { SetNextPageToken(value); return *this;}
+
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline int GetMaximumPageSize() const{ return m_maximumPageSize; }
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline bool MaximumPageSizeHasBeenSet() const { return m_maximumPageSizeHasBeenSet; }
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline void SetMaximumPageSize(int value) { m_maximumPageSizeHasBeenSet = true; m_maximumPageSize = value; }
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p>
+     */
+    inline ListWorkflowTypesRequest& WithMaximumPageSize(int value) { SetMaximumPageSize(value); return *this;}
+
+
+    /**
+     * <p>When set to <code>true</code>, returns the results in reverse order. By
+     * default the results are returned in ascending alphabetical order of the
+     * <code>name</code> of the workflow types.</p>
+     */
+    inline bool GetReverseOrder() const{ return m_reverseOrder; }
+
+    /**
+     * <p>When set to <code>true</code>, returns the results in reverse order. By
+     * default the results are returned in ascending alphabetical order of the
+     * <code>name</code> of the workflow types.</p>
+     */
+    inline bool ReverseOrderHasBeenSet() const { return m_reverseOrderHasBeenSet; }
+
+    /**
+     * <p>When set to <code>true</code>, returns the results in reverse order. By
+     * default the results are returned in ascending alphabetical order of the
+     * <code>name</code> of the workflow types.</p>
+     */
+    inline void SetReverseOrder(bool value) { m_reverseOrderHasBeenSet = true; m_reverseOrder = value; }
+
+    /**
+     * <p>When set to <code>true</code>, returns the results in reverse order. By
+     * default the results are returned in ascending alphabetical order of the
+     * <code>name</code> of the workflow types.</p>
+     */
+    inline ListWorkflowTypesRequest& WithReverseOrder(bool value) { SetReverseOrder(value); return *this;}
+
+  private:
+
+    Aws::String m_domain;
+    bool m_domainHasBeenSet;
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    RegistrationStatus m_registrationStatus;
+    bool m_registrationStatusHasBeenSet;
+
+    Aws::String m_nextPageToken;
+    bool m_nextPageTokenHasBeenSet;
+
+    int m_maximumPageSize;
+    bool m_maximumPageSizeHasBeenSet;
+
+    bool m_reverseOrder;
+    bool m_reverseOrderHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/ListWorkflowTypesResult.h

@@ -0,0 +1,151 @@
+/**
+ * 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/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/WorkflowTypeInfo.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+  /**
+   * <p>Contains a paginated list of information structures about workflow
+   * types.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/WorkflowTypeInfos">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API ListWorkflowTypesResult
+  {
+  public:
+    ListWorkflowTypesResult();
+    ListWorkflowTypesResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListWorkflowTypesResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The list of workflow type information.</p>
+     */
+    inline const Aws::Vector<WorkflowTypeInfo>& GetTypeInfos() const{ return m_typeInfos; }
+
+    /**
+     * <p>The list of workflow type information.</p>
+     */
+    inline void SetTypeInfos(const Aws::Vector<WorkflowTypeInfo>& value) { m_typeInfos = value; }
+
+    /**
+     * <p>The list of workflow type information.</p>
+     */
+    inline void SetTypeInfos(Aws::Vector<WorkflowTypeInfo>&& value) { m_typeInfos = std::move(value); }
+
+    /**
+     * <p>The list of workflow type information.</p>
+     */
+    inline ListWorkflowTypesResult& WithTypeInfos(const Aws::Vector<WorkflowTypeInfo>& value) { SetTypeInfos(value); return *this;}
+
+    /**
+     * <p>The list of workflow type information.</p>
+     */
+    inline ListWorkflowTypesResult& WithTypeInfos(Aws::Vector<WorkflowTypeInfo>&& value) { SetTypeInfos(std::move(value)); return *this;}
+
+    /**
+     * <p>The list of workflow type information.</p>
+     */
+    inline ListWorkflowTypesResult& AddTypeInfos(const WorkflowTypeInfo& value) { m_typeInfos.push_back(value); return *this; }
+
+    /**
+     * <p>The list of workflow type information.</p>
+     */
+    inline ListWorkflowTypesResult& AddTypeInfos(WorkflowTypeInfo&& value) { m_typeInfos.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline const Aws::String& GetNextPageToken() const{ return m_nextPageToken; }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline void SetNextPageToken(const Aws::String& value) { m_nextPageToken = value; }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline void SetNextPageToken(Aws::String&& value) { m_nextPageToken = std::move(value); }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline void SetNextPageToken(const char* value) { m_nextPageToken.assign(value); }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline ListWorkflowTypesResult& WithNextPageToken(const Aws::String& value) { SetNextPageToken(value); return *this;}
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline ListWorkflowTypesResult& WithNextPageToken(Aws::String&& value) { SetNextPageToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline ListWorkflowTypesResult& WithNextPageToken(const char* value) { SetNextPageToken(value); return *this;}
+
+  private:
+
+    Aws::Vector<WorkflowTypeInfo> m_typeInfos;
+
+    Aws::String m_nextPageToken;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/MarkerRecordedEventAttributes.h

@@ -0,0 +1,169 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   * <p>Provides the details of the <code>MarkerRecorded</code> event.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/MarkerRecordedEventAttributes">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API MarkerRecordedEventAttributes
+  {
+  public:
+    MarkerRecordedEventAttributes();
+    MarkerRecordedEventAttributes(Aws::Utils::Json::JsonView jsonValue);
+    MarkerRecordedEventAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the marker.</p>
+     */
+    inline const Aws::String& GetMarkerName() const{ return m_markerName; }
+
+    /**
+     * <p>The name of the marker.</p>
+     */
+    inline bool MarkerNameHasBeenSet() const { return m_markerNameHasBeenSet; }
+
+    /**
+     * <p>The name of the marker.</p>
+     */
+    inline void SetMarkerName(const Aws::String& value) { m_markerNameHasBeenSet = true; m_markerName = value; }
+
+    /**
+     * <p>The name of the marker.</p>
+     */
+    inline void SetMarkerName(Aws::String&& value) { m_markerNameHasBeenSet = true; m_markerName = std::move(value); }
+
+    /**
+     * <p>The name of the marker.</p>
+     */
+    inline void SetMarkerName(const char* value) { m_markerNameHasBeenSet = true; m_markerName.assign(value); }
+
+    /**
+     * <p>The name of the marker.</p>
+     */
+    inline MarkerRecordedEventAttributes& WithMarkerName(const Aws::String& value) { SetMarkerName(value); return *this;}
+
+    /**
+     * <p>The name of the marker.</p>
+     */
+    inline MarkerRecordedEventAttributes& WithMarkerName(Aws::String&& value) { SetMarkerName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the marker.</p>
+     */
+    inline MarkerRecordedEventAttributes& WithMarkerName(const char* value) { SetMarkerName(value); return *this;}
+
+
+    /**
+     * <p>The details of the marker.</p>
+     */
+    inline const Aws::String& GetDetails() const{ return m_details; }
+
+    /**
+     * <p>The details of the marker.</p>
+     */
+    inline bool DetailsHasBeenSet() const { return m_detailsHasBeenSet; }
+
+    /**
+     * <p>The details of the marker.</p>
+     */
+    inline void SetDetails(const Aws::String& value) { m_detailsHasBeenSet = true; m_details = value; }
+
+    /**
+     * <p>The details of the marker.</p>
+     */
+    inline void SetDetails(Aws::String&& value) { m_detailsHasBeenSet = true; m_details = std::move(value); }
+
+    /**
+     * <p>The details of the marker.</p>
+     */
+    inline void SetDetails(const char* value) { m_detailsHasBeenSet = true; m_details.assign(value); }
+
+    /**
+     * <p>The details of the marker.</p>
+     */
+    inline MarkerRecordedEventAttributes& WithDetails(const Aws::String& value) { SetDetails(value); return *this;}
+
+    /**
+     * <p>The details of the marker.</p>
+     */
+    inline MarkerRecordedEventAttributes& WithDetails(Aws::String&& value) { SetDetails(std::move(value)); return *this;}
+
+    /**
+     * <p>The details of the marker.</p>
+     */
+    inline MarkerRecordedEventAttributes& WithDetails(const char* value) { SetDetails(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>RecordMarker</code> decision that
+     * requested this marker. This information can be useful for diagnosing problems by
+     * tracing back the chain of events leading up to this event.</p>
+     */
+    inline long long GetDecisionTaskCompletedEventId() const{ return m_decisionTaskCompletedEventId; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>RecordMarker</code> decision that
+     * requested this marker. This information can be useful for diagnosing problems by
+     * tracing back the chain of events leading up to this event.</p>
+     */
+    inline bool DecisionTaskCompletedEventIdHasBeenSet() const { return m_decisionTaskCompletedEventIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>RecordMarker</code> decision that
+     * requested this marker. This information can be useful for diagnosing problems by
+     * tracing back the chain of events leading up to this event.</p>
+     */
+    inline void SetDecisionTaskCompletedEventId(long long value) { m_decisionTaskCompletedEventIdHasBeenSet = true; m_decisionTaskCompletedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskCompleted</code> event corresponding to the
+     * decision task that resulted in the <code>RecordMarker</code> decision that
+     * requested this marker. This information can be useful for diagnosing problems by
+     * tracing back the chain of events leading up to this event.</p>
+     */
+    inline MarkerRecordedEventAttributes& WithDecisionTaskCompletedEventId(long long value) { SetDecisionTaskCompletedEventId(value); return *this;}
+
+  private:
+
+    Aws::String m_markerName;
+    bool m_markerNameHasBeenSet;
+
+    Aws::String m_details;
+    bool m_detailsHasBeenSet;
+
+    long long m_decisionTaskCompletedEventId;
+    bool m_decisionTaskCompletedEventIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/PollForActivityTaskRequest.h

@@ -0,0 +1,218 @@
+/**
+ * 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/SWFRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/TaskList.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SWF_API PollForActivityTaskRequest : public SWFRequest
+  {
+  public:
+    PollForActivityTaskRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "PollForActivityTask"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the domain that contains the task lists being polled.</p>
+     */
+    inline const Aws::String& GetDomain() const{ return m_domain; }
+
+    /**
+     * <p>The name of the domain that contains the task lists being polled.</p>
+     */
+    inline bool DomainHasBeenSet() const { return m_domainHasBeenSet; }
+
+    /**
+     * <p>The name of the domain that contains the task lists being polled.</p>
+     */
+    inline void SetDomain(const Aws::String& value) { m_domainHasBeenSet = true; m_domain = value; }
+
+    /**
+     * <p>The name of the domain that contains the task lists being polled.</p>
+     */
+    inline void SetDomain(Aws::String&& value) { m_domainHasBeenSet = true; m_domain = std::move(value); }
+
+    /**
+     * <p>The name of the domain that contains the task lists being polled.</p>
+     */
+    inline void SetDomain(const char* value) { m_domainHasBeenSet = true; m_domain.assign(value); }
+
+    /**
+     * <p>The name of the domain that contains the task lists being polled.</p>
+     */
+    inline PollForActivityTaskRequest& WithDomain(const Aws::String& value) { SetDomain(value); return *this;}
+
+    /**
+     * <p>The name of the domain that contains the task lists being polled.</p>
+     */
+    inline PollForActivityTaskRequest& WithDomain(Aws::String&& value) { SetDomain(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the domain that contains the task lists being polled.</p>
+     */
+    inline PollForActivityTaskRequest& WithDomain(const char* value) { SetDomain(value); return *this;}
+
+
+    /**
+     * <p>Specifies the task list to poll for activity tasks.</p> <p>The specified
+     * string must not start or end with whitespace. It must not contain a
+     * <code>:</code> (colon), <code>/</code> (slash), <code>|</code> (vertical bar),
+     * or any control characters (<code>\u0000-\u001f</code> |
+     * <code>\u007f-\u009f</code>). Also, it must not <i>be</i> the literal string
+     * <code>arn</code>.</p>
+     */
+    inline const TaskList& GetTaskList() const{ return m_taskList; }
+
+    /**
+     * <p>Specifies the task list to poll for activity tasks.</p> <p>The specified
+     * string must not start or end with whitespace. It must not contain a
+     * <code>:</code> (colon), <code>/</code> (slash), <code>|</code> (vertical bar),
+     * or any control characters (<code>\u0000-\u001f</code> |
+     * <code>\u007f-\u009f</code>). Also, it must not <i>be</i> the literal string
+     * <code>arn</code>.</p>
+     */
+    inline bool TaskListHasBeenSet() const { return m_taskListHasBeenSet; }
+
+    /**
+     * <p>Specifies the task list to poll for activity tasks.</p> <p>The specified
+     * string must not start or end with whitespace. It must not contain a
+     * <code>:</code> (colon), <code>/</code> (slash), <code>|</code> (vertical bar),
+     * or any control characters (<code>\u0000-\u001f</code> |
+     * <code>\u007f-\u009f</code>). Also, it must not <i>be</i> the literal string
+     * <code>arn</code>.</p>
+     */
+    inline void SetTaskList(const TaskList& value) { m_taskListHasBeenSet = true; m_taskList = value; }
+
+    /**
+     * <p>Specifies the task list to poll for activity tasks.</p> <p>The specified
+     * string must not start or end with whitespace. It must not contain a
+     * <code>:</code> (colon), <code>/</code> (slash), <code>|</code> (vertical bar),
+     * or any control characters (<code>\u0000-\u001f</code> |
+     * <code>\u007f-\u009f</code>). Also, it must not <i>be</i> the literal string
+     * <code>arn</code>.</p>
+     */
+    inline void SetTaskList(TaskList&& value) { m_taskListHasBeenSet = true; m_taskList = std::move(value); }
+
+    /**
+     * <p>Specifies the task list to poll for activity tasks.</p> <p>The specified
+     * string must not start or end with whitespace. It must not contain a
+     * <code>:</code> (colon), <code>/</code> (slash), <code>|</code> (vertical bar),
+     * or any control characters (<code>\u0000-\u001f</code> |
+     * <code>\u007f-\u009f</code>). Also, it must not <i>be</i> the literal string
+     * <code>arn</code>.</p>
+     */
+    inline PollForActivityTaskRequest& WithTaskList(const TaskList& value) { SetTaskList(value); return *this;}
+
+    /**
+     * <p>Specifies the task list to poll for activity tasks.</p> <p>The specified
+     * string must not start or end with whitespace. It must not contain a
+     * <code>:</code> (colon), <code>/</code> (slash), <code>|</code> (vertical bar),
+     * or any control characters (<code>\u0000-\u001f</code> |
+     * <code>\u007f-\u009f</code>). Also, it must not <i>be</i> the literal string
+     * <code>arn</code>.</p>
+     */
+    inline PollForActivityTaskRequest& WithTaskList(TaskList&& value) { SetTaskList(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Identity of the worker making the request, recorded in the
+     * <code>ActivityTaskStarted</code> event in the workflow history. This enables
+     * diagnostic tracing when problems arise. The form of this identity is user
+     * defined.</p>
+     */
+    inline const Aws::String& GetIdentity() const{ return m_identity; }
+
+    /**
+     * <p>Identity of the worker making the request, recorded in the
+     * <code>ActivityTaskStarted</code> event in the workflow history. This enables
+     * diagnostic tracing when problems arise. The form of this identity is user
+     * defined.</p>
+     */
+    inline bool IdentityHasBeenSet() const { return m_identityHasBeenSet; }
+
+    /**
+     * <p>Identity of the worker making the request, recorded in the
+     * <code>ActivityTaskStarted</code> event in the workflow history. This enables
+     * diagnostic tracing when problems arise. The form of this identity is user
+     * defined.</p>
+     */
+    inline void SetIdentity(const Aws::String& value) { m_identityHasBeenSet = true; m_identity = value; }
+
+    /**
+     * <p>Identity of the worker making the request, recorded in the
+     * <code>ActivityTaskStarted</code> event in the workflow history. This enables
+     * diagnostic tracing when problems arise. The form of this identity is user
+     * defined.</p>
+     */
+    inline void SetIdentity(Aws::String&& value) { m_identityHasBeenSet = true; m_identity = std::move(value); }
+
+    /**
+     * <p>Identity of the worker making the request, recorded in the
+     * <code>ActivityTaskStarted</code> event in the workflow history. This enables
+     * diagnostic tracing when problems arise. The form of this identity is user
+     * defined.</p>
+     */
+    inline void SetIdentity(const char* value) { m_identityHasBeenSet = true; m_identity.assign(value); }
+
+    /**
+     * <p>Identity of the worker making the request, recorded in the
+     * <code>ActivityTaskStarted</code> event in the workflow history. This enables
+     * diagnostic tracing when problems arise. The form of this identity is user
+     * defined.</p>
+     */
+    inline PollForActivityTaskRequest& WithIdentity(const Aws::String& value) { SetIdentity(value); return *this;}
+
+    /**
+     * <p>Identity of the worker making the request, recorded in the
+     * <code>ActivityTaskStarted</code> event in the workflow history. This enables
+     * diagnostic tracing when problems arise. The form of this identity is user
+     * defined.</p>
+     */
+    inline PollForActivityTaskRequest& WithIdentity(Aws::String&& value) { SetIdentity(std::move(value)); return *this;}
+
+    /**
+     * <p>Identity of the worker making the request, recorded in the
+     * <code>ActivityTaskStarted</code> event in the workflow history. This enables
+     * diagnostic tracing when problems arise. The form of this identity is user
+     * defined.</p>
+     */
+    inline PollForActivityTaskRequest& WithIdentity(const char* value) { SetIdentity(value); return *this;}
+
+  private:
+
+    Aws::String m_domain;
+    bool m_domainHasBeenSet;
+
+    TaskList m_taskList;
+    bool m_taskListHasBeenSet;
+
+    Aws::String m_identity;
+    bool m_identityHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/PollForActivityTaskResult.h

@@ -0,0 +1,265 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/WorkflowExecution.h>
+#include <aws/swf/model/ActivityType.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+  /**
+   * <p>Unit of work sent to an activity worker.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ActivityTask">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API PollForActivityTaskResult
+  {
+  public:
+    PollForActivityTaskResult();
+    PollForActivityTaskResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    PollForActivityTaskResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The opaque string used as a handle on the task. This token is used by workers
+     * to communicate progress and response information back to the system about the
+     * task.</p>
+     */
+    inline const Aws::String& GetTaskToken() const{ return m_taskToken; }
+
+    /**
+     * <p>The opaque string used as a handle on the task. This token is used by workers
+     * to communicate progress and response information back to the system about the
+     * task.</p>
+     */
+    inline void SetTaskToken(const Aws::String& value) { m_taskToken = value; }
+
+    /**
+     * <p>The opaque string used as a handle on the task. This token is used by workers
+     * to communicate progress and response information back to the system about the
+     * task.</p>
+     */
+    inline void SetTaskToken(Aws::String&& value) { m_taskToken = std::move(value); }
+
+    /**
+     * <p>The opaque string used as a handle on the task. This token is used by workers
+     * to communicate progress and response information back to the system about the
+     * task.</p>
+     */
+    inline void SetTaskToken(const char* value) { m_taskToken.assign(value); }
+
+    /**
+     * <p>The opaque string used as a handle on the task. This token is used by workers
+     * to communicate progress and response information back to the system about the
+     * task.</p>
+     */
+    inline PollForActivityTaskResult& WithTaskToken(const Aws::String& value) { SetTaskToken(value); return *this;}
+
+    /**
+     * <p>The opaque string used as a handle on the task. This token is used by workers
+     * to communicate progress and response information back to the system about the
+     * task.</p>
+     */
+    inline PollForActivityTaskResult& WithTaskToken(Aws::String&& value) { SetTaskToken(std::move(value)); return *this;}
+
+    /**
+     * <p>The opaque string used as a handle on the task. This token is used by workers
+     * to communicate progress and response information back to the system about the
+     * task.</p>
+     */
+    inline PollForActivityTaskResult& WithTaskToken(const char* value) { SetTaskToken(value); return *this;}
+
+
+    /**
+     * <p>The unique ID of the task.</p>
+     */
+    inline const Aws::String& GetActivityId() const{ return m_activityId; }
+
+    /**
+     * <p>The unique ID of the task.</p>
+     */
+    inline void SetActivityId(const Aws::String& value) { m_activityId = value; }
+
+    /**
+     * <p>The unique ID of the task.</p>
+     */
+    inline void SetActivityId(Aws::String&& value) { m_activityId = std::move(value); }
+
+    /**
+     * <p>The unique ID of the task.</p>
+     */
+    inline void SetActivityId(const char* value) { m_activityId.assign(value); }
+
+    /**
+     * <p>The unique ID of the task.</p>
+     */
+    inline PollForActivityTaskResult& WithActivityId(const Aws::String& value) { SetActivityId(value); return *this;}
+
+    /**
+     * <p>The unique ID of the task.</p>
+     */
+    inline PollForActivityTaskResult& WithActivityId(Aws::String&& value) { SetActivityId(std::move(value)); return *this;}
+
+    /**
+     * <p>The unique ID of the task.</p>
+     */
+    inline PollForActivityTaskResult& WithActivityId(const char* value) { SetActivityId(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event recorded in the
+     * history.</p>
+     */
+    inline long long GetStartedEventId() const{ return m_startedEventId; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event recorded in the
+     * history.</p>
+     */
+    inline void SetStartedEventId(long long value) { m_startedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>ActivityTaskStarted</code> event recorded in the
+     * history.</p>
+     */
+    inline PollForActivityTaskResult& WithStartedEventId(long long value) { SetStartedEventId(value); return *this;}
+
+
+    /**
+     * <p>The workflow execution that started this activity task.</p>
+     */
+    inline const WorkflowExecution& GetWorkflowExecution() const{ return m_workflowExecution; }
+
+    /**
+     * <p>The workflow execution that started this activity task.</p>
+     */
+    inline void SetWorkflowExecution(const WorkflowExecution& value) { m_workflowExecution = value; }
+
+    /**
+     * <p>The workflow execution that started this activity task.</p>
+     */
+    inline void SetWorkflowExecution(WorkflowExecution&& value) { m_workflowExecution = std::move(value); }
+
+    /**
+     * <p>The workflow execution that started this activity task.</p>
+     */
+    inline PollForActivityTaskResult& WithWorkflowExecution(const WorkflowExecution& value) { SetWorkflowExecution(value); return *this;}
+
+    /**
+     * <p>The workflow execution that started this activity task.</p>
+     */
+    inline PollForActivityTaskResult& WithWorkflowExecution(WorkflowExecution&& value) { SetWorkflowExecution(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The type of this activity task.</p>
+     */
+    inline const ActivityType& GetActivityType() const{ return m_activityType; }
+
+    /**
+     * <p>The type of this activity task.</p>
+     */
+    inline void SetActivityType(const ActivityType& value) { m_activityType = value; }
+
+    /**
+     * <p>The type of this activity task.</p>
+     */
+    inline void SetActivityType(ActivityType&& value) { m_activityType = std::move(value); }
+
+    /**
+     * <p>The type of this activity task.</p>
+     */
+    inline PollForActivityTaskResult& WithActivityType(const ActivityType& value) { SetActivityType(value); return *this;}
+
+    /**
+     * <p>The type of this activity task.</p>
+     */
+    inline PollForActivityTaskResult& WithActivityType(ActivityType&& value) { SetActivityType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The inputs provided when the activity task was scheduled. The form of the
+     * input is user defined and should be meaningful to the activity
+     * implementation.</p>
+     */
+    inline const Aws::String& GetInput() const{ return m_input; }
+
+    /**
+     * <p>The inputs provided when the activity task was scheduled. The form of the
+     * input is user defined and should be meaningful to the activity
+     * implementation.</p>
+     */
+    inline void SetInput(const Aws::String& value) { m_input = value; }
+
+    /**
+     * <p>The inputs provided when the activity task was scheduled. The form of the
+     * input is user defined and should be meaningful to the activity
+     * implementation.</p>
+     */
+    inline void SetInput(Aws::String&& value) { m_input = std::move(value); }
+
+    /**
+     * <p>The inputs provided when the activity task was scheduled. The form of the
+     * input is user defined and should be meaningful to the activity
+     * implementation.</p>
+     */
+    inline void SetInput(const char* value) { m_input.assign(value); }
+
+    /**
+     * <p>The inputs provided when the activity task was scheduled. The form of the
+     * input is user defined and should be meaningful to the activity
+     * implementation.</p>
+     */
+    inline PollForActivityTaskResult& WithInput(const Aws::String& value) { SetInput(value); return *this;}
+
+    /**
+     * <p>The inputs provided when the activity task was scheduled. The form of the
+     * input is user defined and should be meaningful to the activity
+     * implementation.</p>
+     */
+    inline PollForActivityTaskResult& WithInput(Aws::String&& value) { SetInput(std::move(value)); return *this;}
+
+    /**
+     * <p>The inputs provided when the activity task was scheduled. The form of the
+     * input is user defined and should be meaningful to the activity
+     * implementation.</p>
+     */
+    inline PollForActivityTaskResult& WithInput(const char* value) { SetInput(value); return *this;}
+
+  private:
+
+    Aws::String m_taskToken;
+
+    Aws::String m_activityId;
+
+    long long m_startedEventId;
+
+    WorkflowExecution m_workflowExecution;
+
+    ActivityType m_activityType;
+
+    Aws::String m_input;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/PollForDecisionTaskRequest.h

@@ -0,0 +1,418 @@
+/**
+ * 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/SWFRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/TaskList.h>
+#include <utility>
+
+namespace Aws
+{
+namespace SWF
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_SWF_API PollForDecisionTaskRequest : public SWFRequest
+  {
+  public:
+    PollForDecisionTaskRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "PollForDecisionTask"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the domain containing the task lists to poll.</p>
+     */
+    inline const Aws::String& GetDomain() const{ return m_domain; }
+
+    /**
+     * <p>The name of the domain containing the task lists to poll.</p>
+     */
+    inline bool DomainHasBeenSet() const { return m_domainHasBeenSet; }
+
+    /**
+     * <p>The name of the domain containing the task lists to poll.</p>
+     */
+    inline void SetDomain(const Aws::String& value) { m_domainHasBeenSet = true; m_domain = value; }
+
+    /**
+     * <p>The name of the domain containing the task lists to poll.</p>
+     */
+    inline void SetDomain(Aws::String&& value) { m_domainHasBeenSet = true; m_domain = std::move(value); }
+
+    /**
+     * <p>The name of the domain containing the task lists to poll.</p>
+     */
+    inline void SetDomain(const char* value) { m_domainHasBeenSet = true; m_domain.assign(value); }
+
+    /**
+     * <p>The name of the domain containing the task lists to poll.</p>
+     */
+    inline PollForDecisionTaskRequest& WithDomain(const Aws::String& value) { SetDomain(value); return *this;}
+
+    /**
+     * <p>The name of the domain containing the task lists to poll.</p>
+     */
+    inline PollForDecisionTaskRequest& WithDomain(Aws::String&& value) { SetDomain(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the domain containing the task lists to poll.</p>
+     */
+    inline PollForDecisionTaskRequest& WithDomain(const char* value) { SetDomain(value); return *this;}
+
+
+    /**
+     * <p>Specifies the task list to poll for decision tasks.</p> <p>The specified
+     * string must not start or end with whitespace. It must not contain a
+     * <code>:</code> (colon), <code>/</code> (slash), <code>|</code> (vertical bar),
+     * or any control characters (<code>\u0000-\u001f</code> |
+     * <code>\u007f-\u009f</code>). Also, it must not <i>be</i> the literal string
+     * <code>arn</code>.</p>
+     */
+    inline const TaskList& GetTaskList() const{ return m_taskList; }
+
+    /**
+     * <p>Specifies the task list to poll for decision tasks.</p> <p>The specified
+     * string must not start or end with whitespace. It must not contain a
+     * <code>:</code> (colon), <code>/</code> (slash), <code>|</code> (vertical bar),
+     * or any control characters (<code>\u0000-\u001f</code> |
+     * <code>\u007f-\u009f</code>). Also, it must not <i>be</i> the literal string
+     * <code>arn</code>.</p>
+     */
+    inline bool TaskListHasBeenSet() const { return m_taskListHasBeenSet; }
+
+    /**
+     * <p>Specifies the task list to poll for decision tasks.</p> <p>The specified
+     * string must not start or end with whitespace. It must not contain a
+     * <code>:</code> (colon), <code>/</code> (slash), <code>|</code> (vertical bar),
+     * or any control characters (<code>\u0000-\u001f</code> |
+     * <code>\u007f-\u009f</code>). Also, it must not <i>be</i> the literal string
+     * <code>arn</code>.</p>
+     */
+    inline void SetTaskList(const TaskList& value) { m_taskListHasBeenSet = true; m_taskList = value; }
+
+    /**
+     * <p>Specifies the task list to poll for decision tasks.</p> <p>The specified
+     * string must not start or end with whitespace. It must not contain a
+     * <code>:</code> (colon), <code>/</code> (slash), <code>|</code> (vertical bar),
+     * or any control characters (<code>\u0000-\u001f</code> |
+     * <code>\u007f-\u009f</code>). Also, it must not <i>be</i> the literal string
+     * <code>arn</code>.</p>
+     */
+    inline void SetTaskList(TaskList&& value) { m_taskListHasBeenSet = true; m_taskList = std::move(value); }
+
+    /**
+     * <p>Specifies the task list to poll for decision tasks.</p> <p>The specified
+     * string must not start or end with whitespace. It must not contain a
+     * <code>:</code> (colon), <code>/</code> (slash), <code>|</code> (vertical bar),
+     * or any control characters (<code>\u0000-\u001f</code> |
+     * <code>\u007f-\u009f</code>). Also, it must not <i>be</i> the literal string
+     * <code>arn</code>.</p>
+     */
+    inline PollForDecisionTaskRequest& WithTaskList(const TaskList& value) { SetTaskList(value); return *this;}
+
+    /**
+     * <p>Specifies the task list to poll for decision tasks.</p> <p>The specified
+     * string must not start or end with whitespace. It must not contain a
+     * <code>:</code> (colon), <code>/</code> (slash), <code>|</code> (vertical bar),
+     * or any control characters (<code>\u0000-\u001f</code> |
+     * <code>\u007f-\u009f</code>). Also, it must not <i>be</i> the literal string
+     * <code>arn</code>.</p>
+     */
+    inline PollForDecisionTaskRequest& WithTaskList(TaskList&& value) { SetTaskList(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Identity of the decider making the request, which is recorded in the
+     * DecisionTaskStarted event in the workflow history. This enables diagnostic
+     * tracing when problems arise. The form of this identity is user defined.</p>
+     */
+    inline const Aws::String& GetIdentity() const{ return m_identity; }
+
+    /**
+     * <p>Identity of the decider making the request, which is recorded in the
+     * DecisionTaskStarted event in the workflow history. This enables diagnostic
+     * tracing when problems arise. The form of this identity is user defined.</p>
+     */
+    inline bool IdentityHasBeenSet() const { return m_identityHasBeenSet; }
+
+    /**
+     * <p>Identity of the decider making the request, which is recorded in the
+     * DecisionTaskStarted event in the workflow history. This enables diagnostic
+     * tracing when problems arise. The form of this identity is user defined.</p>
+     */
+    inline void SetIdentity(const Aws::String& value) { m_identityHasBeenSet = true; m_identity = value; }
+
+    /**
+     * <p>Identity of the decider making the request, which is recorded in the
+     * DecisionTaskStarted event in the workflow history. This enables diagnostic
+     * tracing when problems arise. The form of this identity is user defined.</p>
+     */
+    inline void SetIdentity(Aws::String&& value) { m_identityHasBeenSet = true; m_identity = std::move(value); }
+
+    /**
+     * <p>Identity of the decider making the request, which is recorded in the
+     * DecisionTaskStarted event in the workflow history. This enables diagnostic
+     * tracing when problems arise. The form of this identity is user defined.</p>
+     */
+    inline void SetIdentity(const char* value) { m_identityHasBeenSet = true; m_identity.assign(value); }
+
+    /**
+     * <p>Identity of the decider making the request, which is recorded in the
+     * DecisionTaskStarted event in the workflow history. This enables diagnostic
+     * tracing when problems arise. The form of this identity is user defined.</p>
+     */
+    inline PollForDecisionTaskRequest& WithIdentity(const Aws::String& value) { SetIdentity(value); return *this;}
+
+    /**
+     * <p>Identity of the decider making the request, which is recorded in the
+     * DecisionTaskStarted event in the workflow history. This enables diagnostic
+     * tracing when problems arise. The form of this identity is user defined.</p>
+     */
+    inline PollForDecisionTaskRequest& WithIdentity(Aws::String&& value) { SetIdentity(std::move(value)); return *this;}
+
+    /**
+     * <p>Identity of the decider making the request, which is recorded in the
+     * DecisionTaskStarted event in the workflow history. This enables diagnostic
+     * tracing when problems arise. The form of this identity is user defined.</p>
+     */
+    inline PollForDecisionTaskRequest& WithIdentity(const char* value) { SetIdentity(value); return *this;}
+
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>  <p>The <code>nextPageToken</code>
+     * returned by this action cannot be used with <a>GetWorkflowExecutionHistory</a>
+     * to get the next page. You must call <a>PollForDecisionTask</a> again (with the
+     * <code>nextPageToken</code>) to retrieve the next page of history records.
+     * Calling <a>PollForDecisionTask</a> with a <code>nextPageToken</code> doesn't
+     * return a new decision task.</p> 
+     */
+    inline const Aws::String& GetNextPageToken() const{ return m_nextPageToken; }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>  <p>The <code>nextPageToken</code>
+     * returned by this action cannot be used with <a>GetWorkflowExecutionHistory</a>
+     * to get the next page. You must call <a>PollForDecisionTask</a> again (with the
+     * <code>nextPageToken</code>) to retrieve the next page of history records.
+     * Calling <a>PollForDecisionTask</a> with a <code>nextPageToken</code> doesn't
+     * return a new decision task.</p> 
+     */
+    inline bool NextPageTokenHasBeenSet() const { return m_nextPageTokenHasBeenSet; }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>  <p>The <code>nextPageToken</code>
+     * returned by this action cannot be used with <a>GetWorkflowExecutionHistory</a>
+     * to get the next page. You must call <a>PollForDecisionTask</a> again (with the
+     * <code>nextPageToken</code>) to retrieve the next page of history records.
+     * Calling <a>PollForDecisionTask</a> with a <code>nextPageToken</code> doesn't
+     * return a new decision task.</p> 
+     */
+    inline void SetNextPageToken(const Aws::String& value) { m_nextPageTokenHasBeenSet = true; m_nextPageToken = value; }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>  <p>The <code>nextPageToken</code>
+     * returned by this action cannot be used with <a>GetWorkflowExecutionHistory</a>
+     * to get the next page. You must call <a>PollForDecisionTask</a> again (with the
+     * <code>nextPageToken</code>) to retrieve the next page of history records.
+     * Calling <a>PollForDecisionTask</a> with a <code>nextPageToken</code> doesn't
+     * return a new decision task.</p> 
+     */
+    inline void SetNextPageToken(Aws::String&& value) { m_nextPageTokenHasBeenSet = true; m_nextPageToken = std::move(value); }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>  <p>The <code>nextPageToken</code>
+     * returned by this action cannot be used with <a>GetWorkflowExecutionHistory</a>
+     * to get the next page. You must call <a>PollForDecisionTask</a> again (with the
+     * <code>nextPageToken</code>) to retrieve the next page of history records.
+     * Calling <a>PollForDecisionTask</a> with a <code>nextPageToken</code> doesn't
+     * return a new decision task.</p> 
+     */
+    inline void SetNextPageToken(const char* value) { m_nextPageTokenHasBeenSet = true; m_nextPageToken.assign(value); }
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>  <p>The <code>nextPageToken</code>
+     * returned by this action cannot be used with <a>GetWorkflowExecutionHistory</a>
+     * to get the next page. You must call <a>PollForDecisionTask</a> again (with the
+     * <code>nextPageToken</code>) to retrieve the next page of history records.
+     * Calling <a>PollForDecisionTask</a> with a <code>nextPageToken</code> doesn't
+     * return a new decision task.</p> 
+     */
+    inline PollForDecisionTaskRequest& WithNextPageToken(const Aws::String& value) { SetNextPageToken(value); return *this;}
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>  <p>The <code>nextPageToken</code>
+     * returned by this action cannot be used with <a>GetWorkflowExecutionHistory</a>
+     * to get the next page. You must call <a>PollForDecisionTask</a> again (with the
+     * <code>nextPageToken</code>) to retrieve the next page of history records.
+     * Calling <a>PollForDecisionTask</a> with a <code>nextPageToken</code> doesn't
+     * return a new decision task.</p> 
+     */
+    inline PollForDecisionTaskRequest& WithNextPageToken(Aws::String&& value) { SetNextPageToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If <code>NextPageToken</code> is returned there are more results available.
+     * The value of <code>NextPageToken</code> is a unique pagination token for each
+     * page. Make the call again using the returned token to retrieve the next page.
+     * Keep all other arguments unchanged. Each pagination token expires after 60
+     * seconds. Using an expired pagination token will return a <code>400</code> error:
+     * "<code>Specified token has exceeded its maximum lifetime</code>". </p> <p>The
+     * configured <code>maximumPageSize</code> determines how many results can be
+     * returned in a single call. </p>  <p>The <code>nextPageToken</code>
+     * returned by this action cannot be used with <a>GetWorkflowExecutionHistory</a>
+     * to get the next page. You must call <a>PollForDecisionTask</a> again (with the
+     * <code>nextPageToken</code>) to retrieve the next page of history records.
+     * Calling <a>PollForDecisionTask</a> with a <code>nextPageToken</code> doesn't
+     * return a new decision task.</p> 
+     */
+    inline PollForDecisionTaskRequest& WithNextPageToken(const char* value) { SetNextPageToken(value); return *this;}
+
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p> <p>This is
+     * an upper limit only; the actual number of results returned per call may be fewer
+     * than the specified maximum.</p>
+     */
+    inline int GetMaximumPageSize() const{ return m_maximumPageSize; }
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p> <p>This is
+     * an upper limit only; the actual number of results returned per call may be fewer
+     * than the specified maximum.</p>
+     */
+    inline bool MaximumPageSizeHasBeenSet() const { return m_maximumPageSizeHasBeenSet; }
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p> <p>This is
+     * an upper limit only; the actual number of results returned per call may be fewer
+     * than the specified maximum.</p>
+     */
+    inline void SetMaximumPageSize(int value) { m_maximumPageSizeHasBeenSet = true; m_maximumPageSize = value; }
+
+    /**
+     * <p>The maximum number of results that are returned per call. Use
+     * <code>nextPageToken</code> to obtain further pages of results. </p> <p>This is
+     * an upper limit only; the actual number of results returned per call may be fewer
+     * than the specified maximum.</p>
+     */
+    inline PollForDecisionTaskRequest& WithMaximumPageSize(int value) { SetMaximumPageSize(value); return *this;}
+
+
+    /**
+     * <p>When set to <code>true</code>, returns the events in reverse order. By
+     * default the results are returned in ascending order of the
+     * <code>eventTimestamp</code> of the events.</p>
+     */
+    inline bool GetReverseOrder() const{ return m_reverseOrder; }
+
+    /**
+     * <p>When set to <code>true</code>, returns the events in reverse order. By
+     * default the results are returned in ascending order of the
+     * <code>eventTimestamp</code> of the events.</p>
+     */
+    inline bool ReverseOrderHasBeenSet() const { return m_reverseOrderHasBeenSet; }
+
+    /**
+     * <p>When set to <code>true</code>, returns the events in reverse order. By
+     * default the results are returned in ascending order of the
+     * <code>eventTimestamp</code> of the events.</p>
+     */
+    inline void SetReverseOrder(bool value) { m_reverseOrderHasBeenSet = true; m_reverseOrder = value; }
+
+    /**
+     * <p>When set to <code>true</code>, returns the events in reverse order. By
+     * default the results are returned in ascending order of the
+     * <code>eventTimestamp</code> of the events.</p>
+     */
+    inline PollForDecisionTaskRequest& WithReverseOrder(bool value) { SetReverseOrder(value); return *this;}
+
+  private:
+
+    Aws::String m_domain;
+    bool m_domainHasBeenSet;
+
+    TaskList m_taskList;
+    bool m_taskListHasBeenSet;
+
+    Aws::String m_identity;
+    bool m_identityHasBeenSet;
+
+    Aws::String m_nextPageToken;
+    bool m_nextPageTokenHasBeenSet;
+
+    int m_maximumPageSize;
+    bool m_maximumPageSizeHasBeenSet;
+
+    bool m_reverseOrder;
+    bool m_reverseOrderHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-swf/include/aws/swf/model/PollForDecisionTaskResult.h

@@ -0,0 +1,321 @@
+/**
+ * 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/core/utils/memory/stl/AWSString.h>
+#include <aws/swf/model/WorkflowExecution.h>
+#include <aws/swf/model/WorkflowType.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/swf/model/HistoryEvent.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace SWF
+{
+namespace Model
+{
+  /**
+   * <p>A structure that represents a decision task. Decision tasks are sent to
+   * deciders in order for them to make decisions.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DecisionTask">AWS
+   * API Reference</a></p>
+   */
+  class AWS_SWF_API PollForDecisionTaskResult
+  {
+  public:
+    PollForDecisionTaskResult();
+    PollForDecisionTaskResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    PollForDecisionTaskResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The opaque string used as a handle on the task. This token is used by workers
+     * to communicate progress and response information back to the system about the
+     * task.</p>
+     */
+    inline const Aws::String& GetTaskToken() const{ return m_taskToken; }
+
+    /**
+     * <p>The opaque string used as a handle on the task. This token is used by workers
+     * to communicate progress and response information back to the system about the
+     * task.</p>
+     */
+    inline void SetTaskToken(const Aws::String& value) { m_taskToken = value; }
+
+    /**
+     * <p>The opaque string used as a handle on the task. This token is used by workers
+     * to communicate progress and response information back to the system about the
+     * task.</p>
+     */
+    inline void SetTaskToken(Aws::String&& value) { m_taskToken = std::move(value); }
+
+    /**
+     * <p>The opaque string used as a handle on the task. This token is used by workers
+     * to communicate progress and response information back to the system about the
+     * task.</p>
+     */
+    inline void SetTaskToken(const char* value) { m_taskToken.assign(value); }
+
+    /**
+     * <p>The opaque string used as a handle on the task. This token is used by workers
+     * to communicate progress and response information back to the system about the
+     * task.</p>
+     */
+    inline PollForDecisionTaskResult& WithTaskToken(const Aws::String& value) { SetTaskToken(value); return *this;}
+
+    /**
+     * <p>The opaque string used as a handle on the task. This token is used by workers
+     * to communicate progress and response information back to the system about the
+     * task.</p>
+     */
+    inline PollForDecisionTaskResult& WithTaskToken(Aws::String&& value) { SetTaskToken(std::move(value)); return *this;}
+
+    /**
+     * <p>The opaque string used as a handle on the task. This token is used by workers
+     * to communicate progress and response information back to the system about the
+     * task.</p>
+     */
+    inline PollForDecisionTaskResult& WithTaskToken(const char* value) { SetTaskToken(value); return *this;}
+
+
+    /**
+     * <p>The ID of the <code>DecisionTaskStarted</code> event recorded in the
+     * history.</p>
+     */
+    inline long long GetStartedEventId() const{ return m_startedEventId; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskStarted</code> event recorded in the
+     * history.</p>
+     */
+    inline void SetStartedEventId(long long value) { m_startedEventId = value; }
+
+    /**
+     * <p>The ID of the <code>DecisionTaskStarted</code> event recorded in the
+     * history.</p>
+     */
+    inline PollForDecisionTaskResult& WithStartedEventId(long long value) { SetStartedEventId(value); return *this;}
+
+
+    /**
+     * <p>The workflow execution for which this decision task was created.</p>
+     */
+    inline const WorkflowExecution& GetWorkflowExecution() const{ return m_workflowExecution; }
+
+    /**
+     * <p>The workflow execution for which this decision task was created.</p>
+     */
+    inline void SetWorkflowExecution(const WorkflowExecution& value) { m_workflowExecution = value; }
+
+    /**
+     * <p>The workflow execution for which this decision task was created.</p>
+     */
+    inline void SetWorkflowExecution(WorkflowExecution&& value) { m_workflowExecution = std::move(value); }
+
+    /**
+     * <p>The workflow execution for which this decision task was created.</p>
+     */
+    inline PollForDecisionTaskResult& WithWorkflowExecution(const WorkflowExecution& value) { SetWorkflowExecution(value); return *this;}
+
+    /**
+     * <p>The workflow execution for which this decision task was created.</p>
+     */
+    inline PollForDecisionTaskResult& WithWorkflowExecution(WorkflowExecution&& value) { SetWorkflowExecution(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The type of the workflow execution for which this decision task was
+     * created.</p>
+     */
+    inline const WorkflowType& GetWorkflowType() const{ return m_workflowType; }
+
+    /**
+     * <p>The type of the workflow execution for which this decision task was
+     * created.</p>
+     */
+    inline void SetWorkflowType(const WorkflowType& value) { m_workflowType = value; }
+
+    /**
+     * <p>The type of the workflow execution for which this decision task was
+     * created.</p>
+     */
+    inline void SetWorkflowType(WorkflowType&& value) { m_workflowType = std::move(value); }
+
+    /**
+     * <p>The type of the workflow execution for which this decision task was
+     * created.</p>
+     */
+    inline PollForDecisionTaskResult& WithWorkflowType(const WorkflowType& value) { SetWorkflowType(value); return *this;}
+
+    /**
+     * <p>The type of the workflow execution for which this decision task was
+     * created.</p>
+     */
+    inline PollForDecisionTaskResult& WithWorkflowType(WorkflowType&& value) { SetWorkflowType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>A paginated list of history events of the workflow execution. The decider
+     * uses this during the processing of the decision task.</p>
+     */
+    inline const Aws::Vector<HistoryEvent>& GetEvents() const{ return m_events; }
+
+    /**
+     * <p>A paginated list of history events of the workflow execution. The decider
+     * uses this during the processing of the decision task.</p>
+     */
+    inline void SetEvents(const Aws::Vector<HistoryEvent>& value) { m_events = value; }
+
+    /**
+     * <p>A paginated list of history events of the workflow execution. The decider
+     * uses this during the processing of the decision task.</p>
+     */
+    inline void SetEvents(Aws::Vector<HistoryEvent>&& value) { m_events = std::move(value); }
+
+    /**
+     * <p>A paginated list of history events of the workflow execution. The decider
+     * uses this during the processing of the decision task.</p>
+     */
+    inline PollForDecisionTaskResult& WithEvents(const Aws::Vector<HistoryEvent>& value) { SetEvents(value); return *this;}
+
+    /**
+     * <p>A paginated list of history events of the workflow execution. The decider
+     * uses this during the processing of the decision task.</p>
+     */
+    inline PollForDecisionTaskResult& WithEvents(Aws::Vector<HistoryEvent>&& value) { SetEvents(std::move(value)); return *this;}
+
+    /**
+     * <p>A paginated list of history events of the workflow execution. The decider
+     * uses this during the processing of the decision task.</p>
+     */
+    inline PollForDecisionTaskResult& AddEvents(const HistoryEvent& value) { m_events.push_back(value); return *this; }
+
+    /**
+     * <p>A paginated list of history events of the workflow execution. The decider
+     * uses this during the processing of the decision task.</p>
+     */
+    inline PollForDecisionTaskResult& AddEvents(HistoryEvent&& value) { m_events.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline const Aws::String& GetNextPageToken() const{ return m_nextPageToken; }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline void SetNextPageToken(const Aws::String& value) { m_nextPageToken = value; }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline void SetNextPageToken(Aws::String&& value) { m_nextPageToken = std::move(value); }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline void SetNextPageToken(const char* value) { m_nextPageToken.assign(value); }
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline PollForDecisionTaskResult& WithNextPageToken(const Aws::String& value) { SetNextPageToken(value); return *this;}
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline PollForDecisionTaskResult& WithNextPageToken(Aws::String&& value) { SetNextPageToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If a <code>NextPageToken</code> was returned by a previous call, there are
+     * more results available. To retrieve the next page of results, make the call
+     * again using the returned token in <code>nextPageToken</code>. Keep all other
+     * arguments unchanged.</p> <p>The configured <code>maximumPageSize</code>
+     * determines how many results can be returned in a single call.</p>
+     */
+    inline PollForDecisionTaskResult& WithNextPageToken(const char* value) { SetNextPageToken(value); return *this;}
+
+
+    /**
+     * <p>The ID of the DecisionTaskStarted event of the previous decision task of this
+     * workflow execution that was processed by the decider. This can be used to
+     * determine the events in the history new since the last decision task received by
+     * the decider.</p>
+     */
+    inline long long GetPreviousStartedEventId() const{ return m_previousStartedEventId; }
+
+    /**
+     * <p>The ID of the DecisionTaskStarted event of the previous decision task of this
+     * workflow execution that was processed by the decider. This can be used to
+     * determine the events in the history new since the last decision task received by
+     * the decider.</p>
+     */
+    inline void SetPreviousStartedEventId(long long value) { m_previousStartedEventId = value; }
+
+    /**
+     * <p>The ID of the DecisionTaskStarted event of the previous decision task of this
+     * workflow execution that was processed by the decider. This can be used to
+     * determine the events in the history new since the last decision task received by
+     * the decider.</p>
+     */
+    inline PollForDecisionTaskResult& WithPreviousStartedEventId(long long value) { SetPreviousStartedEventId(value); return *this;}
+
+  private:
+
+    Aws::String m_taskToken;
+
+    long long m_startedEventId;
+
+    WorkflowExecution m_workflowExecution;
+
+    WorkflowType m_workflowType;
+
+    Aws::Vector<HistoryEvent> m_events;
+
+    Aws::String m_nextPageToken;
+
+    long long m_previousStartedEventId;
+  };
+
+} // namespace Model
+} // namespace SWF
+} // namespace Aws