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

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/CodeStarNotificationsClient.h

@@ -0,0 +1,581 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/codestar-notifications/CodeStarNotificationsErrors.h>
+#include <aws/core/client/AWSError.h>
+#include <aws/core/client/ClientConfiguration.h>
+#include <aws/core/client/AWSClient.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/codestar-notifications/model/CreateNotificationRuleResult.h>
+#include <aws/codestar-notifications/model/DeleteNotificationRuleResult.h>
+#include <aws/codestar-notifications/model/DeleteTargetResult.h>
+#include <aws/codestar-notifications/model/DescribeNotificationRuleResult.h>
+#include <aws/codestar-notifications/model/ListEventTypesResult.h>
+#include <aws/codestar-notifications/model/ListNotificationRulesResult.h>
+#include <aws/codestar-notifications/model/ListTagsForResourceResult.h>
+#include <aws/codestar-notifications/model/ListTargetsResult.h>
+#include <aws/codestar-notifications/model/SubscribeResult.h>
+#include <aws/codestar-notifications/model/TagResourceResult.h>
+#include <aws/codestar-notifications/model/UnsubscribeResult.h>
+#include <aws/codestar-notifications/model/UntagResourceResult.h>
+#include <aws/codestar-notifications/model/UpdateNotificationRuleResult.h>
+#include <aws/core/client/AsyncCallerContext.h>
+#include <aws/core/http/HttpTypes.h>
+#include <future>
+#include <functional>
+
+namespace Aws
+{
+
+namespace Http
+{
+  class HttpClient;
+  class HttpClientFactory;
+} // namespace Http
+
+namespace Utils
+{
+  template< typename R, typename E> class Outcome;
+namespace Threading
+{
+  class Executor;
+} // namespace Threading
+} // namespace Utils
+
+namespace Auth
+{
+  class AWSCredentials;
+  class AWSCredentialsProvider;
+} // namespace Auth
+
+namespace Client
+{
+  class RetryStrategy;
+} // namespace Client
+
+namespace CodeStarNotifications
+{
+
+namespace Model
+{
+        class CreateNotificationRuleRequest;
+        class DeleteNotificationRuleRequest;
+        class DeleteTargetRequest;
+        class DescribeNotificationRuleRequest;
+        class ListEventTypesRequest;
+        class ListNotificationRulesRequest;
+        class ListTagsForResourceRequest;
+        class ListTargetsRequest;
+        class SubscribeRequest;
+        class TagResourceRequest;
+        class UnsubscribeRequest;
+        class UntagResourceRequest;
+        class UpdateNotificationRuleRequest;
+
+        typedef Aws::Utils::Outcome<CreateNotificationRuleResult, CodeStarNotificationsError> CreateNotificationRuleOutcome;
+        typedef Aws::Utils::Outcome<DeleteNotificationRuleResult, CodeStarNotificationsError> DeleteNotificationRuleOutcome;
+        typedef Aws::Utils::Outcome<DeleteTargetResult, CodeStarNotificationsError> DeleteTargetOutcome;
+        typedef Aws::Utils::Outcome<DescribeNotificationRuleResult, CodeStarNotificationsError> DescribeNotificationRuleOutcome;
+        typedef Aws::Utils::Outcome<ListEventTypesResult, CodeStarNotificationsError> ListEventTypesOutcome;
+        typedef Aws::Utils::Outcome<ListNotificationRulesResult, CodeStarNotificationsError> ListNotificationRulesOutcome;
+        typedef Aws::Utils::Outcome<ListTagsForResourceResult, CodeStarNotificationsError> ListTagsForResourceOutcome;
+        typedef Aws::Utils::Outcome<ListTargetsResult, CodeStarNotificationsError> ListTargetsOutcome;
+        typedef Aws::Utils::Outcome<SubscribeResult, CodeStarNotificationsError> SubscribeOutcome;
+        typedef Aws::Utils::Outcome<TagResourceResult, CodeStarNotificationsError> TagResourceOutcome;
+        typedef Aws::Utils::Outcome<UnsubscribeResult, CodeStarNotificationsError> UnsubscribeOutcome;
+        typedef Aws::Utils::Outcome<UntagResourceResult, CodeStarNotificationsError> UntagResourceOutcome;
+        typedef Aws::Utils::Outcome<UpdateNotificationRuleResult, CodeStarNotificationsError> UpdateNotificationRuleOutcome;
+
+        typedef std::future<CreateNotificationRuleOutcome> CreateNotificationRuleOutcomeCallable;
+        typedef std::future<DeleteNotificationRuleOutcome> DeleteNotificationRuleOutcomeCallable;
+        typedef std::future<DeleteTargetOutcome> DeleteTargetOutcomeCallable;
+        typedef std::future<DescribeNotificationRuleOutcome> DescribeNotificationRuleOutcomeCallable;
+        typedef std::future<ListEventTypesOutcome> ListEventTypesOutcomeCallable;
+        typedef std::future<ListNotificationRulesOutcome> ListNotificationRulesOutcomeCallable;
+        typedef std::future<ListTagsForResourceOutcome> ListTagsForResourceOutcomeCallable;
+        typedef std::future<ListTargetsOutcome> ListTargetsOutcomeCallable;
+        typedef std::future<SubscribeOutcome> SubscribeOutcomeCallable;
+        typedef std::future<TagResourceOutcome> TagResourceOutcomeCallable;
+        typedef std::future<UnsubscribeOutcome> UnsubscribeOutcomeCallable;
+        typedef std::future<UntagResourceOutcome> UntagResourceOutcomeCallable;
+        typedef std::future<UpdateNotificationRuleOutcome> UpdateNotificationRuleOutcomeCallable;
+} // namespace Model
+
+  class CodeStarNotificationsClient;
+
+    typedef std::function<void(const CodeStarNotificationsClient*, const Model::CreateNotificationRuleRequest&, const Model::CreateNotificationRuleOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateNotificationRuleResponseReceivedHandler;
+    typedef std::function<void(const CodeStarNotificationsClient*, const Model::DeleteNotificationRuleRequest&, const Model::DeleteNotificationRuleOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteNotificationRuleResponseReceivedHandler;
+    typedef std::function<void(const CodeStarNotificationsClient*, const Model::DeleteTargetRequest&, const Model::DeleteTargetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteTargetResponseReceivedHandler;
+    typedef std::function<void(const CodeStarNotificationsClient*, const Model::DescribeNotificationRuleRequest&, const Model::DescribeNotificationRuleOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeNotificationRuleResponseReceivedHandler;
+    typedef std::function<void(const CodeStarNotificationsClient*, const Model::ListEventTypesRequest&, const Model::ListEventTypesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListEventTypesResponseReceivedHandler;
+    typedef std::function<void(const CodeStarNotificationsClient*, const Model::ListNotificationRulesRequest&, const Model::ListNotificationRulesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListNotificationRulesResponseReceivedHandler;
+    typedef std::function<void(const CodeStarNotificationsClient*, const Model::ListTagsForResourceRequest&, const Model::ListTagsForResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTagsForResourceResponseReceivedHandler;
+    typedef std::function<void(const CodeStarNotificationsClient*, const Model::ListTargetsRequest&, const Model::ListTargetsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTargetsResponseReceivedHandler;
+    typedef std::function<void(const CodeStarNotificationsClient*, const Model::SubscribeRequest&, const Model::SubscribeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SubscribeResponseReceivedHandler;
+    typedef std::function<void(const CodeStarNotificationsClient*, const Model::TagResourceRequest&, const Model::TagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > TagResourceResponseReceivedHandler;
+    typedef std::function<void(const CodeStarNotificationsClient*, const Model::UnsubscribeRequest&, const Model::UnsubscribeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UnsubscribeResponseReceivedHandler;
+    typedef std::function<void(const CodeStarNotificationsClient*, const Model::UntagResourceRequest&, const Model::UntagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UntagResourceResponseReceivedHandler;
+    typedef std::function<void(const CodeStarNotificationsClient*, const Model::UpdateNotificationRuleRequest&, const Model::UpdateNotificationRuleOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateNotificationRuleResponseReceivedHandler;
+
+  /**
+   * <p>This AWS CodeStar Notifications API Reference provides descriptions and usage
+   * examples of the operations and data types for the AWS CodeStar Notifications
+   * API. You can use the AWS CodeStar Notifications API to work with the following
+   * objects:</p> <p>Notification rules, by calling the following: </p> <ul> <li> <p>
+   * <a>CreateNotificationRule</a>, which creates a notification rule for a resource
+   * in your account. </p> </li> <li> <p> <a>DeleteNotificationRule</a>, which
+   * deletes a notification rule. </p> </li> <li> <p>
+   * <a>DescribeNotificationRule</a>, which provides information about a notification
+   * rule. </p> </li> <li> <p> <a>ListNotificationRules</a>, which lists the
+   * notification rules associated with your account. </p> </li> <li> <p>
+   * <a>UpdateNotificationRule</a>, which changes the name, events, or targets
+   * associated with a notification rule. </p> </li> <li> <p> <a>Subscribe</a>, which
+   * subscribes a target to a notification rule. </p> </li> <li> <p>
+   * <a>Unsubscribe</a>, which removes a target from a notification rule. </p> </li>
+   * </ul> <p>Targets, by calling the following: </p> <ul> <li> <p>
+   * <a>DeleteTarget</a>, which removes a notification rule target (SNS topic) from a
+   * notification rule. </p> </li> <li> <p> <a>ListTargets</a>, which lists the
+   * targets associated with a notification rule. </p> </li> </ul> <p>Events, by
+   * calling the following: </p> <ul> <li> <p> <a>ListEventTypes</a>, which lists the
+   * event types you can include in a notification rule. </p> </li> </ul> <p>Tags, by
+   * calling the following: </p> <ul> <li> <p> <a>ListTagsForResource</a>, which
+   * lists the tags already associated with a notification rule in your account. </p>
+   * </li> <li> <p> <a>TagResource</a>, which associates a tag you provide with a
+   * notification rule in your account. </p> </li> <li> <p> <a>UntagResource</a>,
+   * which removes a tag from a notification rule in your account. </p> </li> </ul>
+   * <p> For information about how to use AWS CodeStar Notifications, see link in the
+   * CodeStarNotifications User Guide. </p>
+   */
+  class AWS_CODESTARNOTIFICATIONS_API CodeStarNotificationsClient : public Aws::Client::AWSJsonClient
+  {
+    public:
+      typedef Aws::Client::AWSJsonClient BASECLASS;
+
+       /**
+        * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config
+        * is not specified, it will be initialized to default values.
+        */
+        CodeStarNotificationsClient(const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());
+
+       /**
+        * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config
+        * is not specified, it will be initialized to default values.
+        */
+        CodeStarNotificationsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());
+
+       /**
+        * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied,
+        * the default http client factory will be used
+        */
+        CodeStarNotificationsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
+            const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());
+
+        virtual ~CodeStarNotificationsClient();
+
+
+        /**
+         * <p>Creates a notification rule for a resource. The rule specifies the events you
+         * want notifications about and the targets (such as SNS topics) where you want to
+         * receive them.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/CreateNotificationRule">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::CreateNotificationRuleOutcome CreateNotificationRule(const Model::CreateNotificationRuleRequest& request) const;
+
+        /**
+         * <p>Creates a notification rule for a resource. The rule specifies the events you
+         * want notifications about and the targets (such as SNS topics) where you want to
+         * receive them.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/CreateNotificationRule">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::CreateNotificationRuleOutcomeCallable CreateNotificationRuleCallable(const Model::CreateNotificationRuleRequest& request) const;
+
+        /**
+         * <p>Creates a notification rule for a resource. The rule specifies the events you
+         * want notifications about and the targets (such as SNS topics) where you want to
+         * receive them.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/CreateNotificationRule">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void CreateNotificationRuleAsync(const Model::CreateNotificationRuleRequest& request, const CreateNotificationRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Deletes a notification rule for a resource.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/DeleteNotificationRule">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DeleteNotificationRuleOutcome DeleteNotificationRule(const Model::DeleteNotificationRuleRequest& request) const;
+
+        /**
+         * <p>Deletes a notification rule for a resource.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/DeleteNotificationRule">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DeleteNotificationRuleOutcomeCallable DeleteNotificationRuleCallable(const Model::DeleteNotificationRuleRequest& request) const;
+
+        /**
+         * <p>Deletes a notification rule for a resource.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/DeleteNotificationRule">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DeleteNotificationRuleAsync(const Model::DeleteNotificationRuleRequest& request, const DeleteNotificationRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Deletes a specified target for notifications.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/DeleteTarget">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DeleteTargetOutcome DeleteTarget(const Model::DeleteTargetRequest& request) const;
+
+        /**
+         * <p>Deletes a specified target for notifications.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/DeleteTarget">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DeleteTargetOutcomeCallable DeleteTargetCallable(const Model::DeleteTargetRequest& request) const;
+
+        /**
+         * <p>Deletes a specified target for notifications.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/DeleteTarget">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DeleteTargetAsync(const Model::DeleteTargetRequest& request, const DeleteTargetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Returns information about a specified notification rule.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/DescribeNotificationRule">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DescribeNotificationRuleOutcome DescribeNotificationRule(const Model::DescribeNotificationRuleRequest& request) const;
+
+        /**
+         * <p>Returns information about a specified notification rule.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/DescribeNotificationRule">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DescribeNotificationRuleOutcomeCallable DescribeNotificationRuleCallable(const Model::DescribeNotificationRuleRequest& request) const;
+
+        /**
+         * <p>Returns information about a specified notification rule.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/DescribeNotificationRule">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DescribeNotificationRuleAsync(const Model::DescribeNotificationRuleRequest& request, const DescribeNotificationRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Returns information about the event types available for configuring
+         * notifications.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/ListEventTypes">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ListEventTypesOutcome ListEventTypes(const Model::ListEventTypesRequest& request) const;
+
+        /**
+         * <p>Returns information about the event types available for configuring
+         * notifications.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/ListEventTypes">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::ListEventTypesOutcomeCallable ListEventTypesCallable(const Model::ListEventTypesRequest& request) const;
+
+        /**
+         * <p>Returns information about the event types available for configuring
+         * notifications.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/ListEventTypes">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void ListEventTypesAsync(const Model::ListEventTypesRequest& request, const ListEventTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Returns a list of the notification rules for an AWS account.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/ListNotificationRules">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ListNotificationRulesOutcome ListNotificationRules(const Model::ListNotificationRulesRequest& request) const;
+
+        /**
+         * <p>Returns a list of the notification rules for an AWS account.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/ListNotificationRules">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::ListNotificationRulesOutcomeCallable ListNotificationRulesCallable(const Model::ListNotificationRulesRequest& request) const;
+
+        /**
+         * <p>Returns a list of the notification rules for an AWS account.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/ListNotificationRules">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void ListNotificationRulesAsync(const Model::ListNotificationRulesRequest& request, const ListNotificationRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Returns a list of the tags associated with a notification rule.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/ListTagsForResource">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
+
+        /**
+         * <p>Returns a list of the tags associated with a notification rule.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/ListTagsForResource">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const Model::ListTagsForResourceRequest& request) const;
+
+        /**
+         * <p>Returns a list of the tags associated with a notification rule.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/ListTagsForResource">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void ListTagsForResourceAsync(const Model::ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Returns a list of the notification rule targets for an AWS
+         * account.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/ListTargets">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ListTargetsOutcome ListTargets(const Model::ListTargetsRequest& request) const;
+
+        /**
+         * <p>Returns a list of the notification rule targets for an AWS
+         * account.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/ListTargets">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::ListTargetsOutcomeCallable ListTargetsCallable(const Model::ListTargetsRequest& request) const;
+
+        /**
+         * <p>Returns a list of the notification rule targets for an AWS
+         * account.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/ListTargets">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void ListTargetsAsync(const Model::ListTargetsRequest& request, const ListTargetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Creates an association between a notification rule and an SNS topic so that
+         * the associated target can receive notifications when the events described in the
+         * rule are triggered.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/Subscribe">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::SubscribeOutcome Subscribe(const Model::SubscribeRequest& request) const;
+
+        /**
+         * <p>Creates an association between a notification rule and an SNS topic so that
+         * the associated target can receive notifications when the events described in the
+         * rule are triggered.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/Subscribe">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::SubscribeOutcomeCallable SubscribeCallable(const Model::SubscribeRequest& request) const;
+
+        /**
+         * <p>Creates an association between a notification rule and an SNS topic so that
+         * the associated target can receive notifications when the events described in the
+         * rule are triggered.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/Subscribe">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void SubscribeAsync(const Model::SubscribeRequest& request, const SubscribeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Associates a set of provided tags with a notification rule.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/TagResource">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
+
+        /**
+         * <p>Associates a set of provided tags with a notification rule.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/TagResource">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::TagResourceOutcomeCallable TagResourceCallable(const Model::TagResourceRequest& request) const;
+
+        /**
+         * <p>Associates a set of provided tags with a notification rule.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/TagResource">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void TagResourceAsync(const Model::TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Removes an association between a notification rule and an Amazon SNS topic so
+         * that subscribers to that topic stop receiving notifications when the events
+         * described in the rule are triggered.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/Unsubscribe">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::UnsubscribeOutcome Unsubscribe(const Model::UnsubscribeRequest& request) const;
+
+        /**
+         * <p>Removes an association between a notification rule and an Amazon SNS topic so
+         * that subscribers to that topic stop receiving notifications when the events
+         * described in the rule are triggered.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/Unsubscribe">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::UnsubscribeOutcomeCallable UnsubscribeCallable(const Model::UnsubscribeRequest& request) const;
+
+        /**
+         * <p>Removes an association between a notification rule and an Amazon SNS topic so
+         * that subscribers to that topic stop receiving notifications when the events
+         * described in the rule are triggered.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/Unsubscribe">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void UnsubscribeAsync(const Model::UnsubscribeRequest& request, const UnsubscribeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Removes the association between one or more provided tags and a notification
+         * rule.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/UntagResource">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
+
+        /**
+         * <p>Removes the association between one or more provided tags and a notification
+         * rule.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/UntagResource">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::UntagResourceOutcomeCallable UntagResourceCallable(const Model::UntagResourceRequest& request) const;
+
+        /**
+         * <p>Removes the association between one or more provided tags and a notification
+         * rule.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/UntagResource">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void UntagResourceAsync(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Updates a notification rule for a resource. You can change the events that
+         * trigger the notification rule, the status of the rule, and the targets that
+         * receive the notifications.</p>  <p>To add or remove tags for a
+         * notification rule, you must use <a>TagResource</a> and <a>UntagResource</a>.</p>
+         * <p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/UpdateNotificationRule">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::UpdateNotificationRuleOutcome UpdateNotificationRule(const Model::UpdateNotificationRuleRequest& request) const;
+
+        /**
+         * <p>Updates a notification rule for a resource. You can change the events that
+         * trigger the notification rule, the status of the rule, and the targets that
+         * receive the notifications.</p>  <p>To add or remove tags for a
+         * notification rule, you must use <a>TagResource</a> and <a>UntagResource</a>.</p>
+         * <p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/UpdateNotificationRule">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::UpdateNotificationRuleOutcomeCallable UpdateNotificationRuleCallable(const Model::UpdateNotificationRuleRequest& request) const;
+
+        /**
+         * <p>Updates a notification rule for a resource. You can change the events that
+         * trigger the notification rule, the status of the rule, and the targets that
+         * receive the notifications.</p>  <p>To add or remove tags for a
+         * notification rule, you must use <a>TagResource</a> and <a>UntagResource</a>.</p>
+         * <p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/UpdateNotificationRule">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void UpdateNotificationRuleAsync(const Model::UpdateNotificationRuleRequest& request, const UpdateNotificationRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+
+      void OverrideEndpoint(const Aws::String& endpoint);
+    private:
+      void init(const Aws::Client::ClientConfiguration& clientConfiguration);
+        void CreateNotificationRuleAsyncHelper(const Model::CreateNotificationRuleRequest& request, const CreateNotificationRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DeleteNotificationRuleAsyncHelper(const Model::DeleteNotificationRuleRequest& request, const DeleteNotificationRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DeleteTargetAsyncHelper(const Model::DeleteTargetRequest& request, const DeleteTargetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DescribeNotificationRuleAsyncHelper(const Model::DescribeNotificationRuleRequest& request, const DescribeNotificationRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void ListEventTypesAsyncHelper(const Model::ListEventTypesRequest& request, const ListEventTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void ListNotificationRulesAsyncHelper(const Model::ListNotificationRulesRequest& request, const ListNotificationRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void ListTagsForResourceAsyncHelper(const Model::ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void ListTargetsAsyncHelper(const Model::ListTargetsRequest& request, const ListTargetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void SubscribeAsyncHelper(const Model::SubscribeRequest& request, const SubscribeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void TagResourceAsyncHelper(const Model::TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void UnsubscribeAsyncHelper(const Model::UnsubscribeRequest& request, const UnsubscribeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void UntagResourceAsyncHelper(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void UpdateNotificationRuleAsyncHelper(const Model::UpdateNotificationRuleRequest& request, const UpdateNotificationRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+
+      Aws::String m_uri;
+      Aws::String m_configScheme;
+      std::shared_ptr<Aws::Utils::Threading::Executor> m_executor;
+  };
+
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/CodeStarNotificationsEndpoint.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/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/core/Region.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+
+namespace CodeStarNotifications
+{
+namespace CodeStarNotificationsEndpoint
+{
+AWS_CODESTARNOTIFICATIONS_API Aws::String ForRegion(const Aws::String& regionName, bool useDualStack = false);
+} // namespace CodeStarNotificationsEndpoint
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/CodeStarNotificationsErrorMarshaller.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/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/core/client/AWSErrorMarshaller.h>
+
+namespace Aws
+{
+namespace Client
+{
+
+class AWS_CODESTARNOTIFICATIONS_API CodeStarNotificationsErrorMarshaller : 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-codestar-notifications/include/aws/codestar-notifications/CodeStarNotificationsErrors.h

@@ -0,0 +1,76 @@
+/**
+ * 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/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+
+namespace Aws
+{
+namespace CodeStarNotifications
+{
+enum class CodeStarNotificationsErrors
+{
+  //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,
+  ///////////////////////////////////////////////////////////////////////////////////////////
+
+  CONCURRENT_MODIFICATION= static_cast<int>(Aws::Client::CoreErrors::SERVICE_EXTENSION_START_RANGE) + 1,
+  CONFIGURATION,
+  INVALID_NEXT_TOKEN,
+  LIMIT_EXCEEDED,
+  RESOURCE_ALREADY_EXISTS
+};
+
+class AWS_CODESTARNOTIFICATIONS_API CodeStarNotificationsError : public Aws::Client::AWSError<CodeStarNotificationsErrors>
+{
+public:
+  CodeStarNotificationsError() {}
+  CodeStarNotificationsError(const Aws::Client::AWSError<Aws::Client::CoreErrors>& rhs) : Aws::Client::AWSError<CodeStarNotificationsErrors>(rhs) {}
+  CodeStarNotificationsError(Aws::Client::AWSError<Aws::Client::CoreErrors>&& rhs) : Aws::Client::AWSError<CodeStarNotificationsErrors>(rhs) {}
+  CodeStarNotificationsError(const Aws::Client::AWSError<CodeStarNotificationsErrors>& rhs) : Aws::Client::AWSError<CodeStarNotificationsErrors>(rhs) {}
+  CodeStarNotificationsError(Aws::Client::AWSError<CodeStarNotificationsErrors>&& rhs) : Aws::Client::AWSError<CodeStarNotificationsErrors>(rhs) {}
+
+  template <typename T>
+  T GetModeledError();
+};
+
+namespace CodeStarNotificationsErrorMapper
+{
+  AWS_CODESTARNOTIFICATIONS_API Aws::Client::AWSError<Aws::Client::CoreErrors> GetErrorForName(const char* errorName);
+}
+
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/CodeStarNotificationsRequest.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/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/core/AmazonSerializableWebServiceRequest.h>
+#include <aws/core/utils/UnreferencedParam.h>
+#include <aws/core/http/HttpRequest.h>
+
+namespace Aws
+{
+namespace CodeStarNotifications
+{
+  class AWS_CODESTARNOTIFICATIONS_API CodeStarNotificationsRequest : public Aws::AmazonSerializableWebServiceRequest
+  {
+  public:
+    virtual ~CodeStarNotificationsRequest () {}
+
+    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_1 ));
+      }
+      headers.emplace(Aws::Http::HeaderValuePair(Aws::Http::API_VERSION_HEADER, "2019-10-15"));
+      return headers;
+    }
+
+  protected:
+    virtual Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const { return Aws::Http::HeaderValueCollection(); }
+
+  };
+
+
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/CodeStarNotifications_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_CODESTARNOTIFICATIONS_EXPORTS
+            #define AWS_CODESTARNOTIFICATIONS_API __declspec(dllexport)
+        #else
+            #define AWS_CODESTARNOTIFICATIONS_API __declspec(dllimport)
+        #endif /* AWS_CODESTARNOTIFICATIONS_EXPORTS */
+    #else
+        #define AWS_CODESTARNOTIFICATIONS_API
+    #endif // USE_IMPORT_EXPORT
+#else // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)
+    #define AWS_CODESTARNOTIFICATIONS_API
+#endif // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/CreateNotificationRuleRequest.h

@@ -0,0 +1,537 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/codestar-notifications/CodeStarNotificationsRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/codestar-notifications/model/DetailType.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <aws/codestar-notifications/model/NotificationRuleStatus.h>
+#include <aws/codestar-notifications/model/Target.h>
+#include <utility>
+#include <aws/core/utils/UUID.h>
+
+namespace Aws
+{
+namespace CodeStarNotifications
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_CODESTARNOTIFICATIONS_API CreateNotificationRuleRequest : public CodeStarNotificationsRequest
+  {
+  public:
+    CreateNotificationRuleRequest();
+
+    // 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 "CreateNotificationRule"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The name for the notification rule. Notifictaion rule names must be unique in
+     * your AWS account.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>The name for the notification rule. Notifictaion rule names must be unique in
+     * your AWS account.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>The name for the notification rule. Notifictaion rule names must be unique in
+     * your AWS account.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>The name for the notification rule. Notifictaion rule names must be unique in
+     * your AWS account.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>The name for the notification rule. Notifictaion rule names must be unique in
+     * your AWS account.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>The name for the notification rule. Notifictaion rule names must be unique in
+     * your AWS account.</p>
+     */
+    inline CreateNotificationRuleRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>The name for the notification rule. Notifictaion rule names must be unique in
+     * your AWS account.</p>
+     */
+    inline CreateNotificationRuleRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name for the notification rule. Notifictaion rule names must be unique in
+     * your AWS account.</p>
+     */
+    inline CreateNotificationRuleRequest& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>A list of event types associated with this notification rule. For a list of
+     * allowed events, see <a>EventTypeSummary</a>.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetEventTypeIds() const{ return m_eventTypeIds; }
+
+    /**
+     * <p>A list of event types associated with this notification rule. For a list of
+     * allowed events, see <a>EventTypeSummary</a>.</p>
+     */
+    inline bool EventTypeIdsHasBeenSet() const { return m_eventTypeIdsHasBeenSet; }
+
+    /**
+     * <p>A list of event types associated with this notification rule. For a list of
+     * allowed events, see <a>EventTypeSummary</a>.</p>
+     */
+    inline void SetEventTypeIds(const Aws::Vector<Aws::String>& value) { m_eventTypeIdsHasBeenSet = true; m_eventTypeIds = value; }
+
+    /**
+     * <p>A list of event types associated with this notification rule. For a list of
+     * allowed events, see <a>EventTypeSummary</a>.</p>
+     */
+    inline void SetEventTypeIds(Aws::Vector<Aws::String>&& value) { m_eventTypeIdsHasBeenSet = true; m_eventTypeIds = std::move(value); }
+
+    /**
+     * <p>A list of event types associated with this notification rule. For a list of
+     * allowed events, see <a>EventTypeSummary</a>.</p>
+     */
+    inline CreateNotificationRuleRequest& WithEventTypeIds(const Aws::Vector<Aws::String>& value) { SetEventTypeIds(value); return *this;}
+
+    /**
+     * <p>A list of event types associated with this notification rule. For a list of
+     * allowed events, see <a>EventTypeSummary</a>.</p>
+     */
+    inline CreateNotificationRuleRequest& WithEventTypeIds(Aws::Vector<Aws::String>&& value) { SetEventTypeIds(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of event types associated with this notification rule. For a list of
+     * allowed events, see <a>EventTypeSummary</a>.</p>
+     */
+    inline CreateNotificationRuleRequest& AddEventTypeIds(const Aws::String& value) { m_eventTypeIdsHasBeenSet = true; m_eventTypeIds.push_back(value); return *this; }
+
+    /**
+     * <p>A list of event types associated with this notification rule. For a list of
+     * allowed events, see <a>EventTypeSummary</a>.</p>
+     */
+    inline CreateNotificationRuleRequest& AddEventTypeIds(Aws::String&& value) { m_eventTypeIdsHasBeenSet = true; m_eventTypeIds.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A list of event types associated with this notification rule. For a list of
+     * allowed events, see <a>EventTypeSummary</a>.</p>
+     */
+    inline CreateNotificationRuleRequest& AddEventTypeIds(const char* value) { m_eventTypeIdsHasBeenSet = true; m_eventTypeIds.push_back(value); return *this; }
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource to associate with the
+     * notification rule. Supported resources include pipelines in AWS CodePipeline,
+     * repositories in AWS CodeCommit, and build projects in AWS CodeBuild.</p>
+     */
+    inline const Aws::String& GetResource() const{ return m_resource; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource to associate with the
+     * notification rule. Supported resources include pipelines in AWS CodePipeline,
+     * repositories in AWS CodeCommit, and build projects in AWS CodeBuild.</p>
+     */
+    inline bool ResourceHasBeenSet() const { return m_resourceHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource to associate with the
+     * notification rule. Supported resources include pipelines in AWS CodePipeline,
+     * repositories in AWS CodeCommit, and build projects in AWS CodeBuild.</p>
+     */
+    inline void SetResource(const Aws::String& value) { m_resourceHasBeenSet = true; m_resource = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource to associate with the
+     * notification rule. Supported resources include pipelines in AWS CodePipeline,
+     * repositories in AWS CodeCommit, and build projects in AWS CodeBuild.</p>
+     */
+    inline void SetResource(Aws::String&& value) { m_resourceHasBeenSet = true; m_resource = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource to associate with the
+     * notification rule. Supported resources include pipelines in AWS CodePipeline,
+     * repositories in AWS CodeCommit, and build projects in AWS CodeBuild.</p>
+     */
+    inline void SetResource(const char* value) { m_resourceHasBeenSet = true; m_resource.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource to associate with the
+     * notification rule. Supported resources include pipelines in AWS CodePipeline,
+     * repositories in AWS CodeCommit, and build projects in AWS CodeBuild.</p>
+     */
+    inline CreateNotificationRuleRequest& WithResource(const Aws::String& value) { SetResource(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource to associate with the
+     * notification rule. Supported resources include pipelines in AWS CodePipeline,
+     * repositories in AWS CodeCommit, and build projects in AWS CodeBuild.</p>
+     */
+    inline CreateNotificationRuleRequest& WithResource(Aws::String&& value) { SetResource(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource to associate with the
+     * notification rule. Supported resources include pipelines in AWS CodePipeline,
+     * repositories in AWS CodeCommit, and build projects in AWS CodeBuild.</p>
+     */
+    inline CreateNotificationRuleRequest& WithResource(const char* value) { SetResource(value); return *this;}
+
+
+    /**
+     * <p>A list of Amazon Resource Names (ARNs) of SNS topics to associate with the
+     * notification rule.</p>
+     */
+    inline const Aws::Vector<Target>& GetTargets() const{ return m_targets; }
+
+    /**
+     * <p>A list of Amazon Resource Names (ARNs) of SNS topics to associate with the
+     * notification rule.</p>
+     */
+    inline bool TargetsHasBeenSet() const { return m_targetsHasBeenSet; }
+
+    /**
+     * <p>A list of Amazon Resource Names (ARNs) of SNS topics to associate with the
+     * notification rule.</p>
+     */
+    inline void SetTargets(const Aws::Vector<Target>& value) { m_targetsHasBeenSet = true; m_targets = value; }
+
+    /**
+     * <p>A list of Amazon Resource Names (ARNs) of SNS topics to associate with the
+     * notification rule.</p>
+     */
+    inline void SetTargets(Aws::Vector<Target>&& value) { m_targetsHasBeenSet = true; m_targets = std::move(value); }
+
+    /**
+     * <p>A list of Amazon Resource Names (ARNs) of SNS topics to associate with the
+     * notification rule.</p>
+     */
+    inline CreateNotificationRuleRequest& WithTargets(const Aws::Vector<Target>& value) { SetTargets(value); return *this;}
+
+    /**
+     * <p>A list of Amazon Resource Names (ARNs) of SNS topics to associate with the
+     * notification rule.</p>
+     */
+    inline CreateNotificationRuleRequest& WithTargets(Aws::Vector<Target>&& value) { SetTargets(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of Amazon Resource Names (ARNs) of SNS topics to associate with the
+     * notification rule.</p>
+     */
+    inline CreateNotificationRuleRequest& AddTargets(const Target& value) { m_targetsHasBeenSet = true; m_targets.push_back(value); return *this; }
+
+    /**
+     * <p>A list of Amazon Resource Names (ARNs) of SNS topics to associate with the
+     * notification rule.</p>
+     */
+    inline CreateNotificationRuleRequest& AddTargets(Target&& value) { m_targetsHasBeenSet = true; m_targets.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>The level of detail to include in the notifications for this resource. BASIC
+     * will include only the contents of the event as it would appear in AWS
+     * CloudWatch. FULL will include any supplemental information provided by AWS
+     * CodeStar Notifications and/or the service for the resource for which the
+     * notification is created.</p>
+     */
+    inline const DetailType& GetDetailType() const{ return m_detailType; }
+
+    /**
+     * <p>The level of detail to include in the notifications for this resource. BASIC
+     * will include only the contents of the event as it would appear in AWS
+     * CloudWatch. FULL will include any supplemental information provided by AWS
+     * CodeStar Notifications and/or the service for the resource for which the
+     * notification is created.</p>
+     */
+    inline bool DetailTypeHasBeenSet() const { return m_detailTypeHasBeenSet; }
+
+    /**
+     * <p>The level of detail to include in the notifications for this resource. BASIC
+     * will include only the contents of the event as it would appear in AWS
+     * CloudWatch. FULL will include any supplemental information provided by AWS
+     * CodeStar Notifications and/or the service for the resource for which the
+     * notification is created.</p>
+     */
+    inline void SetDetailType(const DetailType& value) { m_detailTypeHasBeenSet = true; m_detailType = value; }
+
+    /**
+     * <p>The level of detail to include in the notifications for this resource. BASIC
+     * will include only the contents of the event as it would appear in AWS
+     * CloudWatch. FULL will include any supplemental information provided by AWS
+     * CodeStar Notifications and/or the service for the resource for which the
+     * notification is created.</p>
+     */
+    inline void SetDetailType(DetailType&& value) { m_detailTypeHasBeenSet = true; m_detailType = std::move(value); }
+
+    /**
+     * <p>The level of detail to include in the notifications for this resource. BASIC
+     * will include only the contents of the event as it would appear in AWS
+     * CloudWatch. FULL will include any supplemental information provided by AWS
+     * CodeStar Notifications and/or the service for the resource for which the
+     * notification is created.</p>
+     */
+    inline CreateNotificationRuleRequest& WithDetailType(const DetailType& value) { SetDetailType(value); return *this;}
+
+    /**
+     * <p>The level of detail to include in the notifications for this resource. BASIC
+     * will include only the contents of the event as it would appear in AWS
+     * CloudWatch. FULL will include any supplemental information provided by AWS
+     * CodeStar Notifications and/or the service for the resource for which the
+     * notification is created.</p>
+     */
+    inline CreateNotificationRuleRequest& WithDetailType(DetailType&& value) { SetDetailType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>A unique, client-generated idempotency token that, when provided in a
+     * request, ensures the request cannot be repeated with a changed parameter. If a
+     * request with the same parameters is received and a token is included, the
+     * request returns information about the initial request that used that token.</p>
+     *  <p>The AWS SDKs prepopulate client request tokens. If you are using an
+     * AWS SDK, an idempotency token is created for you.</p> 
+     */
+    inline const Aws::String& GetClientRequestToken() const{ return m_clientRequestToken; }
+
+    /**
+     * <p>A unique, client-generated idempotency token that, when provided in a
+     * request, ensures the request cannot be repeated with a changed parameter. If a
+     * request with the same parameters is received and a token is included, the
+     * request returns information about the initial request that used that token.</p>
+     *  <p>The AWS SDKs prepopulate client request tokens. If you are using an
+     * AWS SDK, an idempotency token is created for you.</p> 
+     */
+    inline bool ClientRequestTokenHasBeenSet() const { return m_clientRequestTokenHasBeenSet; }
+
+    /**
+     * <p>A unique, client-generated idempotency token that, when provided in a
+     * request, ensures the request cannot be repeated with a changed parameter. If a
+     * request with the same parameters is received and a token is included, the
+     * request returns information about the initial request that used that token.</p>
+     *  <p>The AWS SDKs prepopulate client request tokens. If you are using an
+     * AWS SDK, an idempotency token is created for you.</p> 
+     */
+    inline void SetClientRequestToken(const Aws::String& value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken = value; }
+
+    /**
+     * <p>A unique, client-generated idempotency token that, when provided in a
+     * request, ensures the request cannot be repeated with a changed parameter. If a
+     * request with the same parameters is received and a token is included, the
+     * request returns information about the initial request that used that token.</p>
+     *  <p>The AWS SDKs prepopulate client request tokens. If you are using an
+     * AWS SDK, an idempotency token is created for you.</p> 
+     */
+    inline void SetClientRequestToken(Aws::String&& value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken = std::move(value); }
+
+    /**
+     * <p>A unique, client-generated idempotency token that, when provided in a
+     * request, ensures the request cannot be repeated with a changed parameter. If a
+     * request with the same parameters is received and a token is included, the
+     * request returns information about the initial request that used that token.</p>
+     *  <p>The AWS SDKs prepopulate client request tokens. If you are using an
+     * AWS SDK, an idempotency token is created for you.</p> 
+     */
+    inline void SetClientRequestToken(const char* value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken.assign(value); }
+
+    /**
+     * <p>A unique, client-generated idempotency token that, when provided in a
+     * request, ensures the request cannot be repeated with a changed parameter. If a
+     * request with the same parameters is received and a token is included, the
+     * request returns information about the initial request that used that token.</p>
+     *  <p>The AWS SDKs prepopulate client request tokens. If you are using an
+     * AWS SDK, an idempotency token is created for you.</p> 
+     */
+    inline CreateNotificationRuleRequest& WithClientRequestToken(const Aws::String& value) { SetClientRequestToken(value); return *this;}
+
+    /**
+     * <p>A unique, client-generated idempotency token that, when provided in a
+     * request, ensures the request cannot be repeated with a changed parameter. If a
+     * request with the same parameters is received and a token is included, the
+     * request returns information about the initial request that used that token.</p>
+     *  <p>The AWS SDKs prepopulate client request tokens. If you are using an
+     * AWS SDK, an idempotency token is created for you.</p> 
+     */
+    inline CreateNotificationRuleRequest& WithClientRequestToken(Aws::String&& value) { SetClientRequestToken(std::move(value)); return *this;}
+
+    /**
+     * <p>A unique, client-generated idempotency token that, when provided in a
+     * request, ensures the request cannot be repeated with a changed parameter. If a
+     * request with the same parameters is received and a token is included, the
+     * request returns information about the initial request that used that token.</p>
+     *  <p>The AWS SDKs prepopulate client request tokens. If you are using an
+     * AWS SDK, an idempotency token is created for you.</p> 
+     */
+    inline CreateNotificationRuleRequest& WithClientRequestToken(const char* value) { SetClientRequestToken(value); return *this;}
+
+
+    /**
+     * <p>A list of tags to apply to this notification rule. Key names cannot start
+     * with "aws". </p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>A list of tags to apply to this notification rule. Key names cannot start
+     * with "aws". </p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>A list of tags to apply to this notification rule. Key names cannot start
+     * with "aws". </p>
+     */
+    inline void SetTags(const Aws::Map<Aws::String, Aws::String>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>A list of tags to apply to this notification rule. Key names cannot start
+     * with "aws". </p>
+     */
+    inline void SetTags(Aws::Map<Aws::String, Aws::String>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>A list of tags to apply to this notification rule. Key names cannot start
+     * with "aws". </p>
+     */
+    inline CreateNotificationRuleRequest& WithTags(const Aws::Map<Aws::String, Aws::String>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>A list of tags to apply to this notification rule. Key names cannot start
+     * with "aws". </p>
+     */
+    inline CreateNotificationRuleRequest& WithTags(Aws::Map<Aws::String, Aws::String>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of tags to apply to this notification rule. Key names cannot start
+     * with "aws". </p>
+     */
+    inline CreateNotificationRuleRequest& AddTags(const Aws::String& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+    /**
+     * <p>A list of tags to apply to this notification rule. Key names cannot start
+     * with "aws". </p>
+     */
+    inline CreateNotificationRuleRequest& AddTags(Aws::String&& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>A list of tags to apply to this notification rule. Key names cannot start
+     * with "aws". </p>
+     */
+    inline CreateNotificationRuleRequest& AddTags(const Aws::String& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A list of tags to apply to this notification rule. Key names cannot start
+     * with "aws". </p>
+     */
+    inline CreateNotificationRuleRequest& AddTags(Aws::String&& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>A list of tags to apply to this notification rule. Key names cannot start
+     * with "aws". </p>
+     */
+    inline CreateNotificationRuleRequest& AddTags(const char* key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A list of tags to apply to this notification rule. Key names cannot start
+     * with "aws". </p>
+     */
+    inline CreateNotificationRuleRequest& AddTags(Aws::String&& key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>A list of tags to apply to this notification rule. Key names cannot start
+     * with "aws". </p>
+     */
+    inline CreateNotificationRuleRequest& AddTags(const char* key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+
+    /**
+     * <p>The status of the notification rule. The default value is ENABLED. If the
+     * status is set to DISABLED, notifications aren't sent for the notification
+     * rule.</p>
+     */
+    inline const NotificationRuleStatus& GetStatus() const{ return m_status; }
+
+    /**
+     * <p>The status of the notification rule. The default value is ENABLED. If the
+     * status is set to DISABLED, notifications aren't sent for the notification
+     * rule.</p>
+     */
+    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
+
+    /**
+     * <p>The status of the notification rule. The default value is ENABLED. If the
+     * status is set to DISABLED, notifications aren't sent for the notification
+     * rule.</p>
+     */
+    inline void SetStatus(const NotificationRuleStatus& value) { m_statusHasBeenSet = true; m_status = value; }
+
+    /**
+     * <p>The status of the notification rule. The default value is ENABLED. If the
+     * status is set to DISABLED, notifications aren't sent for the notification
+     * rule.</p>
+     */
+    inline void SetStatus(NotificationRuleStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
+
+    /**
+     * <p>The status of the notification rule. The default value is ENABLED. If the
+     * status is set to DISABLED, notifications aren't sent for the notification
+     * rule.</p>
+     */
+    inline CreateNotificationRuleRequest& WithStatus(const NotificationRuleStatus& value) { SetStatus(value); return *this;}
+
+    /**
+     * <p>The status of the notification rule. The default value is ENABLED. If the
+     * status is set to DISABLED, notifications aren't sent for the notification
+     * rule.</p>
+     */
+    inline CreateNotificationRuleRequest& WithStatus(NotificationRuleStatus&& value) { SetStatus(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::Vector<Aws::String> m_eventTypeIds;
+    bool m_eventTypeIdsHasBeenSet;
+
+    Aws::String m_resource;
+    bool m_resourceHasBeenSet;
+
+    Aws::Vector<Target> m_targets;
+    bool m_targetsHasBeenSet;
+
+    DetailType m_detailType;
+    bool m_detailTypeHasBeenSet;
+
+    Aws::String m_clientRequestToken;
+    bool m_clientRequestTokenHasBeenSet;
+
+    Aws::Map<Aws::String, Aws::String> m_tags;
+    bool m_tagsHasBeenSet;
+
+    NotificationRuleStatus m_status;
+    bool m_statusHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/CreateNotificationRuleResult.h

@@ -0,0 +1,77 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_EXPORTS.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 CodeStarNotifications
+{
+namespace Model
+{
+  class AWS_CODESTARNOTIFICATIONS_API CreateNotificationRuleResult
+  {
+  public:
+    CreateNotificationRuleResult();
+    CreateNotificationRuleResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    CreateNotificationRuleResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline void SetArn(const char* value) { m_arn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline CreateNotificationRuleResult& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline CreateNotificationRuleResult& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline CreateNotificationRuleResult& WithArn(const char* value) { SetArn(value); return *this;}
+
+  private:
+
+    Aws::String m_arn;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/DeleteNotificationRuleRequest.h

@@ -0,0 +1,91 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/codestar-notifications/CodeStarNotificationsRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace CodeStarNotifications
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_CODESTARNOTIFICATIONS_API DeleteNotificationRuleRequest : public CodeStarNotificationsRequest
+  {
+  public:
+    DeleteNotificationRuleRequest();
+
+    // 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 "DeleteNotificationRule"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule you want to
+     * delete.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule you want to
+     * delete.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule you want to
+     * delete.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule you want to
+     * delete.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule you want to
+     * delete.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule you want to
+     * delete.</p>
+     */
+    inline DeleteNotificationRuleRequest& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule you want to
+     * delete.</p>
+     */
+    inline DeleteNotificationRuleRequest& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule you want to
+     * delete.</p>
+     */
+    inline DeleteNotificationRuleRequest& WithArn(const char* value) { SetArn(value); return *this;}
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/DeleteNotificationRuleResult.h

@@ -0,0 +1,77 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_EXPORTS.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 CodeStarNotifications
+{
+namespace Model
+{
+  class AWS_CODESTARNOTIFICATIONS_API DeleteNotificationRuleResult
+  {
+  public:
+    DeleteNotificationRuleResult();
+    DeleteNotificationRuleResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DeleteNotificationRuleResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the deleted notification rule.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the deleted notification rule.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the deleted notification rule.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the deleted notification rule.</p>
+     */
+    inline void SetArn(const char* value) { m_arn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the deleted notification rule.</p>
+     */
+    inline DeleteNotificationRuleResult& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the deleted notification rule.</p>
+     */
+    inline DeleteNotificationRuleResult& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the deleted notification rule.</p>
+     */
+    inline DeleteNotificationRuleResult& WithArn(const char* value) { SetArn(value); return *this;}
+
+  private:
+
+    Aws::String m_arn;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/DeleteTargetRequest.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/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/codestar-notifications/CodeStarNotificationsRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace CodeStarNotifications
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_CODESTARNOTIFICATIONS_API DeleteTargetRequest : public CodeStarNotificationsRequest
+  {
+  public:
+    DeleteTargetRequest();
+
+    // 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 "DeleteTarget"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic to delete.</p>
+     */
+    inline const Aws::String& GetTargetAddress() const{ return m_targetAddress; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic to delete.</p>
+     */
+    inline bool TargetAddressHasBeenSet() const { return m_targetAddressHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic to delete.</p>
+     */
+    inline void SetTargetAddress(const Aws::String& value) { m_targetAddressHasBeenSet = true; m_targetAddress = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic to delete.</p>
+     */
+    inline void SetTargetAddress(Aws::String&& value) { m_targetAddressHasBeenSet = true; m_targetAddress = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic to delete.</p>
+     */
+    inline void SetTargetAddress(const char* value) { m_targetAddressHasBeenSet = true; m_targetAddress.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic to delete.</p>
+     */
+    inline DeleteTargetRequest& WithTargetAddress(const Aws::String& value) { SetTargetAddress(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic to delete.</p>
+     */
+    inline DeleteTargetRequest& WithTargetAddress(Aws::String&& value) { SetTargetAddress(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic to delete.</p>
+     */
+    inline DeleteTargetRequest& WithTargetAddress(const char* value) { SetTargetAddress(value); return *this;}
+
+
+    /**
+     * <p>A Boolean value that can be used to delete all associations with this SNS
+     * topic. The default value is FALSE. If set to TRUE, all associations between that
+     * target and every notification rule in your AWS account are deleted.</p>
+     */
+    inline bool GetForceUnsubscribeAll() const{ return m_forceUnsubscribeAll; }
+
+    /**
+     * <p>A Boolean value that can be used to delete all associations with this SNS
+     * topic. The default value is FALSE. If set to TRUE, all associations between that
+     * target and every notification rule in your AWS account are deleted.</p>
+     */
+    inline bool ForceUnsubscribeAllHasBeenSet() const { return m_forceUnsubscribeAllHasBeenSet; }
+
+    /**
+     * <p>A Boolean value that can be used to delete all associations with this SNS
+     * topic. The default value is FALSE. If set to TRUE, all associations between that
+     * target and every notification rule in your AWS account are deleted.</p>
+     */
+    inline void SetForceUnsubscribeAll(bool value) { m_forceUnsubscribeAllHasBeenSet = true; m_forceUnsubscribeAll = value; }
+
+    /**
+     * <p>A Boolean value that can be used to delete all associations with this SNS
+     * topic. The default value is FALSE. If set to TRUE, all associations between that
+     * target and every notification rule in your AWS account are deleted.</p>
+     */
+    inline DeleteTargetRequest& WithForceUnsubscribeAll(bool value) { SetForceUnsubscribeAll(value); return *this;}
+
+  private:
+
+    Aws::String m_targetAddress;
+    bool m_targetAddressHasBeenSet;
+
+    bool m_forceUnsubscribeAll;
+    bool m_forceUnsubscribeAllHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/DeleteTargetResult.h

@@ -0,0 +1,36 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace CodeStarNotifications
+{
+namespace Model
+{
+  class AWS_CODESTARNOTIFICATIONS_API DeleteTargetResult
+  {
+  public:
+    DeleteTargetResult();
+    DeleteTargetResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DeleteTargetResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/DescribeNotificationRuleRequest.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/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/codestar-notifications/CodeStarNotificationsRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace CodeStarNotifications
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_CODESTARNOTIFICATIONS_API DescribeNotificationRuleRequest : public CodeStarNotificationsRequest
+  {
+  public:
+    DescribeNotificationRuleRequest();
+
+    // 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 "DescribeNotificationRule"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline DescribeNotificationRuleRequest& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline DescribeNotificationRuleRequest& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline DescribeNotificationRuleRequest& WithArn(const char* value) { SetArn(value); return *this;}
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/DescribeNotificationRuleResult.h

@@ -0,0 +1,486 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/codestar-notifications/model/DetailType.h>
+#include <aws/codestar-notifications/model/NotificationRuleStatus.h>
+#include <aws/core/utils/DateTime.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <aws/codestar-notifications/model/EventTypeSummary.h>
+#include <aws/codestar-notifications/model/TargetSummary.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace CodeStarNotifications
+{
+namespace Model
+{
+  class AWS_CODESTARNOTIFICATIONS_API DescribeNotificationRuleResult
+  {
+  public:
+    DescribeNotificationRuleResult();
+    DescribeNotificationRuleResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeNotificationRuleResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline void SetArn(const char* value) { m_arn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& WithArn(const char* value) { SetArn(value); return *this;}
+
+
+    /**
+     * <p>The name of the notification rule.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>The name of the notification rule.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_name = value; }
+
+    /**
+     * <p>The name of the notification rule.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_name = std::move(value); }
+
+    /**
+     * <p>The name of the notification rule.</p>
+     */
+    inline void SetName(const char* value) { m_name.assign(value); }
+
+    /**
+     * <p>The name of the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>The name of the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>A list of the event types associated with the notification rule.</p>
+     */
+    inline const Aws::Vector<EventTypeSummary>& GetEventTypes() const{ return m_eventTypes; }
+
+    /**
+     * <p>A list of the event types associated with the notification rule.</p>
+     */
+    inline void SetEventTypes(const Aws::Vector<EventTypeSummary>& value) { m_eventTypes = value; }
+
+    /**
+     * <p>A list of the event types associated with the notification rule.</p>
+     */
+    inline void SetEventTypes(Aws::Vector<EventTypeSummary>&& value) { m_eventTypes = std::move(value); }
+
+    /**
+     * <p>A list of the event types associated with the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& WithEventTypes(const Aws::Vector<EventTypeSummary>& value) { SetEventTypes(value); return *this;}
+
+    /**
+     * <p>A list of the event types associated with the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& WithEventTypes(Aws::Vector<EventTypeSummary>&& value) { SetEventTypes(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of the event types associated with the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& AddEventTypes(const EventTypeSummary& value) { m_eventTypes.push_back(value); return *this; }
+
+    /**
+     * <p>A list of the event types associated with the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& AddEventTypes(EventTypeSummary&& value) { m_eventTypes.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource associated with the
+     * notification rule.</p>
+     */
+    inline const Aws::String& GetResource() const{ return m_resource; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource associated with the
+     * notification rule.</p>
+     */
+    inline void SetResource(const Aws::String& value) { m_resource = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource associated with the
+     * notification rule.</p>
+     */
+    inline void SetResource(Aws::String&& value) { m_resource = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource associated with the
+     * notification rule.</p>
+     */
+    inline void SetResource(const char* value) { m_resource.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource associated with the
+     * notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& WithResource(const Aws::String& value) { SetResource(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource associated with the
+     * notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& WithResource(Aws::String&& value) { SetResource(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource associated with the
+     * notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& WithResource(const char* value) { SetResource(value); return *this;}
+
+
+    /**
+     * <p>A list of the SNS topics associated with the notification rule.</p>
+     */
+    inline const Aws::Vector<TargetSummary>& GetTargets() const{ return m_targets; }
+
+    /**
+     * <p>A list of the SNS topics associated with the notification rule.</p>
+     */
+    inline void SetTargets(const Aws::Vector<TargetSummary>& value) { m_targets = value; }
+
+    /**
+     * <p>A list of the SNS topics associated with the notification rule.</p>
+     */
+    inline void SetTargets(Aws::Vector<TargetSummary>&& value) { m_targets = std::move(value); }
+
+    /**
+     * <p>A list of the SNS topics associated with the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& WithTargets(const Aws::Vector<TargetSummary>& value) { SetTargets(value); return *this;}
+
+    /**
+     * <p>A list of the SNS topics associated with the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& WithTargets(Aws::Vector<TargetSummary>&& value) { SetTargets(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of the SNS topics associated with the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& AddTargets(const TargetSummary& value) { m_targets.push_back(value); return *this; }
+
+    /**
+     * <p>A list of the SNS topics associated with the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& AddTargets(TargetSummary&& value) { m_targets.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>The level of detail included in the notifications for this resource. BASIC
+     * will include only the contents of the event as it would appear in AWS
+     * CloudWatch. FULL will include any supplemental information provided by AWS
+     * CodeStar Notifications and/or the service for the resource for which the
+     * notification is created.</p>
+     */
+    inline const DetailType& GetDetailType() const{ return m_detailType; }
+
+    /**
+     * <p>The level of detail included in the notifications for this resource. BASIC
+     * will include only the contents of the event as it would appear in AWS
+     * CloudWatch. FULL will include any supplemental information provided by AWS
+     * CodeStar Notifications and/or the service for the resource for which the
+     * notification is created.</p>
+     */
+    inline void SetDetailType(const DetailType& value) { m_detailType = value; }
+
+    /**
+     * <p>The level of detail included in the notifications for this resource. BASIC
+     * will include only the contents of the event as it would appear in AWS
+     * CloudWatch. FULL will include any supplemental information provided by AWS
+     * CodeStar Notifications and/or the service for the resource for which the
+     * notification is created.</p>
+     */
+    inline void SetDetailType(DetailType&& value) { m_detailType = std::move(value); }
+
+    /**
+     * <p>The level of detail included in the notifications for this resource. BASIC
+     * will include only the contents of the event as it would appear in AWS
+     * CloudWatch. FULL will include any supplemental information provided by AWS
+     * CodeStar Notifications and/or the service for the resource for which the
+     * notification is created.</p>
+     */
+    inline DescribeNotificationRuleResult& WithDetailType(const DetailType& value) { SetDetailType(value); return *this;}
+
+    /**
+     * <p>The level of detail included in the notifications for this resource. BASIC
+     * will include only the contents of the event as it would appear in AWS
+     * CloudWatch. FULL will include any supplemental information provided by AWS
+     * CodeStar Notifications and/or the service for the resource for which the
+     * notification is created.</p>
+     */
+    inline DescribeNotificationRuleResult& WithDetailType(DetailType&& value) { SetDetailType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The name or email alias of the person who created the notification rule.</p>
+     */
+    inline const Aws::String& GetCreatedBy() const{ return m_createdBy; }
+
+    /**
+     * <p>The name or email alias of the person who created the notification rule.</p>
+     */
+    inline void SetCreatedBy(const Aws::String& value) { m_createdBy = value; }
+
+    /**
+     * <p>The name or email alias of the person who created the notification rule.</p>
+     */
+    inline void SetCreatedBy(Aws::String&& value) { m_createdBy = std::move(value); }
+
+    /**
+     * <p>The name or email alias of the person who created the notification rule.</p>
+     */
+    inline void SetCreatedBy(const char* value) { m_createdBy.assign(value); }
+
+    /**
+     * <p>The name or email alias of the person who created the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& WithCreatedBy(const Aws::String& value) { SetCreatedBy(value); return *this;}
+
+    /**
+     * <p>The name or email alias of the person who created the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& WithCreatedBy(Aws::String&& value) { SetCreatedBy(std::move(value)); return *this;}
+
+    /**
+     * <p>The name or email alias of the person who created the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& WithCreatedBy(const char* value) { SetCreatedBy(value); return *this;}
+
+
+    /**
+     * <p>The status of the notification rule. Valid statuses are on (sending
+     * notifications) or off (not sending notifications).</p>
+     */
+    inline const NotificationRuleStatus& GetStatus() const{ return m_status; }
+
+    /**
+     * <p>The status of the notification rule. Valid statuses are on (sending
+     * notifications) or off (not sending notifications).</p>
+     */
+    inline void SetStatus(const NotificationRuleStatus& value) { m_status = value; }
+
+    /**
+     * <p>The status of the notification rule. Valid statuses are on (sending
+     * notifications) or off (not sending notifications).</p>
+     */
+    inline void SetStatus(NotificationRuleStatus&& value) { m_status = std::move(value); }
+
+    /**
+     * <p>The status of the notification rule. Valid statuses are on (sending
+     * notifications) or off (not sending notifications).</p>
+     */
+    inline DescribeNotificationRuleResult& WithStatus(const NotificationRuleStatus& value) { SetStatus(value); return *this;}
+
+    /**
+     * <p>The status of the notification rule. Valid statuses are on (sending
+     * notifications) or off (not sending notifications).</p>
+     */
+    inline DescribeNotificationRuleResult& WithStatus(NotificationRuleStatus&& value) { SetStatus(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The date and time the notification rule was created, in timestamp format.</p>
+     */
+    inline const Aws::Utils::DateTime& GetCreatedTimestamp() const{ return m_createdTimestamp; }
+
+    /**
+     * <p>The date and time the notification rule was created, in timestamp format.</p>
+     */
+    inline void SetCreatedTimestamp(const Aws::Utils::DateTime& value) { m_createdTimestamp = value; }
+
+    /**
+     * <p>The date and time the notification rule was created, in timestamp format.</p>
+     */
+    inline void SetCreatedTimestamp(Aws::Utils::DateTime&& value) { m_createdTimestamp = std::move(value); }
+
+    /**
+     * <p>The date and time the notification rule was created, in timestamp format.</p>
+     */
+    inline DescribeNotificationRuleResult& WithCreatedTimestamp(const Aws::Utils::DateTime& value) { SetCreatedTimestamp(value); return *this;}
+
+    /**
+     * <p>The date and time the notification rule was created, in timestamp format.</p>
+     */
+    inline DescribeNotificationRuleResult& WithCreatedTimestamp(Aws::Utils::DateTime&& value) { SetCreatedTimestamp(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The date and time the notification rule was most recently updated, in
+     * timestamp format.</p>
+     */
+    inline const Aws::Utils::DateTime& GetLastModifiedTimestamp() const{ return m_lastModifiedTimestamp; }
+
+    /**
+     * <p>The date and time the notification rule was most recently updated, in
+     * timestamp format.</p>
+     */
+    inline void SetLastModifiedTimestamp(const Aws::Utils::DateTime& value) { m_lastModifiedTimestamp = value; }
+
+    /**
+     * <p>The date and time the notification rule was most recently updated, in
+     * timestamp format.</p>
+     */
+    inline void SetLastModifiedTimestamp(Aws::Utils::DateTime&& value) { m_lastModifiedTimestamp = std::move(value); }
+
+    /**
+     * <p>The date and time the notification rule was most recently updated, in
+     * timestamp format.</p>
+     */
+    inline DescribeNotificationRuleResult& WithLastModifiedTimestamp(const Aws::Utils::DateTime& value) { SetLastModifiedTimestamp(value); return *this;}
+
+    /**
+     * <p>The date and time the notification rule was most recently updated, in
+     * timestamp format.</p>
+     */
+    inline DescribeNotificationRuleResult& WithLastModifiedTimestamp(Aws::Utils::DateTime&& value) { SetLastModifiedTimestamp(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline void SetTags(const Aws::Map<Aws::String, Aws::String>& value) { m_tags = value; }
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline void SetTags(Aws::Map<Aws::String, Aws::String>&& value) { m_tags = std::move(value); }
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& WithTags(const Aws::Map<Aws::String, Aws::String>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& WithTags(Aws::Map<Aws::String, Aws::String>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& AddTags(const Aws::String& key, const Aws::String& value) { m_tags.emplace(key, value); return *this; }
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& AddTags(Aws::String&& key, const Aws::String& value) { m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& AddTags(const Aws::String& key, Aws::String&& value) { m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& AddTags(Aws::String&& key, Aws::String&& value) { m_tags.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& AddTags(const char* key, Aws::String&& value) { m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& AddTags(Aws::String&& key, const char* value) { m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline DescribeNotificationRuleResult& AddTags(const char* key, const char* value) { m_tags.emplace(key, value); return *this; }
+
+  private:
+
+    Aws::String m_arn;
+
+    Aws::String m_name;
+
+    Aws::Vector<EventTypeSummary> m_eventTypes;
+
+    Aws::String m_resource;
+
+    Aws::Vector<TargetSummary> m_targets;
+
+    DetailType m_detailType;
+
+    Aws::String m_createdBy;
+
+    NotificationRuleStatus m_status;
+
+    Aws::Utils::DateTime m_createdTimestamp;
+
+    Aws::Utils::DateTime m_lastModifiedTimestamp;
+
+    Aws::Map<Aws::String, Aws::String> m_tags;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/DetailType.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/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace CodeStarNotifications
+{
+namespace Model
+{
+  enum class DetailType
+  {
+    NOT_SET,
+    BASIC,
+    FULL
+  };
+
+namespace DetailTypeMapper
+{
+AWS_CODESTARNOTIFICATIONS_API DetailType GetDetailTypeForName(const Aws::String& name);
+
+AWS_CODESTARNOTIFICATIONS_API Aws::String GetNameForDetailType(DetailType value);
+} // namespace DetailTypeMapper
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/EventTypeSummary.h

@@ -0,0 +1,221 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_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 CodeStarNotifications
+{
+namespace Model
+{
+
+  /**
+   * <p>Returns information about an event that has triggered a notification
+   * rule.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/EventTypeSummary">AWS
+   * API Reference</a></p>
+   */
+  class AWS_CODESTARNOTIFICATIONS_API EventTypeSummary
+  {
+  public:
+    EventTypeSummary();
+    EventTypeSummary(Aws::Utils::Json::JsonView jsonValue);
+    EventTypeSummary& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The system-generated ID of the event.</p>
+     */
+    inline const Aws::String& GetEventTypeId() const{ return m_eventTypeId; }
+
+    /**
+     * <p>The system-generated ID of the event.</p>
+     */
+    inline bool EventTypeIdHasBeenSet() const { return m_eventTypeIdHasBeenSet; }
+
+    /**
+     * <p>The system-generated ID of the event.</p>
+     */
+    inline void SetEventTypeId(const Aws::String& value) { m_eventTypeIdHasBeenSet = true; m_eventTypeId = value; }
+
+    /**
+     * <p>The system-generated ID of the event.</p>
+     */
+    inline void SetEventTypeId(Aws::String&& value) { m_eventTypeIdHasBeenSet = true; m_eventTypeId = std::move(value); }
+
+    /**
+     * <p>The system-generated ID of the event.</p>
+     */
+    inline void SetEventTypeId(const char* value) { m_eventTypeIdHasBeenSet = true; m_eventTypeId.assign(value); }
+
+    /**
+     * <p>The system-generated ID of the event.</p>
+     */
+    inline EventTypeSummary& WithEventTypeId(const Aws::String& value) { SetEventTypeId(value); return *this;}
+
+    /**
+     * <p>The system-generated ID of the event.</p>
+     */
+    inline EventTypeSummary& WithEventTypeId(Aws::String&& value) { SetEventTypeId(std::move(value)); return *this;}
+
+    /**
+     * <p>The system-generated ID of the event.</p>
+     */
+    inline EventTypeSummary& WithEventTypeId(const char* value) { SetEventTypeId(value); return *this;}
+
+
+    /**
+     * <p>The name of the service for which the event applies.</p>
+     */
+    inline const Aws::String& GetServiceName() const{ return m_serviceName; }
+
+    /**
+     * <p>The name of the service for which the event applies.</p>
+     */
+    inline bool ServiceNameHasBeenSet() const { return m_serviceNameHasBeenSet; }
+
+    /**
+     * <p>The name of the service for which the event applies.</p>
+     */
+    inline void SetServiceName(const Aws::String& value) { m_serviceNameHasBeenSet = true; m_serviceName = value; }
+
+    /**
+     * <p>The name of the service for which the event applies.</p>
+     */
+    inline void SetServiceName(Aws::String&& value) { m_serviceNameHasBeenSet = true; m_serviceName = std::move(value); }
+
+    /**
+     * <p>The name of the service for which the event applies.</p>
+     */
+    inline void SetServiceName(const char* value) { m_serviceNameHasBeenSet = true; m_serviceName.assign(value); }
+
+    /**
+     * <p>The name of the service for which the event applies.</p>
+     */
+    inline EventTypeSummary& WithServiceName(const Aws::String& value) { SetServiceName(value); return *this;}
+
+    /**
+     * <p>The name of the service for which the event applies.</p>
+     */
+    inline EventTypeSummary& WithServiceName(Aws::String&& value) { SetServiceName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the service for which the event applies.</p>
+     */
+    inline EventTypeSummary& WithServiceName(const char* value) { SetServiceName(value); return *this;}
+
+
+    /**
+     * <p>The name of the event.</p>
+     */
+    inline const Aws::String& GetEventTypeName() const{ return m_eventTypeName; }
+
+    /**
+     * <p>The name of the event.</p>
+     */
+    inline bool EventTypeNameHasBeenSet() const { return m_eventTypeNameHasBeenSet; }
+
+    /**
+     * <p>The name of the event.</p>
+     */
+    inline void SetEventTypeName(const Aws::String& value) { m_eventTypeNameHasBeenSet = true; m_eventTypeName = value; }
+
+    /**
+     * <p>The name of the event.</p>
+     */
+    inline void SetEventTypeName(Aws::String&& value) { m_eventTypeNameHasBeenSet = true; m_eventTypeName = std::move(value); }
+
+    /**
+     * <p>The name of the event.</p>
+     */
+    inline void SetEventTypeName(const char* value) { m_eventTypeNameHasBeenSet = true; m_eventTypeName.assign(value); }
+
+    /**
+     * <p>The name of the event.</p>
+     */
+    inline EventTypeSummary& WithEventTypeName(const Aws::String& value) { SetEventTypeName(value); return *this;}
+
+    /**
+     * <p>The name of the event.</p>
+     */
+    inline EventTypeSummary& WithEventTypeName(Aws::String&& value) { SetEventTypeName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the event.</p>
+     */
+    inline EventTypeSummary& WithEventTypeName(const char* value) { SetEventTypeName(value); return *this;}
+
+
+    /**
+     * <p>The resource type of the event.</p>
+     */
+    inline const Aws::String& GetResourceType() const{ return m_resourceType; }
+
+    /**
+     * <p>The resource type of the event.</p>
+     */
+    inline bool ResourceTypeHasBeenSet() const { return m_resourceTypeHasBeenSet; }
+
+    /**
+     * <p>The resource type of the event.</p>
+     */
+    inline void SetResourceType(const Aws::String& value) { m_resourceTypeHasBeenSet = true; m_resourceType = value; }
+
+    /**
+     * <p>The resource type of the event.</p>
+     */
+    inline void SetResourceType(Aws::String&& value) { m_resourceTypeHasBeenSet = true; m_resourceType = std::move(value); }
+
+    /**
+     * <p>The resource type of the event.</p>
+     */
+    inline void SetResourceType(const char* value) { m_resourceTypeHasBeenSet = true; m_resourceType.assign(value); }
+
+    /**
+     * <p>The resource type of the event.</p>
+     */
+    inline EventTypeSummary& WithResourceType(const Aws::String& value) { SetResourceType(value); return *this;}
+
+    /**
+     * <p>The resource type of the event.</p>
+     */
+    inline EventTypeSummary& WithResourceType(Aws::String&& value) { SetResourceType(std::move(value)); return *this;}
+
+    /**
+     * <p>The resource type of the event.</p>
+     */
+    inline EventTypeSummary& WithResourceType(const char* value) { SetResourceType(value); return *this;}
+
+  private:
+
+    Aws::String m_eventTypeId;
+    bool m_eventTypeIdHasBeenSet;
+
+    Aws::String m_serviceName;
+    bool m_serviceNameHasBeenSet;
+
+    Aws::String m_eventTypeName;
+    bool m_eventTypeNameHasBeenSet;
+
+    Aws::String m_resourceType;
+    bool m_resourceTypeHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/ListEventTypesFilter.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/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/codestar-notifications/model/ListEventTypesFilterName.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 CodeStarNotifications
+{
+namespace Model
+{
+
+  /**
+   * <p>Information about a filter to apply to the list of returned event types. You
+   * can filter by resource type or service name.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/ListEventTypesFilter">AWS
+   * API Reference</a></p>
+   */
+  class AWS_CODESTARNOTIFICATIONS_API ListEventTypesFilter
+  {
+  public:
+    ListEventTypesFilter();
+    ListEventTypesFilter(Aws::Utils::Json::JsonView jsonValue);
+    ListEventTypesFilter& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The system-generated name of the filter type you want to filter by.</p>
+     */
+    inline const ListEventTypesFilterName& GetName() const{ return m_name; }
+
+    /**
+     * <p>The system-generated name of the filter type you want to filter by.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>The system-generated name of the filter type you want to filter by.</p>
+     */
+    inline void SetName(const ListEventTypesFilterName& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>The system-generated name of the filter type you want to filter by.</p>
+     */
+    inline void SetName(ListEventTypesFilterName&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>The system-generated name of the filter type you want to filter by.</p>
+     */
+    inline ListEventTypesFilter& WithName(const ListEventTypesFilterName& value) { SetName(value); return *this;}
+
+    /**
+     * <p>The system-generated name of the filter type you want to filter by.</p>
+     */
+    inline ListEventTypesFilter& WithName(ListEventTypesFilterName&& value) { SetName(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The name of the resource type (for example, pipeline) or service name (for
+     * example, CodePipeline) that you want to filter by.</p>
+     */
+    inline const Aws::String& GetValue() const{ return m_value; }
+
+    /**
+     * <p>The name of the resource type (for example, pipeline) or service name (for
+     * example, CodePipeline) that you want to filter by.</p>
+     */
+    inline bool ValueHasBeenSet() const { return m_valueHasBeenSet; }
+
+    /**
+     * <p>The name of the resource type (for example, pipeline) or service name (for
+     * example, CodePipeline) that you want to filter by.</p>
+     */
+    inline void SetValue(const Aws::String& value) { m_valueHasBeenSet = true; m_value = value; }
+
+    /**
+     * <p>The name of the resource type (for example, pipeline) or service name (for
+     * example, CodePipeline) that you want to filter by.</p>
+     */
+    inline void SetValue(Aws::String&& value) { m_valueHasBeenSet = true; m_value = std::move(value); }
+
+    /**
+     * <p>The name of the resource type (for example, pipeline) or service name (for
+     * example, CodePipeline) that you want to filter by.</p>
+     */
+    inline void SetValue(const char* value) { m_valueHasBeenSet = true; m_value.assign(value); }
+
+    /**
+     * <p>The name of the resource type (for example, pipeline) or service name (for
+     * example, CodePipeline) that you want to filter by.</p>
+     */
+    inline ListEventTypesFilter& WithValue(const Aws::String& value) { SetValue(value); return *this;}
+
+    /**
+     * <p>The name of the resource type (for example, pipeline) or service name (for
+     * example, CodePipeline) that you want to filter by.</p>
+     */
+    inline ListEventTypesFilter& WithValue(Aws::String&& value) { SetValue(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the resource type (for example, pipeline) or service name (for
+     * example, CodePipeline) that you want to filter by.</p>
+     */
+    inline ListEventTypesFilter& WithValue(const char* value) { SetValue(value); return *this;}
+
+  private:
+
+    ListEventTypesFilterName m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::String m_value;
+    bool m_valueHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/ListEventTypesFilterName.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/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace CodeStarNotifications
+{
+namespace Model
+{
+  enum class ListEventTypesFilterName
+  {
+    NOT_SET,
+    RESOURCE_TYPE,
+    SERVICE_NAME
+  };
+
+namespace ListEventTypesFilterNameMapper
+{
+AWS_CODESTARNOTIFICATIONS_API ListEventTypesFilterName GetListEventTypesFilterNameForName(const Aws::String& name);
+
+AWS_CODESTARNOTIFICATIONS_API Aws::String GetNameForListEventTypesFilterName(ListEventTypesFilterName value);
+} // namespace ListEventTypesFilterNameMapper
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/ListEventTypesRequest.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/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/codestar-notifications/CodeStarNotificationsRequest.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/codestar-notifications/model/ListEventTypesFilter.h>
+#include <utility>
+
+namespace Aws
+{
+namespace CodeStarNotifications
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_CODESTARNOTIFICATIONS_API ListEventTypesRequest : public CodeStarNotificationsRequest
+  {
+  public:
+    ListEventTypesRequest();
+
+    // 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 "ListEventTypes"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The filters to use to return information by service or resource type.</p>
+     */
+    inline const Aws::Vector<ListEventTypesFilter>& GetFilters() const{ return m_filters; }
+
+    /**
+     * <p>The filters to use to return information by service or resource type.</p>
+     */
+    inline bool FiltersHasBeenSet() const { return m_filtersHasBeenSet; }
+
+    /**
+     * <p>The filters to use to return information by service or resource type.</p>
+     */
+    inline void SetFilters(const Aws::Vector<ListEventTypesFilter>& value) { m_filtersHasBeenSet = true; m_filters = value; }
+
+    /**
+     * <p>The filters to use to return information by service or resource type.</p>
+     */
+    inline void SetFilters(Aws::Vector<ListEventTypesFilter>&& value) { m_filtersHasBeenSet = true; m_filters = std::move(value); }
+
+    /**
+     * <p>The filters to use to return information by service or resource type.</p>
+     */
+    inline ListEventTypesRequest& WithFilters(const Aws::Vector<ListEventTypesFilter>& value) { SetFilters(value); return *this;}
+
+    /**
+     * <p>The filters to use to return information by service or resource type.</p>
+     */
+    inline ListEventTypesRequest& WithFilters(Aws::Vector<ListEventTypesFilter>&& value) { SetFilters(std::move(value)); return *this;}
+
+    /**
+     * <p>The filters to use to return information by service or resource type.</p>
+     */
+    inline ListEventTypesRequest& AddFilters(const ListEventTypesFilter& value) { m_filtersHasBeenSet = true; m_filters.push_back(value); return *this; }
+
+    /**
+     * <p>The filters to use to return information by service or resource type.</p>
+     */
+    inline ListEventTypesRequest& AddFilters(ListEventTypesFilter&& value) { m_filtersHasBeenSet = true; m_filters.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline ListEventTypesRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline ListEventTypesRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline ListEventTypesRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>A non-negative integer used to limit the number of returned results. The
+     * default number is 50. The maximum number of results that can be returned is
+     * 100.</p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>A non-negative integer used to limit the number of returned results. The
+     * default number is 50. The maximum number of results that can be returned is
+     * 100.</p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>A non-negative integer used to limit the number of returned results. The
+     * default number is 50. The maximum number of results that can be returned is
+     * 100.</p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>A non-negative integer used to limit the number of returned results. The
+     * default number is 50. The maximum number of results that can be returned is
+     * 100.</p>
+     */
+    inline ListEventTypesRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+  private:
+
+    Aws::Vector<ListEventTypesFilter> m_filters;
+    bool m_filtersHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/ListEventTypesResult.h

@@ -0,0 +1,131 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/codestar-notifications/model/EventTypeSummary.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace CodeStarNotifications
+{
+namespace Model
+{
+  class AWS_CODESTARNOTIFICATIONS_API ListEventTypesResult
+  {
+  public:
+    ListEventTypesResult();
+    ListEventTypesResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListEventTypesResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Information about each event, including service name, resource type, event
+     * ID, and event name.</p>
+     */
+    inline const Aws::Vector<EventTypeSummary>& GetEventTypes() const{ return m_eventTypes; }
+
+    /**
+     * <p>Information about each event, including service name, resource type, event
+     * ID, and event name.</p>
+     */
+    inline void SetEventTypes(const Aws::Vector<EventTypeSummary>& value) { m_eventTypes = value; }
+
+    /**
+     * <p>Information about each event, including service name, resource type, event
+     * ID, and event name.</p>
+     */
+    inline void SetEventTypes(Aws::Vector<EventTypeSummary>&& value) { m_eventTypes = std::move(value); }
+
+    /**
+     * <p>Information about each event, including service name, resource type, event
+     * ID, and event name.</p>
+     */
+    inline ListEventTypesResult& WithEventTypes(const Aws::Vector<EventTypeSummary>& value) { SetEventTypes(value); return *this;}
+
+    /**
+     * <p>Information about each event, including service name, resource type, event
+     * ID, and event name.</p>
+     */
+    inline ListEventTypesResult& WithEventTypes(Aws::Vector<EventTypeSummary>&& value) { SetEventTypes(std::move(value)); return *this;}
+
+    /**
+     * <p>Information about each event, including service name, resource type, event
+     * ID, and event name.</p>
+     */
+    inline ListEventTypesResult& AddEventTypes(const EventTypeSummary& value) { m_eventTypes.push_back(value); return *this; }
+
+    /**
+     * <p>Information about each event, including service name, resource type, event
+     * ID, and event name.</p>
+     */
+    inline ListEventTypesResult& AddEventTypes(EventTypeSummary&& value) { m_eventTypes.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>An enumeration token that can be used in a request to return the next batch
+     * of the results.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>An enumeration token that can be used in a request to return the next batch
+     * of the results.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>An enumeration token that can be used in a request to return the next batch
+     * of the results.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>An enumeration token that can be used in a request to return the next batch
+     * of the results.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>An enumeration token that can be used in a request to return the next batch
+     * of the results.</p>
+     */
+    inline ListEventTypesResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>An enumeration token that can be used in a request to return the next batch
+     * of the results.</p>
+     */
+    inline ListEventTypesResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>An enumeration token that can be used in a request to return the next batch
+     * of the results.</p>
+     */
+    inline ListEventTypesResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    Aws::Vector<EventTypeSummary> m_eventTypes;
+
+    Aws::String m_nextToken;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/ListNotificationRulesFilter.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/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/codestar-notifications/model/ListNotificationRulesFilterName.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 CodeStarNotifications
+{
+namespace Model
+{
+
+  /**
+   * <p>Information about a filter to apply to the list of returned notification
+   * rules. You can filter by event type, owner, resource, or target.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/ListNotificationRulesFilter">AWS
+   * API Reference</a></p>
+   */
+  class AWS_CODESTARNOTIFICATIONS_API ListNotificationRulesFilter
+  {
+  public:
+    ListNotificationRulesFilter();
+    ListNotificationRulesFilter(Aws::Utils::Json::JsonView jsonValue);
+    ListNotificationRulesFilter& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the attribute you want to use to filter the returned notification
+     * rules.</p>
+     */
+    inline const ListNotificationRulesFilterName& GetName() const{ return m_name; }
+
+    /**
+     * <p>The name of the attribute you want to use to filter the returned notification
+     * rules.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>The name of the attribute you want to use to filter the returned notification
+     * rules.</p>
+     */
+    inline void SetName(const ListNotificationRulesFilterName& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>The name of the attribute you want to use to filter the returned notification
+     * rules.</p>
+     */
+    inline void SetName(ListNotificationRulesFilterName&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>The name of the attribute you want to use to filter the returned notification
+     * rules.</p>
+     */
+    inline ListNotificationRulesFilter& WithName(const ListNotificationRulesFilterName& value) { SetName(value); return *this;}
+
+    /**
+     * <p>The name of the attribute you want to use to filter the returned notification
+     * rules.</p>
+     */
+    inline ListNotificationRulesFilter& WithName(ListNotificationRulesFilterName&& value) { SetName(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The value of the attribute you want to use to filter the returned
+     * notification rules. For example, if you specify filtering by <i>RESOURCE</i> in
+     * Name, you might specify the ARN of a pipeline in AWS CodePipeline for the
+     * value.</p>
+     */
+    inline const Aws::String& GetValue() const{ return m_value; }
+
+    /**
+     * <p>The value of the attribute you want to use to filter the returned
+     * notification rules. For example, if you specify filtering by <i>RESOURCE</i> in
+     * Name, you might specify the ARN of a pipeline in AWS CodePipeline for the
+     * value.</p>
+     */
+    inline bool ValueHasBeenSet() const { return m_valueHasBeenSet; }
+
+    /**
+     * <p>The value of the attribute you want to use to filter the returned
+     * notification rules. For example, if you specify filtering by <i>RESOURCE</i> in
+     * Name, you might specify the ARN of a pipeline in AWS CodePipeline for the
+     * value.</p>
+     */
+    inline void SetValue(const Aws::String& value) { m_valueHasBeenSet = true; m_value = value; }
+
+    /**
+     * <p>The value of the attribute you want to use to filter the returned
+     * notification rules. For example, if you specify filtering by <i>RESOURCE</i> in
+     * Name, you might specify the ARN of a pipeline in AWS CodePipeline for the
+     * value.</p>
+     */
+    inline void SetValue(Aws::String&& value) { m_valueHasBeenSet = true; m_value = std::move(value); }
+
+    /**
+     * <p>The value of the attribute you want to use to filter the returned
+     * notification rules. For example, if you specify filtering by <i>RESOURCE</i> in
+     * Name, you might specify the ARN of a pipeline in AWS CodePipeline for the
+     * value.</p>
+     */
+    inline void SetValue(const char* value) { m_valueHasBeenSet = true; m_value.assign(value); }
+
+    /**
+     * <p>The value of the attribute you want to use to filter the returned
+     * notification rules. For example, if you specify filtering by <i>RESOURCE</i> in
+     * Name, you might specify the ARN of a pipeline in AWS CodePipeline for the
+     * value.</p>
+     */
+    inline ListNotificationRulesFilter& WithValue(const Aws::String& value) { SetValue(value); return *this;}
+
+    /**
+     * <p>The value of the attribute you want to use to filter the returned
+     * notification rules. For example, if you specify filtering by <i>RESOURCE</i> in
+     * Name, you might specify the ARN of a pipeline in AWS CodePipeline for the
+     * value.</p>
+     */
+    inline ListNotificationRulesFilter& WithValue(Aws::String&& value) { SetValue(std::move(value)); return *this;}
+
+    /**
+     * <p>The value of the attribute you want to use to filter the returned
+     * notification rules. For example, if you specify filtering by <i>RESOURCE</i> in
+     * Name, you might specify the ARN of a pipeline in AWS CodePipeline for the
+     * value.</p>
+     */
+    inline ListNotificationRulesFilter& WithValue(const char* value) { SetValue(value); return *this;}
+
+  private:
+
+    ListNotificationRulesFilterName m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::String m_value;
+    bool m_valueHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/ListNotificationRulesFilterName.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/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace CodeStarNotifications
+{
+namespace Model
+{
+  enum class ListNotificationRulesFilterName
+  {
+    NOT_SET,
+    EVENT_TYPE_ID,
+    CREATED_BY,
+    RESOURCE,
+    TARGET_ADDRESS
+  };
+
+namespace ListNotificationRulesFilterNameMapper
+{
+AWS_CODESTARNOTIFICATIONS_API ListNotificationRulesFilterName GetListNotificationRulesFilterNameForName(const Aws::String& name);
+
+AWS_CODESTARNOTIFICATIONS_API Aws::String GetNameForListNotificationRulesFilterName(ListNotificationRulesFilterName value);
+} // namespace ListNotificationRulesFilterNameMapper
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/ListNotificationRulesRequest.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/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/codestar-notifications/CodeStarNotificationsRequest.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/codestar-notifications/model/ListNotificationRulesFilter.h>
+#include <utility>
+
+namespace Aws
+{
+namespace CodeStarNotifications
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_CODESTARNOTIFICATIONS_API ListNotificationRulesRequest : public CodeStarNotificationsRequest
+  {
+  public:
+    ListNotificationRulesRequest();
+
+    // 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 "ListNotificationRules"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The filters to use to return information by service or resource type. For
+     * valid values, see <a>ListNotificationRulesFilter</a>.</p>  <p>A filter
+     * with the same name can appear more than once when used with OR statements.
+     * Filters with different names should be applied with AND statements.</p> 
+     */
+    inline const Aws::Vector<ListNotificationRulesFilter>& GetFilters() const{ return m_filters; }
+
+    /**
+     * <p>The filters to use to return information by service or resource type. For
+     * valid values, see <a>ListNotificationRulesFilter</a>.</p>  <p>A filter
+     * with the same name can appear more than once when used with OR statements.
+     * Filters with different names should be applied with AND statements.</p> 
+     */
+    inline bool FiltersHasBeenSet() const { return m_filtersHasBeenSet; }
+
+    /**
+     * <p>The filters to use to return information by service or resource type. For
+     * valid values, see <a>ListNotificationRulesFilter</a>.</p>  <p>A filter
+     * with the same name can appear more than once when used with OR statements.
+     * Filters with different names should be applied with AND statements.</p> 
+     */
+    inline void SetFilters(const Aws::Vector<ListNotificationRulesFilter>& value) { m_filtersHasBeenSet = true; m_filters = value; }
+
+    /**
+     * <p>The filters to use to return information by service or resource type. For
+     * valid values, see <a>ListNotificationRulesFilter</a>.</p>  <p>A filter
+     * with the same name can appear more than once when used with OR statements.
+     * Filters with different names should be applied with AND statements.</p> 
+     */
+    inline void SetFilters(Aws::Vector<ListNotificationRulesFilter>&& value) { m_filtersHasBeenSet = true; m_filters = std::move(value); }
+
+    /**
+     * <p>The filters to use to return information by service or resource type. For
+     * valid values, see <a>ListNotificationRulesFilter</a>.</p>  <p>A filter
+     * with the same name can appear more than once when used with OR statements.
+     * Filters with different names should be applied with AND statements.</p> 
+     */
+    inline ListNotificationRulesRequest& WithFilters(const Aws::Vector<ListNotificationRulesFilter>& value) { SetFilters(value); return *this;}
+
+    /**
+     * <p>The filters to use to return information by service or resource type. For
+     * valid values, see <a>ListNotificationRulesFilter</a>.</p>  <p>A filter
+     * with the same name can appear more than once when used with OR statements.
+     * Filters with different names should be applied with AND statements.</p> 
+     */
+    inline ListNotificationRulesRequest& WithFilters(Aws::Vector<ListNotificationRulesFilter>&& value) { SetFilters(std::move(value)); return *this;}
+
+    /**
+     * <p>The filters to use to return information by service or resource type. For
+     * valid values, see <a>ListNotificationRulesFilter</a>.</p>  <p>A filter
+     * with the same name can appear more than once when used with OR statements.
+     * Filters with different names should be applied with AND statements.</p> 
+     */
+    inline ListNotificationRulesRequest& AddFilters(const ListNotificationRulesFilter& value) { m_filtersHasBeenSet = true; m_filters.push_back(value); return *this; }
+
+    /**
+     * <p>The filters to use to return information by service or resource type. For
+     * valid values, see <a>ListNotificationRulesFilter</a>.</p>  <p>A filter
+     * with the same name can appear more than once when used with OR statements.
+     * Filters with different names should be applied with AND statements.</p> 
+     */
+    inline ListNotificationRulesRequest& AddFilters(ListNotificationRulesFilter&& value) { m_filtersHasBeenSet = true; m_filters.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline ListNotificationRulesRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline ListNotificationRulesRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline ListNotificationRulesRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>A non-negative integer used to limit the number of returned results. The
+     * maximum number of results that can be returned is 100.</p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>A non-negative integer used to limit the number of returned results. The
+     * maximum number of results that can be returned is 100.</p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>A non-negative integer used to limit the number of returned results. The
+     * maximum number of results that can be returned is 100.</p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>A non-negative integer used to limit the number of returned results. The
+     * maximum number of results that can be returned is 100.</p>
+     */
+    inline ListNotificationRulesRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+  private:
+
+    Aws::Vector<ListNotificationRulesFilter> m_filters;
+    bool m_filtersHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/ListNotificationRulesResult.h

@@ -0,0 +1,131 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/codestar-notifications/model/NotificationRuleSummary.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace CodeStarNotifications
+{
+namespace Model
+{
+  class AWS_CODESTARNOTIFICATIONS_API ListNotificationRulesResult
+  {
+  public:
+    ListNotificationRulesResult();
+    ListNotificationRulesResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListNotificationRulesResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>An enumeration token that can be used in a request to return the next batch
+     * of the results.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>An enumeration token that can be used in a request to return the next batch
+     * of the results.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>An enumeration token that can be used in a request to return the next batch
+     * of the results.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>An enumeration token that can be used in a request to return the next batch
+     * of the results.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>An enumeration token that can be used in a request to return the next batch
+     * of the results.</p>
+     */
+    inline ListNotificationRulesResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>An enumeration token that can be used in a request to return the next batch
+     * of the results.</p>
+     */
+    inline ListNotificationRulesResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>An enumeration token that can be used in a request to return the next batch
+     * of the results.</p>
+     */
+    inline ListNotificationRulesResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>The list of notification rules for the AWS account, by Amazon Resource Name
+     * (ARN) and ID. </p>
+     */
+    inline const Aws::Vector<NotificationRuleSummary>& GetNotificationRules() const{ return m_notificationRules; }
+
+    /**
+     * <p>The list of notification rules for the AWS account, by Amazon Resource Name
+     * (ARN) and ID. </p>
+     */
+    inline void SetNotificationRules(const Aws::Vector<NotificationRuleSummary>& value) { m_notificationRules = value; }
+
+    /**
+     * <p>The list of notification rules for the AWS account, by Amazon Resource Name
+     * (ARN) and ID. </p>
+     */
+    inline void SetNotificationRules(Aws::Vector<NotificationRuleSummary>&& value) { m_notificationRules = std::move(value); }
+
+    /**
+     * <p>The list of notification rules for the AWS account, by Amazon Resource Name
+     * (ARN) and ID. </p>
+     */
+    inline ListNotificationRulesResult& WithNotificationRules(const Aws::Vector<NotificationRuleSummary>& value) { SetNotificationRules(value); return *this;}
+
+    /**
+     * <p>The list of notification rules for the AWS account, by Amazon Resource Name
+     * (ARN) and ID. </p>
+     */
+    inline ListNotificationRulesResult& WithNotificationRules(Aws::Vector<NotificationRuleSummary>&& value) { SetNotificationRules(std::move(value)); return *this;}
+
+    /**
+     * <p>The list of notification rules for the AWS account, by Amazon Resource Name
+     * (ARN) and ID. </p>
+     */
+    inline ListNotificationRulesResult& AddNotificationRules(const NotificationRuleSummary& value) { m_notificationRules.push_back(value); return *this; }
+
+    /**
+     * <p>The list of notification rules for the AWS account, by Amazon Resource Name
+     * (ARN) and ID. </p>
+     */
+    inline ListNotificationRulesResult& AddNotificationRules(NotificationRuleSummary&& value) { m_notificationRules.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_nextToken;
+
+    Aws::Vector<NotificationRuleSummary> m_notificationRules;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/ListTagsForResourceRequest.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/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/codestar-notifications/CodeStarNotificationsRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace CodeStarNotifications
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_CODESTARNOTIFICATIONS_API ListTagsForResourceRequest : public CodeStarNotificationsRequest
+  {
+  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;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the notification rule.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the notification rule.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the notification rule.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the notification rule.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the notification rule.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the notification rule.</p>
+     */
+    inline ListTagsForResourceRequest& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the notification rule.</p>
+     */
+    inline ListTagsForResourceRequest& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the notification rule.</p>
+     */
+    inline ListTagsForResourceRequest& WithArn(const char* value) { SetArn(value); return *this;}
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

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

@@ -0,0 +1,103 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSMap.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 CodeStarNotifications
+{
+namespace Model
+{
+  class AWS_CODESTARNOTIFICATIONS_API ListTagsForResourceResult
+  {
+  public:
+    ListTagsForResourceResult();
+    ListTagsForResourceResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListTagsForResourceResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline void SetTags(const Aws::Map<Aws::String, Aws::String>& value) { m_tags = value; }
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline void SetTags(Aws::Map<Aws::String, Aws::String>&& value) { m_tags = std::move(value); }
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline ListTagsForResourceResult& WithTags(const Aws::Map<Aws::String, Aws::String>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline ListTagsForResourceResult& WithTags(Aws::Map<Aws::String, Aws::String>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline ListTagsForResourceResult& AddTags(const Aws::String& key, const Aws::String& value) { m_tags.emplace(key, value); return *this; }
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline ListTagsForResourceResult& AddTags(Aws::String&& key, const Aws::String& value) { m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline ListTagsForResourceResult& AddTags(const Aws::String& key, Aws::String&& value) { m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline ListTagsForResourceResult& AddTags(Aws::String&& key, Aws::String&& value) { m_tags.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline ListTagsForResourceResult& AddTags(const char* key, Aws::String&& value) { m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline ListTagsForResourceResult& AddTags(Aws::String&& key, const char* value) { m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>The tags associated with the notification rule.</p>
+     */
+    inline ListTagsForResourceResult& AddTags(const char* key, const char* value) { m_tags.emplace(key, value); return *this; }
+
+  private:
+
+    Aws::Map<Aws::String, Aws::String> m_tags;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/ListTargetsFilter.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/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/codestar-notifications/model/ListTargetsFilterName.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 CodeStarNotifications
+{
+namespace Model
+{
+
+  /**
+   * <p>Information about a filter to apply to the list of returned targets. You can
+   * filter by target type, address, or status. For example, to filter results to
+   * notification rules that have active Amazon SNS topics as targets, you could
+   * specify a ListTargetsFilter Name as TargetType and a Value of SNS, and a Name of
+   * TARGET_STATUS and a Value of ACTIVE.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/ListTargetsFilter">AWS
+   * API Reference</a></p>
+   */
+  class AWS_CODESTARNOTIFICATIONS_API ListTargetsFilter
+  {
+  public:
+    ListTargetsFilter();
+    ListTargetsFilter(Aws::Utils::Json::JsonView jsonValue);
+    ListTargetsFilter& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the attribute you want to use to filter the returned targets.</p>
+     */
+    inline const ListTargetsFilterName& GetName() const{ return m_name; }
+
+    /**
+     * <p>The name of the attribute you want to use to filter the returned targets.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>The name of the attribute you want to use to filter the returned targets.</p>
+     */
+    inline void SetName(const ListTargetsFilterName& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>The name of the attribute you want to use to filter the returned targets.</p>
+     */
+    inline void SetName(ListTargetsFilterName&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>The name of the attribute you want to use to filter the returned targets.</p>
+     */
+    inline ListTargetsFilter& WithName(const ListTargetsFilterName& value) { SetName(value); return *this;}
+
+    /**
+     * <p>The name of the attribute you want to use to filter the returned targets.</p>
+     */
+    inline ListTargetsFilter& WithName(ListTargetsFilterName&& value) { SetName(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The value of the attribute you want to use to filter the returned targets.
+     * For example, if you specify <i>SNS</i> for the Target type, you could specify an
+     * Amazon Resource Name (ARN) for a topic as the value.</p>
+     */
+    inline const Aws::String& GetValue() const{ return m_value; }
+
+    /**
+     * <p>The value of the attribute you want to use to filter the returned targets.
+     * For example, if you specify <i>SNS</i> for the Target type, you could specify an
+     * Amazon Resource Name (ARN) for a topic as the value.</p>
+     */
+    inline bool ValueHasBeenSet() const { return m_valueHasBeenSet; }
+
+    /**
+     * <p>The value of the attribute you want to use to filter the returned targets.
+     * For example, if you specify <i>SNS</i> for the Target type, you could specify an
+     * Amazon Resource Name (ARN) for a topic as the value.</p>
+     */
+    inline void SetValue(const Aws::String& value) { m_valueHasBeenSet = true; m_value = value; }
+
+    /**
+     * <p>The value of the attribute you want to use to filter the returned targets.
+     * For example, if you specify <i>SNS</i> for the Target type, you could specify an
+     * Amazon Resource Name (ARN) for a topic as the value.</p>
+     */
+    inline void SetValue(Aws::String&& value) { m_valueHasBeenSet = true; m_value = std::move(value); }
+
+    /**
+     * <p>The value of the attribute you want to use to filter the returned targets.
+     * For example, if you specify <i>SNS</i> for the Target type, you could specify an
+     * Amazon Resource Name (ARN) for a topic as the value.</p>
+     */
+    inline void SetValue(const char* value) { m_valueHasBeenSet = true; m_value.assign(value); }
+
+    /**
+     * <p>The value of the attribute you want to use to filter the returned targets.
+     * For example, if you specify <i>SNS</i> for the Target type, you could specify an
+     * Amazon Resource Name (ARN) for a topic as the value.</p>
+     */
+    inline ListTargetsFilter& WithValue(const Aws::String& value) { SetValue(value); return *this;}
+
+    /**
+     * <p>The value of the attribute you want to use to filter the returned targets.
+     * For example, if you specify <i>SNS</i> for the Target type, you could specify an
+     * Amazon Resource Name (ARN) for a topic as the value.</p>
+     */
+    inline ListTargetsFilter& WithValue(Aws::String&& value) { SetValue(std::move(value)); return *this;}
+
+    /**
+     * <p>The value of the attribute you want to use to filter the returned targets.
+     * For example, if you specify <i>SNS</i> for the Target type, you could specify an
+     * Amazon Resource Name (ARN) for a topic as the value.</p>
+     */
+    inline ListTargetsFilter& WithValue(const char* value) { SetValue(value); return *this;}
+
+  private:
+
+    ListTargetsFilterName m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::String m_value;
+    bool m_valueHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/ListTargetsFilterName.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/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace CodeStarNotifications
+{
+namespace Model
+{
+  enum class ListTargetsFilterName
+  {
+    NOT_SET,
+    TARGET_TYPE,
+    TARGET_ADDRESS,
+    TARGET_STATUS
+  };
+
+namespace ListTargetsFilterNameMapper
+{
+AWS_CODESTARNOTIFICATIONS_API ListTargetsFilterName GetListTargetsFilterNameForName(const Aws::String& name);
+
+AWS_CODESTARNOTIFICATIONS_API Aws::String GetNameForListTargetsFilterName(ListTargetsFilterName value);
+} // namespace ListTargetsFilterNameMapper
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/ListTargetsRequest.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/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/codestar-notifications/CodeStarNotificationsRequest.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/codestar-notifications/model/ListTargetsFilter.h>
+#include <utility>
+
+namespace Aws
+{
+namespace CodeStarNotifications
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_CODESTARNOTIFICATIONS_API ListTargetsRequest : public CodeStarNotificationsRequest
+  {
+  public:
+    ListTargetsRequest();
+
+    // 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 "ListTargets"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The filters to use to return information by service or resource type. Valid
+     * filters include target type, target address, and target status.</p>  <p>A
+     * filter with the same name can appear more than once when used with OR
+     * statements. Filters with different names should be applied with AND
+     * statements.</p> 
+     */
+    inline const Aws::Vector<ListTargetsFilter>& GetFilters() const{ return m_filters; }
+
+    /**
+     * <p>The filters to use to return information by service or resource type. Valid
+     * filters include target type, target address, and target status.</p>  <p>A
+     * filter with the same name can appear more than once when used with OR
+     * statements. Filters with different names should be applied with AND
+     * statements.</p> 
+     */
+    inline bool FiltersHasBeenSet() const { return m_filtersHasBeenSet; }
+
+    /**
+     * <p>The filters to use to return information by service or resource type. Valid
+     * filters include target type, target address, and target status.</p>  <p>A
+     * filter with the same name can appear more than once when used with OR
+     * statements. Filters with different names should be applied with AND
+     * statements.</p> 
+     */
+    inline void SetFilters(const Aws::Vector<ListTargetsFilter>& value) { m_filtersHasBeenSet = true; m_filters = value; }
+
+    /**
+     * <p>The filters to use to return information by service or resource type. Valid
+     * filters include target type, target address, and target status.</p>  <p>A
+     * filter with the same name can appear more than once when used with OR
+     * statements. Filters with different names should be applied with AND
+     * statements.</p> 
+     */
+    inline void SetFilters(Aws::Vector<ListTargetsFilter>&& value) { m_filtersHasBeenSet = true; m_filters = std::move(value); }
+
+    /**
+     * <p>The filters to use to return information by service or resource type. Valid
+     * filters include target type, target address, and target status.</p>  <p>A
+     * filter with the same name can appear more than once when used with OR
+     * statements. Filters with different names should be applied with AND
+     * statements.</p> 
+     */
+    inline ListTargetsRequest& WithFilters(const Aws::Vector<ListTargetsFilter>& value) { SetFilters(value); return *this;}
+
+    /**
+     * <p>The filters to use to return information by service or resource type. Valid
+     * filters include target type, target address, and target status.</p>  <p>A
+     * filter with the same name can appear more than once when used with OR
+     * statements. Filters with different names should be applied with AND
+     * statements.</p> 
+     */
+    inline ListTargetsRequest& WithFilters(Aws::Vector<ListTargetsFilter>&& value) { SetFilters(std::move(value)); return *this;}
+
+    /**
+     * <p>The filters to use to return information by service or resource type. Valid
+     * filters include target type, target address, and target status.</p>  <p>A
+     * filter with the same name can appear more than once when used with OR
+     * statements. Filters with different names should be applied with AND
+     * statements.</p> 
+     */
+    inline ListTargetsRequest& AddFilters(const ListTargetsFilter& value) { m_filtersHasBeenSet = true; m_filters.push_back(value); return *this; }
+
+    /**
+     * <p>The filters to use to return information by service or resource type. Valid
+     * filters include target type, target address, and target status.</p>  <p>A
+     * filter with the same name can appear more than once when used with OR
+     * statements. Filters with different names should be applied with AND
+     * statements.</p> 
+     */
+    inline ListTargetsRequest& AddFilters(ListTargetsFilter&& value) { m_filtersHasBeenSet = true; m_filters.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline ListTargetsRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline ListTargetsRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline ListTargetsRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>A non-negative integer used to limit the number of returned results. The
+     * maximum number of results that can be returned is 100.</p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>A non-negative integer used to limit the number of returned results. The
+     * maximum number of results that can be returned is 100.</p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>A non-negative integer used to limit the number of returned results. The
+     * maximum number of results that can be returned is 100.</p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>A non-negative integer used to limit the number of returned results. The
+     * maximum number of results that can be returned is 100.</p>
+     */
+    inline ListTargetsRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+  private:
+
+    Aws::Vector<ListTargetsFilter> m_filters;
+    bool m_filtersHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/ListTargetsResult.h

@@ -0,0 +1,124 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/codestar-notifications/model/TargetSummary.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace CodeStarNotifications
+{
+namespace Model
+{
+  class AWS_CODESTARNOTIFICATIONS_API ListTargetsResult
+  {
+  public:
+    ListTargetsResult();
+    ListTargetsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListTargetsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The list of notification rule targets. </p>
+     */
+    inline const Aws::Vector<TargetSummary>& GetTargets() const{ return m_targets; }
+
+    /**
+     * <p>The list of notification rule targets. </p>
+     */
+    inline void SetTargets(const Aws::Vector<TargetSummary>& value) { m_targets = value; }
+
+    /**
+     * <p>The list of notification rule targets. </p>
+     */
+    inline void SetTargets(Aws::Vector<TargetSummary>&& value) { m_targets = std::move(value); }
+
+    /**
+     * <p>The list of notification rule targets. </p>
+     */
+    inline ListTargetsResult& WithTargets(const Aws::Vector<TargetSummary>& value) { SetTargets(value); return *this;}
+
+    /**
+     * <p>The list of notification rule targets. </p>
+     */
+    inline ListTargetsResult& WithTargets(Aws::Vector<TargetSummary>&& value) { SetTargets(std::move(value)); return *this;}
+
+    /**
+     * <p>The list of notification rule targets. </p>
+     */
+    inline ListTargetsResult& AddTargets(const TargetSummary& value) { m_targets.push_back(value); return *this; }
+
+    /**
+     * <p>The list of notification rule targets. </p>
+     */
+    inline ListTargetsResult& AddTargets(TargetSummary&& value) { m_targets.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>An enumeration token that can be used in a request to return the next batch
+     * of results.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>An enumeration token that can be used in a request to return the next batch
+     * of results.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>An enumeration token that can be used in a request to return the next batch
+     * of results.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>An enumeration token that can be used in a request to return the next batch
+     * of results.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>An enumeration token that can be used in a request to return the next batch
+     * of results.</p>
+     */
+    inline ListTargetsResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>An enumeration token that can be used in a request to return the next batch
+     * of results.</p>
+     */
+    inline ListTargetsResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>An enumeration token that can be used in a request to return the next batch
+     * of results.</p>
+     */
+    inline ListTargetsResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    Aws::Vector<TargetSummary> m_targets;
+
+    Aws::String m_nextToken;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/NotificationRuleStatus.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/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace CodeStarNotifications
+{
+namespace Model
+{
+  enum class NotificationRuleStatus
+  {
+    NOT_SET,
+    ENABLED,
+    DISABLED
+  };
+
+namespace NotificationRuleStatusMapper
+{
+AWS_CODESTARNOTIFICATIONS_API NotificationRuleStatus GetNotificationRuleStatusForName(const Aws::String& name);
+
+AWS_CODESTARNOTIFICATIONS_API Aws::String GetNameForNotificationRuleStatus(NotificationRuleStatus value);
+} // namespace NotificationRuleStatusMapper
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/NotificationRuleSummary.h

@@ -0,0 +1,133 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_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 CodeStarNotifications
+{
+namespace Model
+{
+
+  /**
+   * <p>Information about a specified notification rule.</p><p><h3>See Also:</h3>  
+   * <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/NotificationRuleSummary">AWS
+   * API Reference</a></p>
+   */
+  class AWS_CODESTARNOTIFICATIONS_API NotificationRuleSummary
+  {
+  public:
+    NotificationRuleSummary();
+    NotificationRuleSummary(Aws::Utils::Json::JsonView jsonValue);
+    NotificationRuleSummary& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The unique ID of the notification rule.</p>
+     */
+    inline const Aws::String& GetId() const{ return m_id; }
+
+    /**
+     * <p>The unique ID of the notification rule.</p>
+     */
+    inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
+
+    /**
+     * <p>The unique ID of the notification rule.</p>
+     */
+    inline void SetId(const Aws::String& value) { m_idHasBeenSet = true; m_id = value; }
+
+    /**
+     * <p>The unique ID of the notification rule.</p>
+     */
+    inline void SetId(Aws::String&& value) { m_idHasBeenSet = true; m_id = std::move(value); }
+
+    /**
+     * <p>The unique ID of the notification rule.</p>
+     */
+    inline void SetId(const char* value) { m_idHasBeenSet = true; m_id.assign(value); }
+
+    /**
+     * <p>The unique ID of the notification rule.</p>
+     */
+    inline NotificationRuleSummary& WithId(const Aws::String& value) { SetId(value); return *this;}
+
+    /**
+     * <p>The unique ID of the notification rule.</p>
+     */
+    inline NotificationRuleSummary& WithId(Aws::String&& value) { SetId(std::move(value)); return *this;}
+
+    /**
+     * <p>The unique ID of the notification rule.</p>
+     */
+    inline NotificationRuleSummary& WithId(const char* value) { SetId(value); return *this;}
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline NotificationRuleSummary& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline NotificationRuleSummary& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline NotificationRuleSummary& WithArn(const char* value) { SetArn(value); return *this;}
+
+  private:
+
+    Aws::String m_id;
+    bool m_idHasBeenSet;
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/SubscribeRequest.h

@@ -0,0 +1,166 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/codestar-notifications/CodeStarNotificationsRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/codestar-notifications/model/Target.h>
+#include <utility>
+
+namespace Aws
+{
+namespace CodeStarNotifications
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_CODESTARNOTIFICATIONS_API SubscribeRequest : public CodeStarNotificationsRequest
+  {
+  public:
+    SubscribeRequest();
+
+    // 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 "Subscribe"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule for which you want to
+     * create the association.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule for which you want to
+     * create the association.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule for which you want to
+     * create the association.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule for which you want to
+     * create the association.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule for which you want to
+     * create the association.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule for which you want to
+     * create the association.</p>
+     */
+    inline SubscribeRequest& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule for which you want to
+     * create the association.</p>
+     */
+    inline SubscribeRequest& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule for which you want to
+     * create the association.</p>
+     */
+    inline SubscribeRequest& WithArn(const char* value) { SetArn(value); return *this;}
+
+
+    
+    inline const Target& GetTarget() const{ return m_target; }
+
+    
+    inline bool TargetHasBeenSet() const { return m_targetHasBeenSet; }
+
+    
+    inline void SetTarget(const Target& value) { m_targetHasBeenSet = true; m_target = value; }
+
+    
+    inline void SetTarget(Target&& value) { m_targetHasBeenSet = true; m_target = std::move(value); }
+
+    
+    inline SubscribeRequest& WithTarget(const Target& value) { SetTarget(value); return *this;}
+
+    
+    inline SubscribeRequest& WithTarget(Target&& value) { SetTarget(std::move(value)); return *this;}
+
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline const Aws::String& GetClientRequestToken() const{ return m_clientRequestToken; }
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline bool ClientRequestTokenHasBeenSet() const { return m_clientRequestTokenHasBeenSet; }
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline void SetClientRequestToken(const Aws::String& value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken = value; }
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline void SetClientRequestToken(Aws::String&& value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken = std::move(value); }
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline void SetClientRequestToken(const char* value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken.assign(value); }
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline SubscribeRequest& WithClientRequestToken(const Aws::String& value) { SetClientRequestToken(value); return *this;}
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline SubscribeRequest& WithClientRequestToken(Aws::String&& value) { SetClientRequestToken(std::move(value)); return *this;}
+
+    /**
+     * <p>An enumeration token that, when provided in a request, returns the next batch
+     * of the results.</p>
+     */
+    inline SubscribeRequest& WithClientRequestToken(const char* value) { SetClientRequestToken(value); return *this;}
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+
+    Target m_target;
+    bool m_targetHasBeenSet;
+
+    Aws::String m_clientRequestToken;
+    bool m_clientRequestTokenHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/SubscribeResult.h

@@ -0,0 +1,84 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_EXPORTS.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 CodeStarNotifications
+{
+namespace Model
+{
+  class AWS_CODESTARNOTIFICATIONS_API SubscribeResult
+  {
+  public:
+    SubscribeResult();
+    SubscribeResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    SubscribeResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule for which you have
+     * created assocations.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule for which you have
+     * created assocations.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule for which you have
+     * created assocations.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule for which you have
+     * created assocations.</p>
+     */
+    inline void SetArn(const char* value) { m_arn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule for which you have
+     * created assocations.</p>
+     */
+    inline SubscribeResult& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule for which you have
+     * created assocations.</p>
+     */
+    inline SubscribeResult& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule for which you have
+     * created assocations.</p>
+     */
+    inline SubscribeResult& WithArn(const char* value) { SetArn(value); return *this;}
+
+  private:
+
+    Aws::String m_arn;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/TagResourceRequest.h

@@ -0,0 +1,166 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/codestar-notifications/CodeStarNotificationsRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace CodeStarNotifications
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_CODESTARNOTIFICATIONS_API TagResourceRequest : public CodeStarNotificationsRequest
+  {
+  public:
+    TagResourceRequest();
+
+    // 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 "TagResource"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule to tag.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule to tag.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule to tag.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule to tag.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule to tag.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule to tag.</p>
+     */
+    inline TagResourceRequest& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule to tag.</p>
+     */
+    inline TagResourceRequest& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule to tag.</p>
+     */
+    inline TagResourceRequest& WithArn(const char* value) { SetArn(value); return *this;}
+
+
+    /**
+     * <p>The list of tags to associate with the resource. Tag key names cannot start
+     * with "aws".</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>The list of tags to associate with the resource. Tag key names cannot start
+     * with "aws".</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>The list of tags to associate with the resource. Tag key names cannot start
+     * with "aws".</p>
+     */
+    inline void SetTags(const Aws::Map<Aws::String, Aws::String>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>The list of tags to associate with the resource. Tag key names cannot start
+     * with "aws".</p>
+     */
+    inline void SetTags(Aws::Map<Aws::String, Aws::String>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>The list of tags to associate with the resource. Tag key names cannot start
+     * with "aws".</p>
+     */
+    inline TagResourceRequest& WithTags(const Aws::Map<Aws::String, Aws::String>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>The list of tags to associate with the resource. Tag key names cannot start
+     * with "aws".</p>
+     */
+    inline TagResourceRequest& WithTags(Aws::Map<Aws::String, Aws::String>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>The list of tags to associate with the resource. Tag key names cannot start
+     * with "aws".</p>
+     */
+    inline TagResourceRequest& AddTags(const Aws::String& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+    /**
+     * <p>The list of tags to associate with the resource. Tag key names cannot start
+     * with "aws".</p>
+     */
+    inline TagResourceRequest& AddTags(Aws::String&& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>The list of tags to associate with the resource. Tag key names cannot start
+     * with "aws".</p>
+     */
+    inline TagResourceRequest& AddTags(const Aws::String& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>The list of tags to associate with the resource. Tag key names cannot start
+     * with "aws".</p>
+     */
+    inline TagResourceRequest& AddTags(Aws::String&& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>The list of tags to associate with the resource. Tag key names cannot start
+     * with "aws".</p>
+     */
+    inline TagResourceRequest& AddTags(const char* key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>The list of tags to associate with the resource. Tag key names cannot start
+     * with "aws".</p>
+     */
+    inline TagResourceRequest& AddTags(Aws::String&& key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>The list of tags to associate with the resource. Tag key names cannot start
+     * with "aws".</p>
+     */
+    inline TagResourceRequest& AddTags(const char* key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+
+    Aws::Map<Aws::String, Aws::String> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/TagResourceResult.h

@@ -0,0 +1,103 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSMap.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 CodeStarNotifications
+{
+namespace Model
+{
+  class AWS_CODESTARNOTIFICATIONS_API TagResourceResult
+  {
+  public:
+    TagResourceResult();
+    TagResourceResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    TagResourceResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The list of tags associated with the resource.</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>The list of tags associated with the resource.</p>
+     */
+    inline void SetTags(const Aws::Map<Aws::String, Aws::String>& value) { m_tags = value; }
+
+    /**
+     * <p>The list of tags associated with the resource.</p>
+     */
+    inline void SetTags(Aws::Map<Aws::String, Aws::String>&& value) { m_tags = std::move(value); }
+
+    /**
+     * <p>The list of tags associated with the resource.</p>
+     */
+    inline TagResourceResult& WithTags(const Aws::Map<Aws::String, Aws::String>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>The list of tags associated with the resource.</p>
+     */
+    inline TagResourceResult& WithTags(Aws::Map<Aws::String, Aws::String>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>The list of tags associated with the resource.</p>
+     */
+    inline TagResourceResult& AddTags(const Aws::String& key, const Aws::String& value) { m_tags.emplace(key, value); return *this; }
+
+    /**
+     * <p>The list of tags associated with the resource.</p>
+     */
+    inline TagResourceResult& AddTags(Aws::String&& key, const Aws::String& value) { m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>The list of tags associated with the resource.</p>
+     */
+    inline TagResourceResult& AddTags(const Aws::String& key, Aws::String&& value) { m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>The list of tags associated with the resource.</p>
+     */
+    inline TagResourceResult& AddTags(Aws::String&& key, Aws::String&& value) { m_tags.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>The list of tags associated with the resource.</p>
+     */
+    inline TagResourceResult& AddTags(const char* key, Aws::String&& value) { m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>The list of tags associated with the resource.</p>
+     */
+    inline TagResourceResult& AddTags(Aws::String&& key, const char* value) { m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>The list of tags associated with the resource.</p>
+     */
+    inline TagResourceResult& AddTags(const char* key, const char* value) { m_tags.emplace(key, value); return *this; }
+
+  private:
+
+    Aws::Map<Aws::String, Aws::String> m_tags;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/Target.h

@@ -0,0 +1,133 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_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 CodeStarNotifications
+{
+namespace Model
+{
+
+  /**
+   * <p>Information about the SNS topics associated with a notification
+   * rule.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/Target">AWS
+   * API Reference</a></p>
+   */
+  class AWS_CODESTARNOTIFICATIONS_API Target
+  {
+  public:
+    Target();
+    Target(Aws::Utils::Json::JsonView jsonValue);
+    Target& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The target type. Can be an Amazon SNS topic.</p>
+     */
+    inline const Aws::String& GetTargetType() const{ return m_targetType; }
+
+    /**
+     * <p>The target type. Can be an Amazon SNS topic.</p>
+     */
+    inline bool TargetTypeHasBeenSet() const { return m_targetTypeHasBeenSet; }
+
+    /**
+     * <p>The target type. Can be an Amazon SNS topic.</p>
+     */
+    inline void SetTargetType(const Aws::String& value) { m_targetTypeHasBeenSet = true; m_targetType = value; }
+
+    /**
+     * <p>The target type. Can be an Amazon SNS topic.</p>
+     */
+    inline void SetTargetType(Aws::String&& value) { m_targetTypeHasBeenSet = true; m_targetType = std::move(value); }
+
+    /**
+     * <p>The target type. Can be an Amazon SNS topic.</p>
+     */
+    inline void SetTargetType(const char* value) { m_targetTypeHasBeenSet = true; m_targetType.assign(value); }
+
+    /**
+     * <p>The target type. Can be an Amazon SNS topic.</p>
+     */
+    inline Target& WithTargetType(const Aws::String& value) { SetTargetType(value); return *this;}
+
+    /**
+     * <p>The target type. Can be an Amazon SNS topic.</p>
+     */
+    inline Target& WithTargetType(Aws::String&& value) { SetTargetType(std::move(value)); return *this;}
+
+    /**
+     * <p>The target type. Can be an Amazon SNS topic.</p>
+     */
+    inline Target& WithTargetType(const char* value) { SetTargetType(value); return *this;}
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic.</p>
+     */
+    inline const Aws::String& GetTargetAddress() const{ return m_targetAddress; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic.</p>
+     */
+    inline bool TargetAddressHasBeenSet() const { return m_targetAddressHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic.</p>
+     */
+    inline void SetTargetAddress(const Aws::String& value) { m_targetAddressHasBeenSet = true; m_targetAddress = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic.</p>
+     */
+    inline void SetTargetAddress(Aws::String&& value) { m_targetAddressHasBeenSet = true; m_targetAddress = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic.</p>
+     */
+    inline void SetTargetAddress(const char* value) { m_targetAddressHasBeenSet = true; m_targetAddress.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic.</p>
+     */
+    inline Target& WithTargetAddress(const Aws::String& value) { SetTargetAddress(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic.</p>
+     */
+    inline Target& WithTargetAddress(Aws::String&& value) { SetTargetAddress(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic.</p>
+     */
+    inline Target& WithTargetAddress(const char* value) { SetTargetAddress(value); return *this;}
+
+  private:
+
+    Aws::String m_targetType;
+    bool m_targetTypeHasBeenSet;
+
+    Aws::String m_targetAddress;
+    bool m_targetAddressHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/TargetStatus.h

@@ -0,0 +1,34 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace CodeStarNotifications
+{
+namespace Model
+{
+  enum class TargetStatus
+  {
+    NOT_SET,
+    PENDING,
+    ACTIVE,
+    UNREACHABLE,
+    INACTIVE,
+    DEACTIVATED
+  };
+
+namespace TargetStatusMapper
+{
+AWS_CODESTARNOTIFICATIONS_API TargetStatus GetTargetStatusForName(const Aws::String& name);
+
+AWS_CODESTARNOTIFICATIONS_API Aws::String GetNameForTargetStatus(TargetStatus value);
+} // namespace TargetStatusMapper
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/TargetSummary.h

@@ -0,0 +1,168 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/codestar-notifications/model/TargetStatus.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace CodeStarNotifications
+{
+namespace Model
+{
+
+  /**
+   * <p>Information about the targets specified for a notification
+   * rule.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/codestar-notifications-2019-10-15/TargetSummary">AWS
+   * API Reference</a></p>
+   */
+  class AWS_CODESTARNOTIFICATIONS_API TargetSummary
+  {
+  public:
+    TargetSummary();
+    TargetSummary(Aws::Utils::Json::JsonView jsonValue);
+    TargetSummary& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic.</p>
+     */
+    inline const Aws::String& GetTargetAddress() const{ return m_targetAddress; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic.</p>
+     */
+    inline bool TargetAddressHasBeenSet() const { return m_targetAddressHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic.</p>
+     */
+    inline void SetTargetAddress(const Aws::String& value) { m_targetAddressHasBeenSet = true; m_targetAddress = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic.</p>
+     */
+    inline void SetTargetAddress(Aws::String&& value) { m_targetAddressHasBeenSet = true; m_targetAddress = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic.</p>
+     */
+    inline void SetTargetAddress(const char* value) { m_targetAddressHasBeenSet = true; m_targetAddress.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic.</p>
+     */
+    inline TargetSummary& WithTargetAddress(const Aws::String& value) { SetTargetAddress(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic.</p>
+     */
+    inline TargetSummary& WithTargetAddress(Aws::String&& value) { SetTargetAddress(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SNS topic.</p>
+     */
+    inline TargetSummary& WithTargetAddress(const char* value) { SetTargetAddress(value); return *this;}
+
+
+    /**
+     * <p>The type of the target (for example, SNS).</p>
+     */
+    inline const Aws::String& GetTargetType() const{ return m_targetType; }
+
+    /**
+     * <p>The type of the target (for example, SNS).</p>
+     */
+    inline bool TargetTypeHasBeenSet() const { return m_targetTypeHasBeenSet; }
+
+    /**
+     * <p>The type of the target (for example, SNS).</p>
+     */
+    inline void SetTargetType(const Aws::String& value) { m_targetTypeHasBeenSet = true; m_targetType = value; }
+
+    /**
+     * <p>The type of the target (for example, SNS).</p>
+     */
+    inline void SetTargetType(Aws::String&& value) { m_targetTypeHasBeenSet = true; m_targetType = std::move(value); }
+
+    /**
+     * <p>The type of the target (for example, SNS).</p>
+     */
+    inline void SetTargetType(const char* value) { m_targetTypeHasBeenSet = true; m_targetType.assign(value); }
+
+    /**
+     * <p>The type of the target (for example, SNS).</p>
+     */
+    inline TargetSummary& WithTargetType(const Aws::String& value) { SetTargetType(value); return *this;}
+
+    /**
+     * <p>The type of the target (for example, SNS).</p>
+     */
+    inline TargetSummary& WithTargetType(Aws::String&& value) { SetTargetType(std::move(value)); return *this;}
+
+    /**
+     * <p>The type of the target (for example, SNS).</p>
+     */
+    inline TargetSummary& WithTargetType(const char* value) { SetTargetType(value); return *this;}
+
+
+    /**
+     * <p>The status of the target.</p>
+     */
+    inline const TargetStatus& GetTargetStatus() const{ return m_targetStatus; }
+
+    /**
+     * <p>The status of the target.</p>
+     */
+    inline bool TargetStatusHasBeenSet() const { return m_targetStatusHasBeenSet; }
+
+    /**
+     * <p>The status of the target.</p>
+     */
+    inline void SetTargetStatus(const TargetStatus& value) { m_targetStatusHasBeenSet = true; m_targetStatus = value; }
+
+    /**
+     * <p>The status of the target.</p>
+     */
+    inline void SetTargetStatus(TargetStatus&& value) { m_targetStatusHasBeenSet = true; m_targetStatus = std::move(value); }
+
+    /**
+     * <p>The status of the target.</p>
+     */
+    inline TargetSummary& WithTargetStatus(const TargetStatus& value) { SetTargetStatus(value); return *this;}
+
+    /**
+     * <p>The status of the target.</p>
+     */
+    inline TargetSummary& WithTargetStatus(TargetStatus&& value) { SetTargetStatus(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_targetAddress;
+    bool m_targetAddressHasBeenSet;
+
+    Aws::String m_targetType;
+    bool m_targetTypeHasBeenSet;
+
+    TargetStatus m_targetStatus;
+    bool m_targetStatusHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/UnsubscribeRequest.h

@@ -0,0 +1,127 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/codestar-notifications/CodeStarNotificationsRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace CodeStarNotifications
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_CODESTARNOTIFICATIONS_API UnsubscribeRequest : public CodeStarNotificationsRequest
+  {
+  public:
+    UnsubscribeRequest();
+
+    // 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 "Unsubscribe"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline UnsubscribeRequest& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline UnsubscribeRequest& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline UnsubscribeRequest& WithArn(const char* value) { SetArn(value); return *this;}
+
+
+    /**
+     * <p>The ARN of the SNS topic to unsubscribe from the notification rule.</p>
+     */
+    inline const Aws::String& GetTargetAddress() const{ return m_targetAddress; }
+
+    /**
+     * <p>The ARN of the SNS topic to unsubscribe from the notification rule.</p>
+     */
+    inline bool TargetAddressHasBeenSet() const { return m_targetAddressHasBeenSet; }
+
+    /**
+     * <p>The ARN of the SNS topic to unsubscribe from the notification rule.</p>
+     */
+    inline void SetTargetAddress(const Aws::String& value) { m_targetAddressHasBeenSet = true; m_targetAddress = value; }
+
+    /**
+     * <p>The ARN of the SNS topic to unsubscribe from the notification rule.</p>
+     */
+    inline void SetTargetAddress(Aws::String&& value) { m_targetAddressHasBeenSet = true; m_targetAddress = std::move(value); }
+
+    /**
+     * <p>The ARN of the SNS topic to unsubscribe from the notification rule.</p>
+     */
+    inline void SetTargetAddress(const char* value) { m_targetAddressHasBeenSet = true; m_targetAddress.assign(value); }
+
+    /**
+     * <p>The ARN of the SNS topic to unsubscribe from the notification rule.</p>
+     */
+    inline UnsubscribeRequest& WithTargetAddress(const Aws::String& value) { SetTargetAddress(value); return *this;}
+
+    /**
+     * <p>The ARN of the SNS topic to unsubscribe from the notification rule.</p>
+     */
+    inline UnsubscribeRequest& WithTargetAddress(Aws::String&& value) { SetTargetAddress(std::move(value)); return *this;}
+
+    /**
+     * <p>The ARN of the SNS topic to unsubscribe from the notification rule.</p>
+     */
+    inline UnsubscribeRequest& WithTargetAddress(const char* value) { SetTargetAddress(value); return *this;}
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+
+    Aws::String m_targetAddress;
+    bool m_targetAddressHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/UnsubscribeResult.h

@@ -0,0 +1,84 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_EXPORTS.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 CodeStarNotifications
+{
+namespace Model
+{
+  class AWS_CODESTARNOTIFICATIONS_API UnsubscribeResult
+  {
+  public:
+    UnsubscribeResult();
+    UnsubscribeResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    UnsubscribeResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the the notification rule from which you
+     * have removed a subscription.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the the notification rule from which you
+     * have removed a subscription.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the the notification rule from which you
+     * have removed a subscription.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the the notification rule from which you
+     * have removed a subscription.</p>
+     */
+    inline void SetArn(const char* value) { m_arn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the the notification rule from which you
+     * have removed a subscription.</p>
+     */
+    inline UnsubscribeResult& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the the notification rule from which you
+     * have removed a subscription.</p>
+     */
+    inline UnsubscribeResult& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the the notification rule from which you
+     * have removed a subscription.</p>
+     */
+    inline UnsubscribeResult& WithArn(const char* value) { SetArn(value); return *this;}
+
+  private:
+
+    Aws::String m_arn;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/UntagResourceRequest.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/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/codestar-notifications/CodeStarNotificationsRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <utility>
+
+namespace Aws
+{
+namespace CodeStarNotifications
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_CODESTARNOTIFICATIONS_API UntagResourceRequest : public CodeStarNotificationsRequest
+  {
+  public:
+    UntagResourceRequest();
+
+    // 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 "UntagResource"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule from which to remove
+     * the tags.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule from which to remove
+     * the tags.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule from which to remove
+     * the tags.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule from which to remove
+     * the tags.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule from which to remove
+     * the tags.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule from which to remove
+     * the tags.</p>
+     */
+    inline UntagResourceRequest& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule from which to remove
+     * the tags.</p>
+     */
+    inline UntagResourceRequest& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule from which to remove
+     * the tags.</p>
+     */
+    inline UntagResourceRequest& WithArn(const char* value) { SetArn(value); return *this;}
+
+
+    /**
+     * <p>The key names of the tags to remove.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetTagKeys() const{ return m_tagKeys; }
+
+    /**
+     * <p>The key names of the tags to remove.</p>
+     */
+    inline bool TagKeysHasBeenSet() const { return m_tagKeysHasBeenSet; }
+
+    /**
+     * <p>The key names of the tags to remove.</p>
+     */
+    inline void SetTagKeys(const Aws::Vector<Aws::String>& value) { m_tagKeysHasBeenSet = true; m_tagKeys = value; }
+
+    /**
+     * <p>The key names of the tags to remove.</p>
+     */
+    inline void SetTagKeys(Aws::Vector<Aws::String>&& value) { m_tagKeysHasBeenSet = true; m_tagKeys = std::move(value); }
+
+    /**
+     * <p>The key names of the tags to remove.</p>
+     */
+    inline UntagResourceRequest& WithTagKeys(const Aws::Vector<Aws::String>& value) { SetTagKeys(value); return *this;}
+
+    /**
+     * <p>The key names of the tags to remove.</p>
+     */
+    inline UntagResourceRequest& WithTagKeys(Aws::Vector<Aws::String>&& value) { SetTagKeys(std::move(value)); return *this;}
+
+    /**
+     * <p>The key names of the tags to remove.</p>
+     */
+    inline UntagResourceRequest& AddTagKeys(const Aws::String& value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(value); return *this; }
+
+    /**
+     * <p>The key names of the tags to remove.</p>
+     */
+    inline UntagResourceRequest& AddTagKeys(Aws::String&& value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>The key names of the tags to remove.</p>
+     */
+    inline UntagResourceRequest& AddTagKeys(const char* value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(value); return *this; }
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+
+    Aws::Vector<Aws::String> m_tagKeys;
+    bool m_tagKeysHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/UntagResourceResult.h

@@ -0,0 +1,36 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace CodeStarNotifications
+{
+namespace Model
+{
+  class AWS_CODESTARNOTIFICATIONS_API UntagResourceResult
+  {
+  public:
+    UntagResourceResult();
+    UntagResourceResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    UntagResourceResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/UpdateNotificationRuleRequest.h

@@ -0,0 +1,330 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+#include <aws/codestar-notifications/CodeStarNotificationsRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/codestar-notifications/model/NotificationRuleStatus.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/codestar-notifications/model/DetailType.h>
+#include <aws/codestar-notifications/model/Target.h>
+#include <utility>
+
+namespace Aws
+{
+namespace CodeStarNotifications
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_CODESTARNOTIFICATIONS_API UpdateNotificationRuleRequest : public CodeStarNotificationsRequest
+  {
+  public:
+    UpdateNotificationRuleRequest();
+
+    // 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 "UpdateNotificationRule"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline UpdateNotificationRuleRequest& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline UpdateNotificationRuleRequest& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the notification rule.</p>
+     */
+    inline UpdateNotificationRuleRequest& WithArn(const char* value) { SetArn(value); return *this;}
+
+
+    /**
+     * <p>The name of the notification rule.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>The name of the notification rule.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>The name of the notification rule.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>The name of the notification rule.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>The name of the notification rule.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>The name of the notification rule.</p>
+     */
+    inline UpdateNotificationRuleRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>The name of the notification rule.</p>
+     */
+    inline UpdateNotificationRuleRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the notification rule.</p>
+     */
+    inline UpdateNotificationRuleRequest& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>The status of the notification rule. Valid statuses include enabled (sending
+     * notifications) or disabled (not sending notifications).</p>
+     */
+    inline const NotificationRuleStatus& GetStatus() const{ return m_status; }
+
+    /**
+     * <p>The status of the notification rule. Valid statuses include enabled (sending
+     * notifications) or disabled (not sending notifications).</p>
+     */
+    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
+
+    /**
+     * <p>The status of the notification rule. Valid statuses include enabled (sending
+     * notifications) or disabled (not sending notifications).</p>
+     */
+    inline void SetStatus(const NotificationRuleStatus& value) { m_statusHasBeenSet = true; m_status = value; }
+
+    /**
+     * <p>The status of the notification rule. Valid statuses include enabled (sending
+     * notifications) or disabled (not sending notifications).</p>
+     */
+    inline void SetStatus(NotificationRuleStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
+
+    /**
+     * <p>The status of the notification rule. Valid statuses include enabled (sending
+     * notifications) or disabled (not sending notifications).</p>
+     */
+    inline UpdateNotificationRuleRequest& WithStatus(const NotificationRuleStatus& value) { SetStatus(value); return *this;}
+
+    /**
+     * <p>The status of the notification rule. Valid statuses include enabled (sending
+     * notifications) or disabled (not sending notifications).</p>
+     */
+    inline UpdateNotificationRuleRequest& WithStatus(NotificationRuleStatus&& value) { SetStatus(std::move(value)); return *this;}
+
+
+    /**
+     * <p>A list of event types associated with this notification rule.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetEventTypeIds() const{ return m_eventTypeIds; }
+
+    /**
+     * <p>A list of event types associated with this notification rule.</p>
+     */
+    inline bool EventTypeIdsHasBeenSet() const { return m_eventTypeIdsHasBeenSet; }
+
+    /**
+     * <p>A list of event types associated with this notification rule.</p>
+     */
+    inline void SetEventTypeIds(const Aws::Vector<Aws::String>& value) { m_eventTypeIdsHasBeenSet = true; m_eventTypeIds = value; }
+
+    /**
+     * <p>A list of event types associated with this notification rule.</p>
+     */
+    inline void SetEventTypeIds(Aws::Vector<Aws::String>&& value) { m_eventTypeIdsHasBeenSet = true; m_eventTypeIds = std::move(value); }
+
+    /**
+     * <p>A list of event types associated with this notification rule.</p>
+     */
+    inline UpdateNotificationRuleRequest& WithEventTypeIds(const Aws::Vector<Aws::String>& value) { SetEventTypeIds(value); return *this;}
+
+    /**
+     * <p>A list of event types associated with this notification rule.</p>
+     */
+    inline UpdateNotificationRuleRequest& WithEventTypeIds(Aws::Vector<Aws::String>&& value) { SetEventTypeIds(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of event types associated with this notification rule.</p>
+     */
+    inline UpdateNotificationRuleRequest& AddEventTypeIds(const Aws::String& value) { m_eventTypeIdsHasBeenSet = true; m_eventTypeIds.push_back(value); return *this; }
+
+    /**
+     * <p>A list of event types associated with this notification rule.</p>
+     */
+    inline UpdateNotificationRuleRequest& AddEventTypeIds(Aws::String&& value) { m_eventTypeIdsHasBeenSet = true; m_eventTypeIds.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A list of event types associated with this notification rule.</p>
+     */
+    inline UpdateNotificationRuleRequest& AddEventTypeIds(const char* value) { m_eventTypeIdsHasBeenSet = true; m_eventTypeIds.push_back(value); return *this; }
+
+
+    /**
+     * <p>The address and type of the targets to receive notifications from this
+     * notification rule.</p>
+     */
+    inline const Aws::Vector<Target>& GetTargets() const{ return m_targets; }
+
+    /**
+     * <p>The address and type of the targets to receive notifications from this
+     * notification rule.</p>
+     */
+    inline bool TargetsHasBeenSet() const { return m_targetsHasBeenSet; }
+
+    /**
+     * <p>The address and type of the targets to receive notifications from this
+     * notification rule.</p>
+     */
+    inline void SetTargets(const Aws::Vector<Target>& value) { m_targetsHasBeenSet = true; m_targets = value; }
+
+    /**
+     * <p>The address and type of the targets to receive notifications from this
+     * notification rule.</p>
+     */
+    inline void SetTargets(Aws::Vector<Target>&& value) { m_targetsHasBeenSet = true; m_targets = std::move(value); }
+
+    /**
+     * <p>The address and type of the targets to receive notifications from this
+     * notification rule.</p>
+     */
+    inline UpdateNotificationRuleRequest& WithTargets(const Aws::Vector<Target>& value) { SetTargets(value); return *this;}
+
+    /**
+     * <p>The address and type of the targets to receive notifications from this
+     * notification rule.</p>
+     */
+    inline UpdateNotificationRuleRequest& WithTargets(Aws::Vector<Target>&& value) { SetTargets(std::move(value)); return *this;}
+
+    /**
+     * <p>The address and type of the targets to receive notifications from this
+     * notification rule.</p>
+     */
+    inline UpdateNotificationRuleRequest& AddTargets(const Target& value) { m_targetsHasBeenSet = true; m_targets.push_back(value); return *this; }
+
+    /**
+     * <p>The address and type of the targets to receive notifications from this
+     * notification rule.</p>
+     */
+    inline UpdateNotificationRuleRequest& AddTargets(Target&& value) { m_targetsHasBeenSet = true; m_targets.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>The level of detail to include in the notifications for this resource. BASIC
+     * will include only the contents of the event as it would appear in AWS
+     * CloudWatch. FULL will include any supplemental information provided by AWS
+     * CodeStar Notifications and/or the service for the resource for which the
+     * notification is created.</p>
+     */
+    inline const DetailType& GetDetailType() const{ return m_detailType; }
+
+    /**
+     * <p>The level of detail to include in the notifications for this resource. BASIC
+     * will include only the contents of the event as it would appear in AWS
+     * CloudWatch. FULL will include any supplemental information provided by AWS
+     * CodeStar Notifications and/or the service for the resource for which the
+     * notification is created.</p>
+     */
+    inline bool DetailTypeHasBeenSet() const { return m_detailTypeHasBeenSet; }
+
+    /**
+     * <p>The level of detail to include in the notifications for this resource. BASIC
+     * will include only the contents of the event as it would appear in AWS
+     * CloudWatch. FULL will include any supplemental information provided by AWS
+     * CodeStar Notifications and/or the service for the resource for which the
+     * notification is created.</p>
+     */
+    inline void SetDetailType(const DetailType& value) { m_detailTypeHasBeenSet = true; m_detailType = value; }
+
+    /**
+     * <p>The level of detail to include in the notifications for this resource. BASIC
+     * will include only the contents of the event as it would appear in AWS
+     * CloudWatch. FULL will include any supplemental information provided by AWS
+     * CodeStar Notifications and/or the service for the resource for which the
+     * notification is created.</p>
+     */
+    inline void SetDetailType(DetailType&& value) { m_detailTypeHasBeenSet = true; m_detailType = std::move(value); }
+
+    /**
+     * <p>The level of detail to include in the notifications for this resource. BASIC
+     * will include only the contents of the event as it would appear in AWS
+     * CloudWatch. FULL will include any supplemental information provided by AWS
+     * CodeStar Notifications and/or the service for the resource for which the
+     * notification is created.</p>
+     */
+    inline UpdateNotificationRuleRequest& WithDetailType(const DetailType& value) { SetDetailType(value); return *this;}
+
+    /**
+     * <p>The level of detail to include in the notifications for this resource. BASIC
+     * will include only the contents of the event as it would appear in AWS
+     * CloudWatch. FULL will include any supplemental information provided by AWS
+     * CodeStar Notifications and/or the service for the resource for which the
+     * notification is created.</p>
+     */
+    inline UpdateNotificationRuleRequest& WithDetailType(DetailType&& value) { SetDetailType(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    NotificationRuleStatus m_status;
+    bool m_statusHasBeenSet;
+
+    Aws::Vector<Aws::String> m_eventTypeIds;
+    bool m_eventTypeIdsHasBeenSet;
+
+    Aws::Vector<Target> m_targets;
+    bool m_targetsHasBeenSet;
+
+    DetailType m_detailType;
+    bool m_detailTypeHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/model/UpdateNotificationRuleResult.h

@@ -0,0 +1,36 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/codestar-notifications/CodeStarNotifications_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace CodeStarNotifications
+{
+namespace Model
+{
+  class AWS_CODESTARNOTIFICATIONS_API UpdateNotificationRuleResult
+  {
+  public:
+    UpdateNotificationRuleResult();
+    UpdateNotificationRuleResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    UpdateNotificationRuleResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+  };
+
+} // namespace Model
+} // namespace CodeStarNotifications
+} // namespace Aws