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

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/MediaStoreClient.h

@@ -0,0 +1,984 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/MediaStoreErrors.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/mediastore/model/CreateContainerResult.h>
+#include <aws/mediastore/model/DeleteContainerResult.h>
+#include <aws/mediastore/model/DeleteContainerPolicyResult.h>
+#include <aws/mediastore/model/DeleteCorsPolicyResult.h>
+#include <aws/mediastore/model/DeleteLifecyclePolicyResult.h>
+#include <aws/mediastore/model/DeleteMetricPolicyResult.h>
+#include <aws/mediastore/model/DescribeContainerResult.h>
+#include <aws/mediastore/model/GetContainerPolicyResult.h>
+#include <aws/mediastore/model/GetCorsPolicyResult.h>
+#include <aws/mediastore/model/GetLifecyclePolicyResult.h>
+#include <aws/mediastore/model/GetMetricPolicyResult.h>
+#include <aws/mediastore/model/ListContainersResult.h>
+#include <aws/mediastore/model/ListTagsForResourceResult.h>
+#include <aws/mediastore/model/PutContainerPolicyResult.h>
+#include <aws/mediastore/model/PutCorsPolicyResult.h>
+#include <aws/mediastore/model/PutLifecyclePolicyResult.h>
+#include <aws/mediastore/model/PutMetricPolicyResult.h>
+#include <aws/mediastore/model/StartAccessLoggingResult.h>
+#include <aws/mediastore/model/StopAccessLoggingResult.h>
+#include <aws/mediastore/model/TagResourceResult.h>
+#include <aws/mediastore/model/UntagResourceResult.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 MediaStore
+{
+
+namespace Model
+{
+        class CreateContainerRequest;
+        class DeleteContainerRequest;
+        class DeleteContainerPolicyRequest;
+        class DeleteCorsPolicyRequest;
+        class DeleteLifecyclePolicyRequest;
+        class DeleteMetricPolicyRequest;
+        class DescribeContainerRequest;
+        class GetContainerPolicyRequest;
+        class GetCorsPolicyRequest;
+        class GetLifecyclePolicyRequest;
+        class GetMetricPolicyRequest;
+        class ListContainersRequest;
+        class ListTagsForResourceRequest;
+        class PutContainerPolicyRequest;
+        class PutCorsPolicyRequest;
+        class PutLifecyclePolicyRequest;
+        class PutMetricPolicyRequest;
+        class StartAccessLoggingRequest;
+        class StopAccessLoggingRequest;
+        class TagResourceRequest;
+        class UntagResourceRequest;
+
+        typedef Aws::Utils::Outcome<CreateContainerResult, MediaStoreError> CreateContainerOutcome;
+        typedef Aws::Utils::Outcome<DeleteContainerResult, MediaStoreError> DeleteContainerOutcome;
+        typedef Aws::Utils::Outcome<DeleteContainerPolicyResult, MediaStoreError> DeleteContainerPolicyOutcome;
+        typedef Aws::Utils::Outcome<DeleteCorsPolicyResult, MediaStoreError> DeleteCorsPolicyOutcome;
+        typedef Aws::Utils::Outcome<DeleteLifecyclePolicyResult, MediaStoreError> DeleteLifecyclePolicyOutcome;
+        typedef Aws::Utils::Outcome<DeleteMetricPolicyResult, MediaStoreError> DeleteMetricPolicyOutcome;
+        typedef Aws::Utils::Outcome<DescribeContainerResult, MediaStoreError> DescribeContainerOutcome;
+        typedef Aws::Utils::Outcome<GetContainerPolicyResult, MediaStoreError> GetContainerPolicyOutcome;
+        typedef Aws::Utils::Outcome<GetCorsPolicyResult, MediaStoreError> GetCorsPolicyOutcome;
+        typedef Aws::Utils::Outcome<GetLifecyclePolicyResult, MediaStoreError> GetLifecyclePolicyOutcome;
+        typedef Aws::Utils::Outcome<GetMetricPolicyResult, MediaStoreError> GetMetricPolicyOutcome;
+        typedef Aws::Utils::Outcome<ListContainersResult, MediaStoreError> ListContainersOutcome;
+        typedef Aws::Utils::Outcome<ListTagsForResourceResult, MediaStoreError> ListTagsForResourceOutcome;
+        typedef Aws::Utils::Outcome<PutContainerPolicyResult, MediaStoreError> PutContainerPolicyOutcome;
+        typedef Aws::Utils::Outcome<PutCorsPolicyResult, MediaStoreError> PutCorsPolicyOutcome;
+        typedef Aws::Utils::Outcome<PutLifecyclePolicyResult, MediaStoreError> PutLifecyclePolicyOutcome;
+        typedef Aws::Utils::Outcome<PutMetricPolicyResult, MediaStoreError> PutMetricPolicyOutcome;
+        typedef Aws::Utils::Outcome<StartAccessLoggingResult, MediaStoreError> StartAccessLoggingOutcome;
+        typedef Aws::Utils::Outcome<StopAccessLoggingResult, MediaStoreError> StopAccessLoggingOutcome;
+        typedef Aws::Utils::Outcome<TagResourceResult, MediaStoreError> TagResourceOutcome;
+        typedef Aws::Utils::Outcome<UntagResourceResult, MediaStoreError> UntagResourceOutcome;
+
+        typedef std::future<CreateContainerOutcome> CreateContainerOutcomeCallable;
+        typedef std::future<DeleteContainerOutcome> DeleteContainerOutcomeCallable;
+        typedef std::future<DeleteContainerPolicyOutcome> DeleteContainerPolicyOutcomeCallable;
+        typedef std::future<DeleteCorsPolicyOutcome> DeleteCorsPolicyOutcomeCallable;
+        typedef std::future<DeleteLifecyclePolicyOutcome> DeleteLifecyclePolicyOutcomeCallable;
+        typedef std::future<DeleteMetricPolicyOutcome> DeleteMetricPolicyOutcomeCallable;
+        typedef std::future<DescribeContainerOutcome> DescribeContainerOutcomeCallable;
+        typedef std::future<GetContainerPolicyOutcome> GetContainerPolicyOutcomeCallable;
+        typedef std::future<GetCorsPolicyOutcome> GetCorsPolicyOutcomeCallable;
+        typedef std::future<GetLifecyclePolicyOutcome> GetLifecyclePolicyOutcomeCallable;
+        typedef std::future<GetMetricPolicyOutcome> GetMetricPolicyOutcomeCallable;
+        typedef std::future<ListContainersOutcome> ListContainersOutcomeCallable;
+        typedef std::future<ListTagsForResourceOutcome> ListTagsForResourceOutcomeCallable;
+        typedef std::future<PutContainerPolicyOutcome> PutContainerPolicyOutcomeCallable;
+        typedef std::future<PutCorsPolicyOutcome> PutCorsPolicyOutcomeCallable;
+        typedef std::future<PutLifecyclePolicyOutcome> PutLifecyclePolicyOutcomeCallable;
+        typedef std::future<PutMetricPolicyOutcome> PutMetricPolicyOutcomeCallable;
+        typedef std::future<StartAccessLoggingOutcome> StartAccessLoggingOutcomeCallable;
+        typedef std::future<StopAccessLoggingOutcome> StopAccessLoggingOutcomeCallable;
+        typedef std::future<TagResourceOutcome> TagResourceOutcomeCallable;
+        typedef std::future<UntagResourceOutcome> UntagResourceOutcomeCallable;
+} // namespace Model
+
+  class MediaStoreClient;
+
+    typedef std::function<void(const MediaStoreClient*, const Model::CreateContainerRequest&, const Model::CreateContainerOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateContainerResponseReceivedHandler;
+    typedef std::function<void(const MediaStoreClient*, const Model::DeleteContainerRequest&, const Model::DeleteContainerOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteContainerResponseReceivedHandler;
+    typedef std::function<void(const MediaStoreClient*, const Model::DeleteContainerPolicyRequest&, const Model::DeleteContainerPolicyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteContainerPolicyResponseReceivedHandler;
+    typedef std::function<void(const MediaStoreClient*, const Model::DeleteCorsPolicyRequest&, const Model::DeleteCorsPolicyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteCorsPolicyResponseReceivedHandler;
+    typedef std::function<void(const MediaStoreClient*, const Model::DeleteLifecyclePolicyRequest&, const Model::DeleteLifecyclePolicyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteLifecyclePolicyResponseReceivedHandler;
+    typedef std::function<void(const MediaStoreClient*, const Model::DeleteMetricPolicyRequest&, const Model::DeleteMetricPolicyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteMetricPolicyResponseReceivedHandler;
+    typedef std::function<void(const MediaStoreClient*, const Model::DescribeContainerRequest&, const Model::DescribeContainerOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeContainerResponseReceivedHandler;
+    typedef std::function<void(const MediaStoreClient*, const Model::GetContainerPolicyRequest&, const Model::GetContainerPolicyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetContainerPolicyResponseReceivedHandler;
+    typedef std::function<void(const MediaStoreClient*, const Model::GetCorsPolicyRequest&, const Model::GetCorsPolicyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetCorsPolicyResponseReceivedHandler;
+    typedef std::function<void(const MediaStoreClient*, const Model::GetLifecyclePolicyRequest&, const Model::GetLifecyclePolicyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetLifecyclePolicyResponseReceivedHandler;
+    typedef std::function<void(const MediaStoreClient*, const Model::GetMetricPolicyRequest&, const Model::GetMetricPolicyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetMetricPolicyResponseReceivedHandler;
+    typedef std::function<void(const MediaStoreClient*, const Model::ListContainersRequest&, const Model::ListContainersOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListContainersResponseReceivedHandler;
+    typedef std::function<void(const MediaStoreClient*, const Model::ListTagsForResourceRequest&, const Model::ListTagsForResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTagsForResourceResponseReceivedHandler;
+    typedef std::function<void(const MediaStoreClient*, const Model::PutContainerPolicyRequest&, const Model::PutContainerPolicyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutContainerPolicyResponseReceivedHandler;
+    typedef std::function<void(const MediaStoreClient*, const Model::PutCorsPolicyRequest&, const Model::PutCorsPolicyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutCorsPolicyResponseReceivedHandler;
+    typedef std::function<void(const MediaStoreClient*, const Model::PutLifecyclePolicyRequest&, const Model::PutLifecyclePolicyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutLifecyclePolicyResponseReceivedHandler;
+    typedef std::function<void(const MediaStoreClient*, const Model::PutMetricPolicyRequest&, const Model::PutMetricPolicyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutMetricPolicyResponseReceivedHandler;
+    typedef std::function<void(const MediaStoreClient*, const Model::StartAccessLoggingRequest&, const Model::StartAccessLoggingOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StartAccessLoggingResponseReceivedHandler;
+    typedef std::function<void(const MediaStoreClient*, const Model::StopAccessLoggingRequest&, const Model::StopAccessLoggingOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StopAccessLoggingResponseReceivedHandler;
+    typedef std::function<void(const MediaStoreClient*, const Model::TagResourceRequest&, const Model::TagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > TagResourceResponseReceivedHandler;
+    typedef std::function<void(const MediaStoreClient*, const Model::UntagResourceRequest&, const Model::UntagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UntagResourceResponseReceivedHandler;
+
+  /**
+   * <p>An AWS Elemental MediaStore container is a namespace that holds folders and
+   * objects. You use a container endpoint to create, read, and delete objects. </p>
+   */
+  class AWS_MEDIASTORE_API MediaStoreClient : 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.
+        */
+        MediaStoreClient(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.
+        */
+        MediaStoreClient(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
+        */
+        MediaStoreClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
+            const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());
+
+        virtual ~MediaStoreClient();
+
+
+        /**
+         * <p>Creates a storage container to hold objects. A container is similar to a
+         * bucket in the Amazon S3 service.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/CreateContainer">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::CreateContainerOutcome CreateContainer(const Model::CreateContainerRequest& request) const;
+
+        /**
+         * <p>Creates a storage container to hold objects. A container is similar to a
+         * bucket in the Amazon S3 service.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/CreateContainer">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::CreateContainerOutcomeCallable CreateContainerCallable(const Model::CreateContainerRequest& request) const;
+
+        /**
+         * <p>Creates a storage container to hold objects. A container is similar to a
+         * bucket in the Amazon S3 service.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/CreateContainer">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void CreateContainerAsync(const Model::CreateContainerRequest& request, const CreateContainerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Deletes the specified container. Before you make a
+         * <code>DeleteContainer</code> request, delete any objects in the container or in
+         * any folders in the container. You can delete only empty containers.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/DeleteContainer">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DeleteContainerOutcome DeleteContainer(const Model::DeleteContainerRequest& request) const;
+
+        /**
+         * <p>Deletes the specified container. Before you make a
+         * <code>DeleteContainer</code> request, delete any objects in the container or in
+         * any folders in the container. You can delete only empty containers.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/DeleteContainer">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DeleteContainerOutcomeCallable DeleteContainerCallable(const Model::DeleteContainerRequest& request) const;
+
+        /**
+         * <p>Deletes the specified container. Before you make a
+         * <code>DeleteContainer</code> request, delete any objects in the container or in
+         * any folders in the container. You can delete only empty containers.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/DeleteContainer">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DeleteContainerAsync(const Model::DeleteContainerRequest& request, const DeleteContainerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Deletes the access policy that is associated with the specified
+         * container.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/DeleteContainerPolicy">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DeleteContainerPolicyOutcome DeleteContainerPolicy(const Model::DeleteContainerPolicyRequest& request) const;
+
+        /**
+         * <p>Deletes the access policy that is associated with the specified
+         * container.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/DeleteContainerPolicy">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DeleteContainerPolicyOutcomeCallable DeleteContainerPolicyCallable(const Model::DeleteContainerPolicyRequest& request) const;
+
+        /**
+         * <p>Deletes the access policy that is associated with the specified
+         * container.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/DeleteContainerPolicy">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DeleteContainerPolicyAsync(const Model::DeleteContainerPolicyRequest& request, const DeleteContainerPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Deletes the cross-origin resource sharing (CORS) configuration information
+         * that is set for the container.</p> <p>To use this operation, you must have
+         * permission to perform the <code>MediaStore:DeleteCorsPolicy</code> action. The
+         * container owner has this permission by default and can grant this permission to
+         * others.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/DeleteCorsPolicy">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DeleteCorsPolicyOutcome DeleteCorsPolicy(const Model::DeleteCorsPolicyRequest& request) const;
+
+        /**
+         * <p>Deletes the cross-origin resource sharing (CORS) configuration information
+         * that is set for the container.</p> <p>To use this operation, you must have
+         * permission to perform the <code>MediaStore:DeleteCorsPolicy</code> action. The
+         * container owner has this permission by default and can grant this permission to
+         * others.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/DeleteCorsPolicy">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DeleteCorsPolicyOutcomeCallable DeleteCorsPolicyCallable(const Model::DeleteCorsPolicyRequest& request) const;
+
+        /**
+         * <p>Deletes the cross-origin resource sharing (CORS) configuration information
+         * that is set for the container.</p> <p>To use this operation, you must have
+         * permission to perform the <code>MediaStore:DeleteCorsPolicy</code> action. The
+         * container owner has this permission by default and can grant this permission to
+         * others.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/DeleteCorsPolicy">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DeleteCorsPolicyAsync(const Model::DeleteCorsPolicyRequest& request, const DeleteCorsPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Removes an object lifecycle policy from a container. It takes up to 20
+         * minutes for the change to take effect.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/DeleteLifecyclePolicy">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DeleteLifecyclePolicyOutcome DeleteLifecyclePolicy(const Model::DeleteLifecyclePolicyRequest& request) const;
+
+        /**
+         * <p>Removes an object lifecycle policy from a container. It takes up to 20
+         * minutes for the change to take effect.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/DeleteLifecyclePolicy">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DeleteLifecyclePolicyOutcomeCallable DeleteLifecyclePolicyCallable(const Model::DeleteLifecyclePolicyRequest& request) const;
+
+        /**
+         * <p>Removes an object lifecycle policy from a container. It takes up to 20
+         * minutes for the change to take effect.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/DeleteLifecyclePolicy">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DeleteLifecyclePolicyAsync(const Model::DeleteLifecyclePolicyRequest& request, const DeleteLifecyclePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Deletes the metric policy that is associated with the specified container. If
+         * there is no metric policy associated with the container, MediaStore doesn't send
+         * metrics to CloudWatch.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/DeleteMetricPolicy">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DeleteMetricPolicyOutcome DeleteMetricPolicy(const Model::DeleteMetricPolicyRequest& request) const;
+
+        /**
+         * <p>Deletes the metric policy that is associated with the specified container. If
+         * there is no metric policy associated with the container, MediaStore doesn't send
+         * metrics to CloudWatch.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/DeleteMetricPolicy">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DeleteMetricPolicyOutcomeCallable DeleteMetricPolicyCallable(const Model::DeleteMetricPolicyRequest& request) const;
+
+        /**
+         * <p>Deletes the metric policy that is associated with the specified container. If
+         * there is no metric policy associated with the container, MediaStore doesn't send
+         * metrics to CloudWatch.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/DeleteMetricPolicy">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DeleteMetricPolicyAsync(const Model::DeleteMetricPolicyRequest& request, const DeleteMetricPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Retrieves the properties of the requested container. This request is commonly
+         * used to retrieve the endpoint of a container. An endpoint is a value assigned by
+         * the service when a new container is created. A container's endpoint does not
+         * change after it has been assigned. The <code>DescribeContainer</code> request
+         * returns a single <code>Container</code> object based on
+         * <code>ContainerName</code>. To return all <code>Container</code> objects that
+         * are associated with a specified AWS account, use
+         * <a>ListContainers</a>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/DescribeContainer">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DescribeContainerOutcome DescribeContainer(const Model::DescribeContainerRequest& request) const;
+
+        /**
+         * <p>Retrieves the properties of the requested container. This request is commonly
+         * used to retrieve the endpoint of a container. An endpoint is a value assigned by
+         * the service when a new container is created. A container's endpoint does not
+         * change after it has been assigned. The <code>DescribeContainer</code> request
+         * returns a single <code>Container</code> object based on
+         * <code>ContainerName</code>. To return all <code>Container</code> objects that
+         * are associated with a specified AWS account, use
+         * <a>ListContainers</a>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/DescribeContainer">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DescribeContainerOutcomeCallable DescribeContainerCallable(const Model::DescribeContainerRequest& request) const;
+
+        /**
+         * <p>Retrieves the properties of the requested container. This request is commonly
+         * used to retrieve the endpoint of a container. An endpoint is a value assigned by
+         * the service when a new container is created. A container's endpoint does not
+         * change after it has been assigned. The <code>DescribeContainer</code> request
+         * returns a single <code>Container</code> object based on
+         * <code>ContainerName</code>. To return all <code>Container</code> objects that
+         * are associated with a specified AWS account, use
+         * <a>ListContainers</a>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/DescribeContainer">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DescribeContainerAsync(const Model::DescribeContainerRequest& request, const DescribeContainerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Retrieves the access policy for the specified container. For information
+         * about the data that is included in an access policy, see the <a
+         * href="https://aws.amazon.com/documentation/iam/">AWS Identity and Access
+         * Management User Guide</a>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/GetContainerPolicy">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::GetContainerPolicyOutcome GetContainerPolicy(const Model::GetContainerPolicyRequest& request) const;
+
+        /**
+         * <p>Retrieves the access policy for the specified container. For information
+         * about the data that is included in an access policy, see the <a
+         * href="https://aws.amazon.com/documentation/iam/">AWS Identity and Access
+         * Management User Guide</a>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/GetContainerPolicy">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::GetContainerPolicyOutcomeCallable GetContainerPolicyCallable(const Model::GetContainerPolicyRequest& request) const;
+
+        /**
+         * <p>Retrieves the access policy for the specified container. For information
+         * about the data that is included in an access policy, see the <a
+         * href="https://aws.amazon.com/documentation/iam/">AWS Identity and Access
+         * Management User Guide</a>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/GetContainerPolicy">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void GetContainerPolicyAsync(const Model::GetContainerPolicyRequest& request, const GetContainerPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Returns the cross-origin resource sharing (CORS) configuration information
+         * that is set for the container.</p> <p>To use this operation, you must have
+         * permission to perform the <code>MediaStore:GetCorsPolicy</code> action. By
+         * default, the container owner has this permission and can grant it to
+         * others.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/GetCorsPolicy">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::GetCorsPolicyOutcome GetCorsPolicy(const Model::GetCorsPolicyRequest& request) const;
+
+        /**
+         * <p>Returns the cross-origin resource sharing (CORS) configuration information
+         * that is set for the container.</p> <p>To use this operation, you must have
+         * permission to perform the <code>MediaStore:GetCorsPolicy</code> action. By
+         * default, the container owner has this permission and can grant it to
+         * others.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/GetCorsPolicy">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::GetCorsPolicyOutcomeCallable GetCorsPolicyCallable(const Model::GetCorsPolicyRequest& request) const;
+
+        /**
+         * <p>Returns the cross-origin resource sharing (CORS) configuration information
+         * that is set for the container.</p> <p>To use this operation, you must have
+         * permission to perform the <code>MediaStore:GetCorsPolicy</code> action. By
+         * default, the container owner has this permission and can grant it to
+         * others.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/GetCorsPolicy">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void GetCorsPolicyAsync(const Model::GetCorsPolicyRequest& request, const GetCorsPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Retrieves the object lifecycle policy that is assigned to a
+         * container.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/GetLifecyclePolicy">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::GetLifecyclePolicyOutcome GetLifecyclePolicy(const Model::GetLifecyclePolicyRequest& request) const;
+
+        /**
+         * <p>Retrieves the object lifecycle policy that is assigned to a
+         * container.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/GetLifecyclePolicy">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::GetLifecyclePolicyOutcomeCallable GetLifecyclePolicyCallable(const Model::GetLifecyclePolicyRequest& request) const;
+
+        /**
+         * <p>Retrieves the object lifecycle policy that is assigned to a
+         * container.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/GetLifecyclePolicy">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void GetLifecyclePolicyAsync(const Model::GetLifecyclePolicyRequest& request, const GetLifecyclePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Returns the metric policy for the specified container. </p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/GetMetricPolicy">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::GetMetricPolicyOutcome GetMetricPolicy(const Model::GetMetricPolicyRequest& request) const;
+
+        /**
+         * <p>Returns the metric policy for the specified container. </p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/GetMetricPolicy">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::GetMetricPolicyOutcomeCallable GetMetricPolicyCallable(const Model::GetMetricPolicyRequest& request) const;
+
+        /**
+         * <p>Returns the metric policy for the specified container. </p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/GetMetricPolicy">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void GetMetricPolicyAsync(const Model::GetMetricPolicyRequest& request, const GetMetricPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Lists the properties of all containers in AWS Elemental MediaStore. </p>
+         * <p>You can query to receive all the containers in one response. Or you can
+         * include the <code>MaxResults</code> parameter to receive a limited number of
+         * containers in each response. In this case, the response includes a token. To get
+         * the next set of containers, send the command again, this time with the
+         * <code>NextToken</code> parameter (with the returned token as its value). The
+         * next set of responses appears, with a token if there are still more containers
+         * to receive. </p> <p>See also <a>DescribeContainer</a>, which gets the properties
+         * of one container. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/ListContainers">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ListContainersOutcome ListContainers(const Model::ListContainersRequest& request) const;
+
+        /**
+         * <p>Lists the properties of all containers in AWS Elemental MediaStore. </p>
+         * <p>You can query to receive all the containers in one response. Or you can
+         * include the <code>MaxResults</code> parameter to receive a limited number of
+         * containers in each response. In this case, the response includes a token. To get
+         * the next set of containers, send the command again, this time with the
+         * <code>NextToken</code> parameter (with the returned token as its value). The
+         * next set of responses appears, with a token if there are still more containers
+         * to receive. </p> <p>See also <a>DescribeContainer</a>, which gets the properties
+         * of one container. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/ListContainers">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::ListContainersOutcomeCallable ListContainersCallable(const Model::ListContainersRequest& request) const;
+
+        /**
+         * <p>Lists the properties of all containers in AWS Elemental MediaStore. </p>
+         * <p>You can query to receive all the containers in one response. Or you can
+         * include the <code>MaxResults</code> parameter to receive a limited number of
+         * containers in each response. In this case, the response includes a token. To get
+         * the next set of containers, send the command again, this time with the
+         * <code>NextToken</code> parameter (with the returned token as its value). The
+         * next set of responses appears, with a token if there are still more containers
+         * to receive. </p> <p>See also <a>DescribeContainer</a>, which gets the properties
+         * of one container. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/ListContainers">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void ListContainersAsync(const Model::ListContainersRequest& request, const ListContainersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Returns a list of the tags assigned to the specified container.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/ListTagsForResource">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
+
+        /**
+         * <p>Returns a list of the tags assigned to the specified container.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/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 assigned to the specified container.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/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>Creates an access policy for the specified container to restrict the users
+         * and clients that can access it. For information about the data that is included
+         * in an access policy, see the <a
+         * href="https://aws.amazon.com/documentation/iam/">AWS Identity and Access
+         * Management User Guide</a>.</p> <p>For this release of the REST API, you can
+         * create only one policy for a container. If you enter
+         * <code>PutContainerPolicy</code> twice, the second command modifies the existing
+         * policy. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/PutContainerPolicy">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::PutContainerPolicyOutcome PutContainerPolicy(const Model::PutContainerPolicyRequest& request) const;
+
+        /**
+         * <p>Creates an access policy for the specified container to restrict the users
+         * and clients that can access it. For information about the data that is included
+         * in an access policy, see the <a
+         * href="https://aws.amazon.com/documentation/iam/">AWS Identity and Access
+         * Management User Guide</a>.</p> <p>For this release of the REST API, you can
+         * create only one policy for a container. If you enter
+         * <code>PutContainerPolicy</code> twice, the second command modifies the existing
+         * policy. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/PutContainerPolicy">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::PutContainerPolicyOutcomeCallable PutContainerPolicyCallable(const Model::PutContainerPolicyRequest& request) const;
+
+        /**
+         * <p>Creates an access policy for the specified container to restrict the users
+         * and clients that can access it. For information about the data that is included
+         * in an access policy, see the <a
+         * href="https://aws.amazon.com/documentation/iam/">AWS Identity and Access
+         * Management User Guide</a>.</p> <p>For this release of the REST API, you can
+         * create only one policy for a container. If you enter
+         * <code>PutContainerPolicy</code> twice, the second command modifies the existing
+         * policy. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/PutContainerPolicy">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void PutContainerPolicyAsync(const Model::PutContainerPolicyRequest& request, const PutContainerPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Sets the cross-origin resource sharing (CORS) configuration on a container so
+         * that the container can service cross-origin requests. For example, you might
+         * want to enable a request whose origin is http://www.example.com to access your
+         * AWS Elemental MediaStore container at my.example.container.com by using the
+         * browser's XMLHttpRequest capability.</p> <p>To enable CORS on a container, you
+         * attach a CORS policy to the container. In the CORS policy, you configure rules
+         * that identify origins and the HTTP methods that can be executed on your
+         * container. The policy can contain up to 398,000 characters. You can add up to
+         * 100 rules to a CORS policy. If more than one rule applies, the service uses the
+         * first applicable rule listed.</p> <p>To learn more about CORS, see <a
+         * href="https://docs.aws.amazon.com/mediastore/latest/ug/cors-policy.html">Cross-Origin
+         * Resource Sharing (CORS) in AWS Elemental MediaStore</a>.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/PutCorsPolicy">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::PutCorsPolicyOutcome PutCorsPolicy(const Model::PutCorsPolicyRequest& request) const;
+
+        /**
+         * <p>Sets the cross-origin resource sharing (CORS) configuration on a container so
+         * that the container can service cross-origin requests. For example, you might
+         * want to enable a request whose origin is http://www.example.com to access your
+         * AWS Elemental MediaStore container at my.example.container.com by using the
+         * browser's XMLHttpRequest capability.</p> <p>To enable CORS on a container, you
+         * attach a CORS policy to the container. In the CORS policy, you configure rules
+         * that identify origins and the HTTP methods that can be executed on your
+         * container. The policy can contain up to 398,000 characters. You can add up to
+         * 100 rules to a CORS policy. If more than one rule applies, the service uses the
+         * first applicable rule listed.</p> <p>To learn more about CORS, see <a
+         * href="https://docs.aws.amazon.com/mediastore/latest/ug/cors-policy.html">Cross-Origin
+         * Resource Sharing (CORS) in AWS Elemental MediaStore</a>.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/PutCorsPolicy">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::PutCorsPolicyOutcomeCallable PutCorsPolicyCallable(const Model::PutCorsPolicyRequest& request) const;
+
+        /**
+         * <p>Sets the cross-origin resource sharing (CORS) configuration on a container so
+         * that the container can service cross-origin requests. For example, you might
+         * want to enable a request whose origin is http://www.example.com to access your
+         * AWS Elemental MediaStore container at my.example.container.com by using the
+         * browser's XMLHttpRequest capability.</p> <p>To enable CORS on a container, you
+         * attach a CORS policy to the container. In the CORS policy, you configure rules
+         * that identify origins and the HTTP methods that can be executed on your
+         * container. The policy can contain up to 398,000 characters. You can add up to
+         * 100 rules to a CORS policy. If more than one rule applies, the service uses the
+         * first applicable rule listed.</p> <p>To learn more about CORS, see <a
+         * href="https://docs.aws.amazon.com/mediastore/latest/ug/cors-policy.html">Cross-Origin
+         * Resource Sharing (CORS) in AWS Elemental MediaStore</a>.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/PutCorsPolicy">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void PutCorsPolicyAsync(const Model::PutCorsPolicyRequest& request, const PutCorsPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Writes an object lifecycle policy to a container. If the container already
+         * has an object lifecycle policy, the service replaces the existing policy with
+         * the new policy. It takes up to 20 minutes for the change to take effect.</p>
+         * <p>For information about how to construct an object lifecycle policy, see <a
+         * href="https://docs.aws.amazon.com/mediastore/latest/ug/policies-object-lifecycle-components.html">Components
+         * of an Object Lifecycle Policy</a>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/PutLifecyclePolicy">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::PutLifecyclePolicyOutcome PutLifecyclePolicy(const Model::PutLifecyclePolicyRequest& request) const;
+
+        /**
+         * <p>Writes an object lifecycle policy to a container. If the container already
+         * has an object lifecycle policy, the service replaces the existing policy with
+         * the new policy. It takes up to 20 minutes for the change to take effect.</p>
+         * <p>For information about how to construct an object lifecycle policy, see <a
+         * href="https://docs.aws.amazon.com/mediastore/latest/ug/policies-object-lifecycle-components.html">Components
+         * of an Object Lifecycle Policy</a>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/PutLifecyclePolicy">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::PutLifecyclePolicyOutcomeCallable PutLifecyclePolicyCallable(const Model::PutLifecyclePolicyRequest& request) const;
+
+        /**
+         * <p>Writes an object lifecycle policy to a container. If the container already
+         * has an object lifecycle policy, the service replaces the existing policy with
+         * the new policy. It takes up to 20 minutes for the change to take effect.</p>
+         * <p>For information about how to construct an object lifecycle policy, see <a
+         * href="https://docs.aws.amazon.com/mediastore/latest/ug/policies-object-lifecycle-components.html">Components
+         * of an Object Lifecycle Policy</a>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/PutLifecyclePolicy">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void PutLifecyclePolicyAsync(const Model::PutLifecyclePolicyRequest& request, const PutLifecyclePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>The metric policy that you want to add to the container. A metric policy
+         * allows AWS Elemental MediaStore to send metrics to Amazon CloudWatch. It takes
+         * up to 20 minutes for the new policy to take effect.</p><p><h3>See Also:</h3>  
+         * <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/PutMetricPolicy">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::PutMetricPolicyOutcome PutMetricPolicy(const Model::PutMetricPolicyRequest& request) const;
+
+        /**
+         * <p>The metric policy that you want to add to the container. A metric policy
+         * allows AWS Elemental MediaStore to send metrics to Amazon CloudWatch. It takes
+         * up to 20 minutes for the new policy to take effect.</p><p><h3>See Also:</h3>  
+         * <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/PutMetricPolicy">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::PutMetricPolicyOutcomeCallable PutMetricPolicyCallable(const Model::PutMetricPolicyRequest& request) const;
+
+        /**
+         * <p>The metric policy that you want to add to the container. A metric policy
+         * allows AWS Elemental MediaStore to send metrics to Amazon CloudWatch. It takes
+         * up to 20 minutes for the new policy to take effect.</p><p><h3>See Also:</h3>  
+         * <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/PutMetricPolicy">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void PutMetricPolicyAsync(const Model::PutMetricPolicyRequest& request, const PutMetricPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Starts access logging on the specified container. When you enable access
+         * logging on a container, MediaStore delivers access logs for objects stored in
+         * that container to Amazon CloudWatch Logs.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/StartAccessLogging">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::StartAccessLoggingOutcome StartAccessLogging(const Model::StartAccessLoggingRequest& request) const;
+
+        /**
+         * <p>Starts access logging on the specified container. When you enable access
+         * logging on a container, MediaStore delivers access logs for objects stored in
+         * that container to Amazon CloudWatch Logs.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/StartAccessLogging">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::StartAccessLoggingOutcomeCallable StartAccessLoggingCallable(const Model::StartAccessLoggingRequest& request) const;
+
+        /**
+         * <p>Starts access logging on the specified container. When you enable access
+         * logging on a container, MediaStore delivers access logs for objects stored in
+         * that container to Amazon CloudWatch Logs.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/StartAccessLogging">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void StartAccessLoggingAsync(const Model::StartAccessLoggingRequest& request, const StartAccessLoggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Stops access logging on the specified container. When you stop access logging
+         * on a container, MediaStore stops sending access logs to Amazon CloudWatch Logs.
+         * These access logs are not saved and are not retrievable.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/StopAccessLogging">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::StopAccessLoggingOutcome StopAccessLogging(const Model::StopAccessLoggingRequest& request) const;
+
+        /**
+         * <p>Stops access logging on the specified container. When you stop access logging
+         * on a container, MediaStore stops sending access logs to Amazon CloudWatch Logs.
+         * These access logs are not saved and are not retrievable.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/StopAccessLogging">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::StopAccessLoggingOutcomeCallable StopAccessLoggingCallable(const Model::StopAccessLoggingRequest& request) const;
+
+        /**
+         * <p>Stops access logging on the specified container. When you stop access logging
+         * on a container, MediaStore stops sending access logs to Amazon CloudWatch Logs.
+         * These access logs are not saved and are not retrievable.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/StopAccessLogging">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void StopAccessLoggingAsync(const Model::StopAccessLoggingRequest& request, const StopAccessLoggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Adds tags to the specified AWS Elemental MediaStore container. Tags are
+         * key:value pairs that you can associate with AWS resources. For example, the tag
+         * key might be "customer" and the tag value might be "companyA." You can specify
+         * one or more tags to add to each container. You can add up to 50 tags to each
+         * container. For more information about tagging, including naming and usage
+         * conventions, see <a
+         * href="https://docs.aws.amazon.com/mediastore/latest/ug/tagging.html">Tagging
+         * Resources in MediaStore</a>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/TagResource">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
+
+        /**
+         * <p>Adds tags to the specified AWS Elemental MediaStore container. Tags are
+         * key:value pairs that you can associate with AWS resources. For example, the tag
+         * key might be "customer" and the tag value might be "companyA." You can specify
+         * one or more tags to add to each container. You can add up to 50 tags to each
+         * container. For more information about tagging, including naming and usage
+         * conventions, see <a
+         * href="https://docs.aws.amazon.com/mediastore/latest/ug/tagging.html">Tagging
+         * Resources in MediaStore</a>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/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>Adds tags to the specified AWS Elemental MediaStore container. Tags are
+         * key:value pairs that you can associate with AWS resources. For example, the tag
+         * key might be "customer" and the tag value might be "companyA." You can specify
+         * one or more tags to add to each container. You can add up to 50 tags to each
+         * container. For more information about tagging, including naming and usage
+         * conventions, see <a
+         * href="https://docs.aws.amazon.com/mediastore/latest/ug/tagging.html">Tagging
+         * Resources in MediaStore</a>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/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 tags from the specified container. You can specify one or more tags
+         * to remove. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/UntagResource">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
+
+        /**
+         * <p>Removes tags from the specified container. You can specify one or more tags
+         * to remove. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/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 tags from the specified container. You can specify one or more tags
+         * to remove. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/UntagResource">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void UntagResourceAsync(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+
+      void OverrideEndpoint(const Aws::String& endpoint);
+    private:
+      void init(const Aws::Client::ClientConfiguration& clientConfiguration);
+        void CreateContainerAsyncHelper(const Model::CreateContainerRequest& request, const CreateContainerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DeleteContainerAsyncHelper(const Model::DeleteContainerRequest& request, const DeleteContainerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DeleteContainerPolicyAsyncHelper(const Model::DeleteContainerPolicyRequest& request, const DeleteContainerPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DeleteCorsPolicyAsyncHelper(const Model::DeleteCorsPolicyRequest& request, const DeleteCorsPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DeleteLifecyclePolicyAsyncHelper(const Model::DeleteLifecyclePolicyRequest& request, const DeleteLifecyclePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DeleteMetricPolicyAsyncHelper(const Model::DeleteMetricPolicyRequest& request, const DeleteMetricPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DescribeContainerAsyncHelper(const Model::DescribeContainerRequest& request, const DescribeContainerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void GetContainerPolicyAsyncHelper(const Model::GetContainerPolicyRequest& request, const GetContainerPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void GetCorsPolicyAsyncHelper(const Model::GetCorsPolicyRequest& request, const GetCorsPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void GetLifecyclePolicyAsyncHelper(const Model::GetLifecyclePolicyRequest& request, const GetLifecyclePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void GetMetricPolicyAsyncHelper(const Model::GetMetricPolicyRequest& request, const GetMetricPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void ListContainersAsyncHelper(const Model::ListContainersRequest& request, const ListContainersResponseReceivedHandler& 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 PutContainerPolicyAsyncHelper(const Model::PutContainerPolicyRequest& request, const PutContainerPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void PutCorsPolicyAsyncHelper(const Model::PutCorsPolicyRequest& request, const PutCorsPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void PutLifecyclePolicyAsyncHelper(const Model::PutLifecyclePolicyRequest& request, const PutLifecyclePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void PutMetricPolicyAsyncHelper(const Model::PutMetricPolicyRequest& request, const PutMetricPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void StartAccessLoggingAsyncHelper(const Model::StartAccessLoggingRequest& request, const StartAccessLoggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void StopAccessLoggingAsyncHelper(const Model::StopAccessLoggingRequest& request, const StopAccessLoggingResponseReceivedHandler& 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 UntagResourceAsyncHelper(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+
+      Aws::String m_uri;
+      Aws::String m_configScheme;
+      std::shared_ptr<Aws::Utils::Threading::Executor> m_executor;
+  };
+
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/MediaStoreEndpoint.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/mediastore/MediaStore_EXPORTS.h>
+#include <aws/core/Region.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+
+namespace MediaStore
+{
+namespace MediaStoreEndpoint
+{
+AWS_MEDIASTORE_API Aws::String ForRegion(const Aws::String& regionName, bool useDualStack = false);
+} // namespace MediaStoreEndpoint
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/MediaStoreErrorMarshaller.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/mediastore/MediaStore_EXPORTS.h>
+#include <aws/core/client/AWSErrorMarshaller.h>
+
+namespace Aws
+{
+namespace Client
+{
+
+class AWS_MEDIASTORE_API MediaStoreErrorMarshaller : 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-mediastore/include/aws/mediastore/MediaStoreErrors.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/mediastore/MediaStore_EXPORTS.h>
+
+namespace Aws
+{
+namespace MediaStore
+{
+enum class MediaStoreErrors
+{
+  //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,
+  ///////////////////////////////////////////////////////////////////////////////////////////
+
+  CONTAINER_IN_USE= static_cast<int>(Aws::Client::CoreErrors::SERVICE_EXTENSION_START_RANGE) + 1,
+  CONTAINER_NOT_FOUND,
+  CORS_POLICY_NOT_FOUND,
+  LIMIT_EXCEEDED,
+  POLICY_NOT_FOUND
+};
+
+class AWS_MEDIASTORE_API MediaStoreError : public Aws::Client::AWSError<MediaStoreErrors>
+{
+public:
+  MediaStoreError() {}
+  MediaStoreError(const Aws::Client::AWSError<Aws::Client::CoreErrors>& rhs) : Aws::Client::AWSError<MediaStoreErrors>(rhs) {}
+  MediaStoreError(Aws::Client::AWSError<Aws::Client::CoreErrors>&& rhs) : Aws::Client::AWSError<MediaStoreErrors>(rhs) {}
+  MediaStoreError(const Aws::Client::AWSError<MediaStoreErrors>& rhs) : Aws::Client::AWSError<MediaStoreErrors>(rhs) {}
+  MediaStoreError(Aws::Client::AWSError<MediaStoreErrors>&& rhs) : Aws::Client::AWSError<MediaStoreErrors>(rhs) {}
+
+  template <typename T>
+  T GetModeledError();
+};
+
+namespace MediaStoreErrorMapper
+{
+  AWS_MEDIASTORE_API Aws::Client::AWSError<Aws::Client::CoreErrors> GetErrorForName(const char* errorName);
+}
+
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/MediaStoreRequest.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/mediastore/MediaStore_EXPORTS.h>
+#include <aws/core/AmazonSerializableWebServiceRequest.h>
+#include <aws/core/utils/UnreferencedParam.h>
+#include <aws/core/http/HttpRequest.h>
+
+namespace Aws
+{
+namespace MediaStore
+{
+  class AWS_MEDIASTORE_API MediaStoreRequest : public Aws::AmazonSerializableWebServiceRequest
+  {
+  public:
+    virtual ~MediaStoreRequest () {}
+
+    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, "2017-09-01"));
+      return headers;
+    }
+
+  protected:
+    virtual Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const { return Aws::Http::HeaderValueCollection(); }
+
+  };
+
+
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/MediaStore_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_MEDIASTORE_EXPORTS
+            #define AWS_MEDIASTORE_API __declspec(dllexport)
+        #else
+            #define AWS_MEDIASTORE_API __declspec(dllimport)
+        #endif /* AWS_MEDIASTORE_EXPORTS */
+    #else
+        #define AWS_MEDIASTORE_API
+    #endif // USE_IMPORT_EXPORT
+#else // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)
+    #define AWS_MEDIASTORE_API
+#endif // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/Container.h

@@ -0,0 +1,363 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/DateTime.h>
+#include <aws/mediastore/model/ContainerStatus.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   * <p>This section describes operations that you can perform on an AWS Elemental
+   * MediaStore container.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/Container">AWS
+   * API Reference</a></p>
+   */
+  class AWS_MEDIASTORE_API Container
+  {
+  public:
+    Container();
+    Container(Aws::Utils::Json::JsonView jsonValue);
+    Container& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The DNS endpoint of the container. Use the endpoint to identify the specific
+     * container when sending requests to the data plane. The service assigns this
+     * value when the container is created. Once the value has been assigned, it does
+     * not change.</p>
+     */
+    inline const Aws::String& GetEndpoint() const{ return m_endpoint; }
+
+    /**
+     * <p>The DNS endpoint of the container. Use the endpoint to identify the specific
+     * container when sending requests to the data plane. The service assigns this
+     * value when the container is created. Once the value has been assigned, it does
+     * not change.</p>
+     */
+    inline bool EndpointHasBeenSet() const { return m_endpointHasBeenSet; }
+
+    /**
+     * <p>The DNS endpoint of the container. Use the endpoint to identify the specific
+     * container when sending requests to the data plane. The service assigns this
+     * value when the container is created. Once the value has been assigned, it does
+     * not change.</p>
+     */
+    inline void SetEndpoint(const Aws::String& value) { m_endpointHasBeenSet = true; m_endpoint = value; }
+
+    /**
+     * <p>The DNS endpoint of the container. Use the endpoint to identify the specific
+     * container when sending requests to the data plane. The service assigns this
+     * value when the container is created. Once the value has been assigned, it does
+     * not change.</p>
+     */
+    inline void SetEndpoint(Aws::String&& value) { m_endpointHasBeenSet = true; m_endpoint = std::move(value); }
+
+    /**
+     * <p>The DNS endpoint of the container. Use the endpoint to identify the specific
+     * container when sending requests to the data plane. The service assigns this
+     * value when the container is created. Once the value has been assigned, it does
+     * not change.</p>
+     */
+    inline void SetEndpoint(const char* value) { m_endpointHasBeenSet = true; m_endpoint.assign(value); }
+
+    /**
+     * <p>The DNS endpoint of the container. Use the endpoint to identify the specific
+     * container when sending requests to the data plane. The service assigns this
+     * value when the container is created. Once the value has been assigned, it does
+     * not change.</p>
+     */
+    inline Container& WithEndpoint(const Aws::String& value) { SetEndpoint(value); return *this;}
+
+    /**
+     * <p>The DNS endpoint of the container. Use the endpoint to identify the specific
+     * container when sending requests to the data plane. The service assigns this
+     * value when the container is created. Once the value has been assigned, it does
+     * not change.</p>
+     */
+    inline Container& WithEndpoint(Aws::String&& value) { SetEndpoint(std::move(value)); return *this;}
+
+    /**
+     * <p>The DNS endpoint of the container. Use the endpoint to identify the specific
+     * container when sending requests to the data plane. The service assigns this
+     * value when the container is created. Once the value has been assigned, it does
+     * not change.</p>
+     */
+    inline Container& WithEndpoint(const char* value) { SetEndpoint(value); return *this;}
+
+
+    /**
+     * <p>Unix timestamp.</p>
+     */
+    inline const Aws::Utils::DateTime& GetCreationTime() const{ return m_creationTime; }
+
+    /**
+     * <p>Unix timestamp.</p>
+     */
+    inline bool CreationTimeHasBeenSet() const { return m_creationTimeHasBeenSet; }
+
+    /**
+     * <p>Unix timestamp.</p>
+     */
+    inline void SetCreationTime(const Aws::Utils::DateTime& value) { m_creationTimeHasBeenSet = true; m_creationTime = value; }
+
+    /**
+     * <p>Unix timestamp.</p>
+     */
+    inline void SetCreationTime(Aws::Utils::DateTime&& value) { m_creationTimeHasBeenSet = true; m_creationTime = std::move(value); }
+
+    /**
+     * <p>Unix timestamp.</p>
+     */
+    inline Container& WithCreationTime(const Aws::Utils::DateTime& value) { SetCreationTime(value); return *this;}
+
+    /**
+     * <p>Unix timestamp.</p>
+     */
+    inline Container& WithCreationTime(Aws::Utils::DateTime&& value) { SetCreationTime(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the container. The ARN has the following
+     * format:</p> <p>arn:aws:&lt;region&gt;:&lt;account that owns this
+     * container&gt;:container/&lt;name of container&gt; </p> <p>For example:
+     * arn:aws:mediastore:us-west-2:111122223333:container/movies </p>
+     */
+    inline const Aws::String& GetARN() const{ return m_aRN; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the container. The ARN has the following
+     * format:</p> <p>arn:aws:&lt;region&gt;:&lt;account that owns this
+     * container&gt;:container/&lt;name of container&gt; </p> <p>For example:
+     * arn:aws:mediastore:us-west-2:111122223333:container/movies </p>
+     */
+    inline bool ARNHasBeenSet() const { return m_aRNHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the container. The ARN has the following
+     * format:</p> <p>arn:aws:&lt;region&gt;:&lt;account that owns this
+     * container&gt;:container/&lt;name of container&gt; </p> <p>For example:
+     * arn:aws:mediastore:us-west-2:111122223333:container/movies </p>
+     */
+    inline void SetARN(const Aws::String& value) { m_aRNHasBeenSet = true; m_aRN = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the container. The ARN has the following
+     * format:</p> <p>arn:aws:&lt;region&gt;:&lt;account that owns this
+     * container&gt;:container/&lt;name of container&gt; </p> <p>For example:
+     * arn:aws:mediastore:us-west-2:111122223333:container/movies </p>
+     */
+    inline void SetARN(Aws::String&& value) { m_aRNHasBeenSet = true; m_aRN = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the container. The ARN has the following
+     * format:</p> <p>arn:aws:&lt;region&gt;:&lt;account that owns this
+     * container&gt;:container/&lt;name of container&gt; </p> <p>For example:
+     * arn:aws:mediastore:us-west-2:111122223333:container/movies </p>
+     */
+    inline void SetARN(const char* value) { m_aRNHasBeenSet = true; m_aRN.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the container. The ARN has the following
+     * format:</p> <p>arn:aws:&lt;region&gt;:&lt;account that owns this
+     * container&gt;:container/&lt;name of container&gt; </p> <p>For example:
+     * arn:aws:mediastore:us-west-2:111122223333:container/movies </p>
+     */
+    inline Container& WithARN(const Aws::String& value) { SetARN(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the container. The ARN has the following
+     * format:</p> <p>arn:aws:&lt;region&gt;:&lt;account that owns this
+     * container&gt;:container/&lt;name of container&gt; </p> <p>For example:
+     * arn:aws:mediastore:us-west-2:111122223333:container/movies </p>
+     */
+    inline Container& WithARN(Aws::String&& value) { SetARN(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the container. The ARN has the following
+     * format:</p> <p>arn:aws:&lt;region&gt;:&lt;account that owns this
+     * container&gt;:container/&lt;name of container&gt; </p> <p>For example:
+     * arn:aws:mediastore:us-west-2:111122223333:container/movies </p>
+     */
+    inline Container& WithARN(const char* value) { SetARN(value); return *this;}
+
+
+    /**
+     * <p>The name of the container.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>The name of the container.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>The name of the container.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>The name of the container.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>The name of the container.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>The name of the container.</p>
+     */
+    inline Container& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>The name of the container.</p>
+     */
+    inline Container& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the container.</p>
+     */
+    inline Container& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>The status of container creation or deletion. The status is one of the
+     * following: <code>CREATING</code>, <code>ACTIVE</code>, or <code>DELETING</code>.
+     * While the service is creating the container, the status is
+     * <code>CREATING</code>. When the endpoint is available, the status changes to
+     * <code>ACTIVE</code>.</p>
+     */
+    inline const ContainerStatus& GetStatus() const{ return m_status; }
+
+    /**
+     * <p>The status of container creation or deletion. The status is one of the
+     * following: <code>CREATING</code>, <code>ACTIVE</code>, or <code>DELETING</code>.
+     * While the service is creating the container, the status is
+     * <code>CREATING</code>. When the endpoint is available, the status changes to
+     * <code>ACTIVE</code>.</p>
+     */
+    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
+
+    /**
+     * <p>The status of container creation or deletion. The status is one of the
+     * following: <code>CREATING</code>, <code>ACTIVE</code>, or <code>DELETING</code>.
+     * While the service is creating the container, the status is
+     * <code>CREATING</code>. When the endpoint is available, the status changes to
+     * <code>ACTIVE</code>.</p>
+     */
+    inline void SetStatus(const ContainerStatus& value) { m_statusHasBeenSet = true; m_status = value; }
+
+    /**
+     * <p>The status of container creation or deletion. The status is one of the
+     * following: <code>CREATING</code>, <code>ACTIVE</code>, or <code>DELETING</code>.
+     * While the service is creating the container, the status is
+     * <code>CREATING</code>. When the endpoint is available, the status changes to
+     * <code>ACTIVE</code>.</p>
+     */
+    inline void SetStatus(ContainerStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
+
+    /**
+     * <p>The status of container creation or deletion. The status is one of the
+     * following: <code>CREATING</code>, <code>ACTIVE</code>, or <code>DELETING</code>.
+     * While the service is creating the container, the status is
+     * <code>CREATING</code>. When the endpoint is available, the status changes to
+     * <code>ACTIVE</code>.</p>
+     */
+    inline Container& WithStatus(const ContainerStatus& value) { SetStatus(value); return *this;}
+
+    /**
+     * <p>The status of container creation or deletion. The status is one of the
+     * following: <code>CREATING</code>, <code>ACTIVE</code>, or <code>DELETING</code>.
+     * While the service is creating the container, the status is
+     * <code>CREATING</code>. When the endpoint is available, the status changes to
+     * <code>ACTIVE</code>.</p>
+     */
+    inline Container& WithStatus(ContainerStatus&& value) { SetStatus(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The state of access logging on the container. This value is
+     * <code>false</code> by default, indicating that AWS Elemental MediaStore does not
+     * send access logs to Amazon CloudWatch Logs. When you enable access logging on
+     * the container, MediaStore changes this value to <code>true</code>, indicating
+     * that the service delivers access logs for objects stored in that container to
+     * CloudWatch Logs.</p>
+     */
+    inline bool GetAccessLoggingEnabled() const{ return m_accessLoggingEnabled; }
+
+    /**
+     * <p>The state of access logging on the container. This value is
+     * <code>false</code> by default, indicating that AWS Elemental MediaStore does not
+     * send access logs to Amazon CloudWatch Logs. When you enable access logging on
+     * the container, MediaStore changes this value to <code>true</code>, indicating
+     * that the service delivers access logs for objects stored in that container to
+     * CloudWatch Logs.</p>
+     */
+    inline bool AccessLoggingEnabledHasBeenSet() const { return m_accessLoggingEnabledHasBeenSet; }
+
+    /**
+     * <p>The state of access logging on the container. This value is
+     * <code>false</code> by default, indicating that AWS Elemental MediaStore does not
+     * send access logs to Amazon CloudWatch Logs. When you enable access logging on
+     * the container, MediaStore changes this value to <code>true</code>, indicating
+     * that the service delivers access logs for objects stored in that container to
+     * CloudWatch Logs.</p>
+     */
+    inline void SetAccessLoggingEnabled(bool value) { m_accessLoggingEnabledHasBeenSet = true; m_accessLoggingEnabled = value; }
+
+    /**
+     * <p>The state of access logging on the container. This value is
+     * <code>false</code> by default, indicating that AWS Elemental MediaStore does not
+     * send access logs to Amazon CloudWatch Logs. When you enable access logging on
+     * the container, MediaStore changes this value to <code>true</code>, indicating
+     * that the service delivers access logs for objects stored in that container to
+     * CloudWatch Logs.</p>
+     */
+    inline Container& WithAccessLoggingEnabled(bool value) { SetAccessLoggingEnabled(value); return *this;}
+
+  private:
+
+    Aws::String m_endpoint;
+    bool m_endpointHasBeenSet;
+
+    Aws::Utils::DateTime m_creationTime;
+    bool m_creationTimeHasBeenSet;
+
+    Aws::String m_aRN;
+    bool m_aRNHasBeenSet;
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    ContainerStatus m_status;
+    bool m_statusHasBeenSet;
+
+    bool m_accessLoggingEnabled;
+    bool m_accessLoggingEnabledHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/ContainerLevelMetrics.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/mediastore/MediaStore_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+  enum class ContainerLevelMetrics
+  {
+    NOT_SET,
+    ENABLED,
+    DISABLED
+  };
+
+namespace ContainerLevelMetricsMapper
+{
+AWS_MEDIASTORE_API ContainerLevelMetrics GetContainerLevelMetricsForName(const Aws::String& name);
+
+AWS_MEDIASTORE_API Aws::String GetNameForContainerLevelMetrics(ContainerLevelMetrics value);
+} // namespace ContainerLevelMetricsMapper
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/ContainerStatus.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/mediastore/MediaStore_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+  enum class ContainerStatus
+  {
+    NOT_SET,
+    ACTIVE,
+    CREATING,
+    DELETING
+  };
+
+namespace ContainerStatusMapper
+{
+AWS_MEDIASTORE_API ContainerStatus GetContainerStatusForName(const Aws::String& name);
+
+AWS_MEDIASTORE_API Aws::String GetNameForContainerStatus(ContainerStatus value);
+} // namespace ContainerStatusMapper
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/CorsRule.h

@@ -0,0 +1,413 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/mediastore/model/MethodName.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   * <p>A rule for a CORS policy. You can add up to 100 rules to a CORS policy. If
+   * more than one rule applies, the service uses the first applicable rule
+   * listed.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/CorsRule">AWS
+   * API Reference</a></p>
+   */
+  class AWS_MEDIASTORE_API CorsRule
+  {
+  public:
+    CorsRule();
+    CorsRule(Aws::Utils::Json::JsonView jsonValue);
+    CorsRule& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>One or more response headers that you want users to be able to access from
+     * their applications (for example, from a JavaScript <code>XMLHttpRequest</code>
+     * object).</p> <p>Each CORS rule must have at least one
+     * <code>AllowedOrigins</code> element. The string value can include only one
+     * wildcard character (*), for example, http:// *.example.com. Additionally, you can
+     * specify only one wildcard character to allow cross-origin access for all
+     * origins.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetAllowedOrigins() const{ return m_allowedOrigins; }
+
+    /**
+     * <p>One or more response headers that you want users to be able to access from
+     * their applications (for example, from a JavaScript <code>XMLHttpRequest</code>
+     * object).</p> <p>Each CORS rule must have at least one
+     * <code>AllowedOrigins</code> element. The string value can include only one
+     * wildcard character (*), for example, http:// *.example.com. Additionally, you can
+     * specify only one wildcard character to allow cross-origin access for all
+     * origins.</p>
+     */
+    inline bool AllowedOriginsHasBeenSet() const { return m_allowedOriginsHasBeenSet; }
+
+    /**
+     * <p>One or more response headers that you want users to be able to access from
+     * their applications (for example, from a JavaScript <code>XMLHttpRequest</code>
+     * object).</p> <p>Each CORS rule must have at least one
+     * <code>AllowedOrigins</code> element. The string value can include only one
+     * wildcard character (*), for example, http:// *.example.com. Additionally, you can
+     * specify only one wildcard character to allow cross-origin access for all
+     * origins.</p>
+     */
+    inline void SetAllowedOrigins(const Aws::Vector<Aws::String>& value) { m_allowedOriginsHasBeenSet = true; m_allowedOrigins = value; }
+
+    /**
+     * <p>One or more response headers that you want users to be able to access from
+     * their applications (for example, from a JavaScript <code>XMLHttpRequest</code>
+     * object).</p> <p>Each CORS rule must have at least one
+     * <code>AllowedOrigins</code> element. The string value can include only one
+     * wildcard character (*), for example, http:// *.example.com. Additionally, you can
+     * specify only one wildcard character to allow cross-origin access for all
+     * origins.</p>
+     */
+    inline void SetAllowedOrigins(Aws::Vector<Aws::String>&& value) { m_allowedOriginsHasBeenSet = true; m_allowedOrigins = std::move(value); }
+
+    /**
+     * <p>One or more response headers that you want users to be able to access from
+     * their applications (for example, from a JavaScript <code>XMLHttpRequest</code>
+     * object).</p> <p>Each CORS rule must have at least one
+     * <code>AllowedOrigins</code> element. The string value can include only one
+     * wildcard character (*), for example, http:// *.example.com. Additionally, you can
+     * specify only one wildcard character to allow cross-origin access for all
+     * origins.</p>
+     */
+    inline CorsRule& WithAllowedOrigins(const Aws::Vector<Aws::String>& value) { SetAllowedOrigins(value); return *this;}
+
+    /**
+     * <p>One or more response headers that you want users to be able to access from
+     * their applications (for example, from a JavaScript <code>XMLHttpRequest</code>
+     * object).</p> <p>Each CORS rule must have at least one
+     * <code>AllowedOrigins</code> element. The string value can include only one
+     * wildcard character (*), for example, http:// *.example.com. Additionally, you can
+     * specify only one wildcard character to allow cross-origin access for all
+     * origins.</p>
+     */
+    inline CorsRule& WithAllowedOrigins(Aws::Vector<Aws::String>&& value) { SetAllowedOrigins(std::move(value)); return *this;}
+
+    /**
+     * <p>One or more response headers that you want users to be able to access from
+     * their applications (for example, from a JavaScript <code>XMLHttpRequest</code>
+     * object).</p> <p>Each CORS rule must have at least one
+     * <code>AllowedOrigins</code> element. The string value can include only one
+     * wildcard character (*), for example, http:// *.example.com. Additionally, you can
+     * specify only one wildcard character to allow cross-origin access for all
+     * origins.</p>
+     */
+    inline CorsRule& AddAllowedOrigins(const Aws::String& value) { m_allowedOriginsHasBeenSet = true; m_allowedOrigins.push_back(value); return *this; }
+
+    /**
+     * <p>One or more response headers that you want users to be able to access from
+     * their applications (for example, from a JavaScript <code>XMLHttpRequest</code>
+     * object).</p> <p>Each CORS rule must have at least one
+     * <code>AllowedOrigins</code> element. The string value can include only one
+     * wildcard character (*), for example, http:// *.example.com. Additionally, you can
+     * specify only one wildcard character to allow cross-origin access for all
+     * origins.</p>
+     */
+    inline CorsRule& AddAllowedOrigins(Aws::String&& value) { m_allowedOriginsHasBeenSet = true; m_allowedOrigins.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>One or more response headers that you want users to be able to access from
+     * their applications (for example, from a JavaScript <code>XMLHttpRequest</code>
+     * object).</p> <p>Each CORS rule must have at least one
+     * <code>AllowedOrigins</code> element. The string value can include only one
+     * wildcard character (*), for example, http:// *.example.com. Additionally, you can
+     * specify only one wildcard character to allow cross-origin access for all
+     * origins.</p>
+     */
+    inline CorsRule& AddAllowedOrigins(const char* value) { m_allowedOriginsHasBeenSet = true; m_allowedOrigins.push_back(value); return *this; }
+
+
+    /**
+     * <p>Identifies an HTTP method that the origin that is specified in the rule is
+     * allowed to execute.</p> <p>Each CORS rule must contain at least one
+     * <code>AllowedMethods</code> and one <code>AllowedOrigins</code> element.</p>
+     */
+    inline const Aws::Vector<MethodName>& GetAllowedMethods() const{ return m_allowedMethods; }
+
+    /**
+     * <p>Identifies an HTTP method that the origin that is specified in the rule is
+     * allowed to execute.</p> <p>Each CORS rule must contain at least one
+     * <code>AllowedMethods</code> and one <code>AllowedOrigins</code> element.</p>
+     */
+    inline bool AllowedMethodsHasBeenSet() const { return m_allowedMethodsHasBeenSet; }
+
+    /**
+     * <p>Identifies an HTTP method that the origin that is specified in the rule is
+     * allowed to execute.</p> <p>Each CORS rule must contain at least one
+     * <code>AllowedMethods</code> and one <code>AllowedOrigins</code> element.</p>
+     */
+    inline void SetAllowedMethods(const Aws::Vector<MethodName>& value) { m_allowedMethodsHasBeenSet = true; m_allowedMethods = value; }
+
+    /**
+     * <p>Identifies an HTTP method that the origin that is specified in the rule is
+     * allowed to execute.</p> <p>Each CORS rule must contain at least one
+     * <code>AllowedMethods</code> and one <code>AllowedOrigins</code> element.</p>
+     */
+    inline void SetAllowedMethods(Aws::Vector<MethodName>&& value) { m_allowedMethodsHasBeenSet = true; m_allowedMethods = std::move(value); }
+
+    /**
+     * <p>Identifies an HTTP method that the origin that is specified in the rule is
+     * allowed to execute.</p> <p>Each CORS rule must contain at least one
+     * <code>AllowedMethods</code> and one <code>AllowedOrigins</code> element.</p>
+     */
+    inline CorsRule& WithAllowedMethods(const Aws::Vector<MethodName>& value) { SetAllowedMethods(value); return *this;}
+
+    /**
+     * <p>Identifies an HTTP method that the origin that is specified in the rule is
+     * allowed to execute.</p> <p>Each CORS rule must contain at least one
+     * <code>AllowedMethods</code> and one <code>AllowedOrigins</code> element.</p>
+     */
+    inline CorsRule& WithAllowedMethods(Aws::Vector<MethodName>&& value) { SetAllowedMethods(std::move(value)); return *this;}
+
+    /**
+     * <p>Identifies an HTTP method that the origin that is specified in the rule is
+     * allowed to execute.</p> <p>Each CORS rule must contain at least one
+     * <code>AllowedMethods</code> and one <code>AllowedOrigins</code> element.</p>
+     */
+    inline CorsRule& AddAllowedMethods(const MethodName& value) { m_allowedMethodsHasBeenSet = true; m_allowedMethods.push_back(value); return *this; }
+
+    /**
+     * <p>Identifies an HTTP method that the origin that is specified in the rule is
+     * allowed to execute.</p> <p>Each CORS rule must contain at least one
+     * <code>AllowedMethods</code> and one <code>AllowedOrigins</code> element.</p>
+     */
+    inline CorsRule& AddAllowedMethods(MethodName&& value) { m_allowedMethodsHasBeenSet = true; m_allowedMethods.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>Specifies which headers are allowed in a preflight <code>OPTIONS</code>
+     * request through the <code>Access-Control-Request-Headers</code> header. Each
+     * header name that is specified in <code>Access-Control-Request-Headers</code>
+     * must have a corresponding entry in the rule. Only the headers that were
+     * requested are sent back. </p> <p>This element can contain only one wildcard
+     * character (*).</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetAllowedHeaders() const{ return m_allowedHeaders; }
+
+    /**
+     * <p>Specifies which headers are allowed in a preflight <code>OPTIONS</code>
+     * request through the <code>Access-Control-Request-Headers</code> header. Each
+     * header name that is specified in <code>Access-Control-Request-Headers</code>
+     * must have a corresponding entry in the rule. Only the headers that were
+     * requested are sent back. </p> <p>This element can contain only one wildcard
+     * character (*).</p>
+     */
+    inline bool AllowedHeadersHasBeenSet() const { return m_allowedHeadersHasBeenSet; }
+
+    /**
+     * <p>Specifies which headers are allowed in a preflight <code>OPTIONS</code>
+     * request through the <code>Access-Control-Request-Headers</code> header. Each
+     * header name that is specified in <code>Access-Control-Request-Headers</code>
+     * must have a corresponding entry in the rule. Only the headers that were
+     * requested are sent back. </p> <p>This element can contain only one wildcard
+     * character (*).</p>
+     */
+    inline void SetAllowedHeaders(const Aws::Vector<Aws::String>& value) { m_allowedHeadersHasBeenSet = true; m_allowedHeaders = value; }
+
+    /**
+     * <p>Specifies which headers are allowed in a preflight <code>OPTIONS</code>
+     * request through the <code>Access-Control-Request-Headers</code> header. Each
+     * header name that is specified in <code>Access-Control-Request-Headers</code>
+     * must have a corresponding entry in the rule. Only the headers that were
+     * requested are sent back. </p> <p>This element can contain only one wildcard
+     * character (*).</p>
+     */
+    inline void SetAllowedHeaders(Aws::Vector<Aws::String>&& value) { m_allowedHeadersHasBeenSet = true; m_allowedHeaders = std::move(value); }
+
+    /**
+     * <p>Specifies which headers are allowed in a preflight <code>OPTIONS</code>
+     * request through the <code>Access-Control-Request-Headers</code> header. Each
+     * header name that is specified in <code>Access-Control-Request-Headers</code>
+     * must have a corresponding entry in the rule. Only the headers that were
+     * requested are sent back. </p> <p>This element can contain only one wildcard
+     * character (*).</p>
+     */
+    inline CorsRule& WithAllowedHeaders(const Aws::Vector<Aws::String>& value) { SetAllowedHeaders(value); return *this;}
+
+    /**
+     * <p>Specifies which headers are allowed in a preflight <code>OPTIONS</code>
+     * request through the <code>Access-Control-Request-Headers</code> header. Each
+     * header name that is specified in <code>Access-Control-Request-Headers</code>
+     * must have a corresponding entry in the rule. Only the headers that were
+     * requested are sent back. </p> <p>This element can contain only one wildcard
+     * character (*).</p>
+     */
+    inline CorsRule& WithAllowedHeaders(Aws::Vector<Aws::String>&& value) { SetAllowedHeaders(std::move(value)); return *this;}
+
+    /**
+     * <p>Specifies which headers are allowed in a preflight <code>OPTIONS</code>
+     * request through the <code>Access-Control-Request-Headers</code> header. Each
+     * header name that is specified in <code>Access-Control-Request-Headers</code>
+     * must have a corresponding entry in the rule. Only the headers that were
+     * requested are sent back. </p> <p>This element can contain only one wildcard
+     * character (*).</p>
+     */
+    inline CorsRule& AddAllowedHeaders(const Aws::String& value) { m_allowedHeadersHasBeenSet = true; m_allowedHeaders.push_back(value); return *this; }
+
+    /**
+     * <p>Specifies which headers are allowed in a preflight <code>OPTIONS</code>
+     * request through the <code>Access-Control-Request-Headers</code> header. Each
+     * header name that is specified in <code>Access-Control-Request-Headers</code>
+     * must have a corresponding entry in the rule. Only the headers that were
+     * requested are sent back. </p> <p>This element can contain only one wildcard
+     * character (*).</p>
+     */
+    inline CorsRule& AddAllowedHeaders(Aws::String&& value) { m_allowedHeadersHasBeenSet = true; m_allowedHeaders.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>Specifies which headers are allowed in a preflight <code>OPTIONS</code>
+     * request through the <code>Access-Control-Request-Headers</code> header. Each
+     * header name that is specified in <code>Access-Control-Request-Headers</code>
+     * must have a corresponding entry in the rule. Only the headers that were
+     * requested are sent back. </p> <p>This element can contain only one wildcard
+     * character (*).</p>
+     */
+    inline CorsRule& AddAllowedHeaders(const char* value) { m_allowedHeadersHasBeenSet = true; m_allowedHeaders.push_back(value); return *this; }
+
+
+    /**
+     * <p>The time in seconds that your browser caches the preflight response for the
+     * specified resource.</p> <p>A CORS rule can have only one
+     * <code>MaxAgeSeconds</code> element.</p>
+     */
+    inline int GetMaxAgeSeconds() const{ return m_maxAgeSeconds; }
+
+    /**
+     * <p>The time in seconds that your browser caches the preflight response for the
+     * specified resource.</p> <p>A CORS rule can have only one
+     * <code>MaxAgeSeconds</code> element.</p>
+     */
+    inline bool MaxAgeSecondsHasBeenSet() const { return m_maxAgeSecondsHasBeenSet; }
+
+    /**
+     * <p>The time in seconds that your browser caches the preflight response for the
+     * specified resource.</p> <p>A CORS rule can have only one
+     * <code>MaxAgeSeconds</code> element.</p>
+     */
+    inline void SetMaxAgeSeconds(int value) { m_maxAgeSecondsHasBeenSet = true; m_maxAgeSeconds = value; }
+
+    /**
+     * <p>The time in seconds that your browser caches the preflight response for the
+     * specified resource.</p> <p>A CORS rule can have only one
+     * <code>MaxAgeSeconds</code> element.</p>
+     */
+    inline CorsRule& WithMaxAgeSeconds(int value) { SetMaxAgeSeconds(value); return *this;}
+
+
+    /**
+     * <p>One or more headers in the response that you want users to be able to access
+     * from their applications (for example, from a JavaScript
+     * <code>XMLHttpRequest</code> object).</p> <p>This element is optional for each
+     * rule.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetExposeHeaders() const{ return m_exposeHeaders; }
+
+    /**
+     * <p>One or more headers in the response that you want users to be able to access
+     * from their applications (for example, from a JavaScript
+     * <code>XMLHttpRequest</code> object).</p> <p>This element is optional for each
+     * rule.</p>
+     */
+    inline bool ExposeHeadersHasBeenSet() const { return m_exposeHeadersHasBeenSet; }
+
+    /**
+     * <p>One or more headers in the response that you want users to be able to access
+     * from their applications (for example, from a JavaScript
+     * <code>XMLHttpRequest</code> object).</p> <p>This element is optional for each
+     * rule.</p>
+     */
+    inline void SetExposeHeaders(const Aws::Vector<Aws::String>& value) { m_exposeHeadersHasBeenSet = true; m_exposeHeaders = value; }
+
+    /**
+     * <p>One or more headers in the response that you want users to be able to access
+     * from their applications (for example, from a JavaScript
+     * <code>XMLHttpRequest</code> object).</p> <p>This element is optional for each
+     * rule.</p>
+     */
+    inline void SetExposeHeaders(Aws::Vector<Aws::String>&& value) { m_exposeHeadersHasBeenSet = true; m_exposeHeaders = std::move(value); }
+
+    /**
+     * <p>One or more headers in the response that you want users to be able to access
+     * from their applications (for example, from a JavaScript
+     * <code>XMLHttpRequest</code> object).</p> <p>This element is optional for each
+     * rule.</p>
+     */
+    inline CorsRule& WithExposeHeaders(const Aws::Vector<Aws::String>& value) { SetExposeHeaders(value); return *this;}
+
+    /**
+     * <p>One or more headers in the response that you want users to be able to access
+     * from their applications (for example, from a JavaScript
+     * <code>XMLHttpRequest</code> object).</p> <p>This element is optional for each
+     * rule.</p>
+     */
+    inline CorsRule& WithExposeHeaders(Aws::Vector<Aws::String>&& value) { SetExposeHeaders(std::move(value)); return *this;}
+
+    /**
+     * <p>One or more headers in the response that you want users to be able to access
+     * from their applications (for example, from a JavaScript
+     * <code>XMLHttpRequest</code> object).</p> <p>This element is optional for each
+     * rule.</p>
+     */
+    inline CorsRule& AddExposeHeaders(const Aws::String& value) { m_exposeHeadersHasBeenSet = true; m_exposeHeaders.push_back(value); return *this; }
+
+    /**
+     * <p>One or more headers in the response that you want users to be able to access
+     * from their applications (for example, from a JavaScript
+     * <code>XMLHttpRequest</code> object).</p> <p>This element is optional for each
+     * rule.</p>
+     */
+    inline CorsRule& AddExposeHeaders(Aws::String&& value) { m_exposeHeadersHasBeenSet = true; m_exposeHeaders.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>One or more headers in the response that you want users to be able to access
+     * from their applications (for example, from a JavaScript
+     * <code>XMLHttpRequest</code> object).</p> <p>This element is optional for each
+     * rule.</p>
+     */
+    inline CorsRule& AddExposeHeaders(const char* value) { m_exposeHeadersHasBeenSet = true; m_exposeHeaders.push_back(value); return *this; }
+
+  private:
+
+    Aws::Vector<Aws::String> m_allowedOrigins;
+    bool m_allowedOriginsHasBeenSet;
+
+    Aws::Vector<MethodName> m_allowedMethods;
+    bool m_allowedMethodsHasBeenSet;
+
+    Aws::Vector<Aws::String> m_allowedHeaders;
+    bool m_allowedHeadersHasBeenSet;
+
+    int m_maxAgeSeconds;
+    bool m_maxAgeSecondsHasBeenSet;
+
+    Aws::Vector<Aws::String> m_exposeHeaders;
+    bool m_exposeHeadersHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/CreateContainerRequest.h

@@ -0,0 +1,211 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/MediaStoreRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/mediastore/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_MEDIASTORE_API CreateContainerRequest : public MediaStoreRequest
+  {
+  public:
+    CreateContainerRequest();
+
+    // 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 "CreateContainer"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name for the container. The name must be from 1 to 255 characters.
+     * Container names must be unique to your AWS account within a specific region. As
+     * an example, you could create a container named <code>movies</code> in every
+     * region, as long as you don’t have an existing container with that name.</p>
+     */
+    inline const Aws::String& GetContainerName() const{ return m_containerName; }
+
+    /**
+     * <p>The name for the container. The name must be from 1 to 255 characters.
+     * Container names must be unique to your AWS account within a specific region. As
+     * an example, you could create a container named <code>movies</code> in every
+     * region, as long as you don’t have an existing container with that name.</p>
+     */
+    inline bool ContainerNameHasBeenSet() const { return m_containerNameHasBeenSet; }
+
+    /**
+     * <p>The name for the container. The name must be from 1 to 255 characters.
+     * Container names must be unique to your AWS account within a specific region. As
+     * an example, you could create a container named <code>movies</code> in every
+     * region, as long as you don’t have an existing container with that name.</p>
+     */
+    inline void SetContainerName(const Aws::String& value) { m_containerNameHasBeenSet = true; m_containerName = value; }
+
+    /**
+     * <p>The name for the container. The name must be from 1 to 255 characters.
+     * Container names must be unique to your AWS account within a specific region. As
+     * an example, you could create a container named <code>movies</code> in every
+     * region, as long as you don’t have an existing container with that name.</p>
+     */
+    inline void SetContainerName(Aws::String&& value) { m_containerNameHasBeenSet = true; m_containerName = std::move(value); }
+
+    /**
+     * <p>The name for the container. The name must be from 1 to 255 characters.
+     * Container names must be unique to your AWS account within a specific region. As
+     * an example, you could create a container named <code>movies</code> in every
+     * region, as long as you don’t have an existing container with that name.</p>
+     */
+    inline void SetContainerName(const char* value) { m_containerNameHasBeenSet = true; m_containerName.assign(value); }
+
+    /**
+     * <p>The name for the container. The name must be from 1 to 255 characters.
+     * Container names must be unique to your AWS account within a specific region. As
+     * an example, you could create a container named <code>movies</code> in every
+     * region, as long as you don’t have an existing container with that name.</p>
+     */
+    inline CreateContainerRequest& WithContainerName(const Aws::String& value) { SetContainerName(value); return *this;}
+
+    /**
+     * <p>The name for the container. The name must be from 1 to 255 characters.
+     * Container names must be unique to your AWS account within a specific region. As
+     * an example, you could create a container named <code>movies</code> in every
+     * region, as long as you don’t have an existing container with that name.</p>
+     */
+    inline CreateContainerRequest& WithContainerName(Aws::String&& value) { SetContainerName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name for the container. The name must be from 1 to 255 characters.
+     * Container names must be unique to your AWS account within a specific region. As
+     * an example, you could create a container named <code>movies</code> in every
+     * region, as long as you don’t have an existing container with that name.</p>
+     */
+    inline CreateContainerRequest& WithContainerName(const char* value) { SetContainerName(value); return *this;}
+
+
+    /**
+     * <p>An array of key:value pairs that you define. These values can be anything
+     * that you want. Typically, the tag key represents a category (such as
+     * "environment") and the tag value represents a specific value within that
+     * category (such as "test," "development," or "production"). You can add up to 50
+     * tags to each container. For more information about tagging, including naming and
+     * usage conventions, see <a
+     * href="https://docs.aws.amazon.com/mediastore/latest/ug/tagging.html">Tagging
+     * Resources in MediaStore</a>.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>An array of key:value pairs that you define. These values can be anything
+     * that you want. Typically, the tag key represents a category (such as
+     * "environment") and the tag value represents a specific value within that
+     * category (such as "test," "development," or "production"). You can add up to 50
+     * tags to each container. For more information about tagging, including naming and
+     * usage conventions, see <a
+     * href="https://docs.aws.amazon.com/mediastore/latest/ug/tagging.html">Tagging
+     * Resources in MediaStore</a>.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>An array of key:value pairs that you define. These values can be anything
+     * that you want. Typically, the tag key represents a category (such as
+     * "environment") and the tag value represents a specific value within that
+     * category (such as "test," "development," or "production"). You can add up to 50
+     * tags to each container. For more information about tagging, including naming and
+     * usage conventions, see <a
+     * href="https://docs.aws.amazon.com/mediastore/latest/ug/tagging.html">Tagging
+     * Resources in MediaStore</a>.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>An array of key:value pairs that you define. These values can be anything
+     * that you want. Typically, the tag key represents a category (such as
+     * "environment") and the tag value represents a specific value within that
+     * category (such as "test," "development," or "production"). You can add up to 50
+     * tags to each container. For more information about tagging, including naming and
+     * usage conventions, see <a
+     * href="https://docs.aws.amazon.com/mediastore/latest/ug/tagging.html">Tagging
+     * Resources in MediaStore</a>.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>An array of key:value pairs that you define. These values can be anything
+     * that you want. Typically, the tag key represents a category (such as
+     * "environment") and the tag value represents a specific value within that
+     * category (such as "test," "development," or "production"). You can add up to 50
+     * tags to each container. For more information about tagging, including naming and
+     * usage conventions, see <a
+     * href="https://docs.aws.amazon.com/mediastore/latest/ug/tagging.html">Tagging
+     * Resources in MediaStore</a>.</p>
+     */
+    inline CreateContainerRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>An array of key:value pairs that you define. These values can be anything
+     * that you want. Typically, the tag key represents a category (such as
+     * "environment") and the tag value represents a specific value within that
+     * category (such as "test," "development," or "production"). You can add up to 50
+     * tags to each container. For more information about tagging, including naming and
+     * usage conventions, see <a
+     * href="https://docs.aws.amazon.com/mediastore/latest/ug/tagging.html">Tagging
+     * Resources in MediaStore</a>.</p>
+     */
+    inline CreateContainerRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>An array of key:value pairs that you define. These values can be anything
+     * that you want. Typically, the tag key represents a category (such as
+     * "environment") and the tag value represents a specific value within that
+     * category (such as "test," "development," or "production"). You can add up to 50
+     * tags to each container. For more information about tagging, including naming and
+     * usage conventions, see <a
+     * href="https://docs.aws.amazon.com/mediastore/latest/ug/tagging.html">Tagging
+     * Resources in MediaStore</a>.</p>
+     */
+    inline CreateContainerRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>An array of key:value pairs that you define. These values can be anything
+     * that you want. Typically, the tag key represents a category (such as
+     * "environment") and the tag value represents a specific value within that
+     * category (such as "test," "development," or "production"). You can add up to 50
+     * tags to each container. For more information about tagging, including naming and
+     * usage conventions, see <a
+     * href="https://docs.aws.amazon.com/mediastore/latest/ug/tagging.html">Tagging
+     * Resources in MediaStore</a>.</p>
+     */
+    inline CreateContainerRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_containerName;
+    bool m_containerNameHasBeenSet;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/CreateContainerResult.h

@@ -0,0 +1,122 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/model/Container.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace MediaStore
+{
+namespace Model
+{
+  class AWS_MEDIASTORE_API CreateContainerResult
+  {
+  public:
+    CreateContainerResult();
+    CreateContainerResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    CreateContainerResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>ContainerARN: The Amazon Resource Name (ARN) of the newly created container.
+     * The ARN has the following format: arn:aws:&lt;region&gt;:&lt;account that owns
+     * this container&gt;:container/&lt;name of container&gt;. For example:
+     * arn:aws:mediastore:us-west-2:111122223333:container/movies </p>
+     * <p>ContainerName: The container name as specified in the request.</p>
+     * <p>CreationTime: Unix time stamp.</p> <p>Status: The status of container
+     * creation or deletion. The status is one of the following: <code>CREATING</code>,
+     * <code>ACTIVE</code>, or <code>DELETING</code>. While the service is creating the
+     * container, the status is <code>CREATING</code>. When an endpoint is available,
+     * the status changes to <code>ACTIVE</code>.</p> <p>The return value does not
+     * include the container's endpoint. To make downstream requests, you must obtain
+     * this value by using <a>DescribeContainer</a> or <a>ListContainers</a>.</p>
+     */
+    inline const Container& GetContainer() const{ return m_container; }
+
+    /**
+     * <p>ContainerARN: The Amazon Resource Name (ARN) of the newly created container.
+     * The ARN has the following format: arn:aws:&lt;region&gt;:&lt;account that owns
+     * this container&gt;:container/&lt;name of container&gt;. For example:
+     * arn:aws:mediastore:us-west-2:111122223333:container/movies </p>
+     * <p>ContainerName: The container name as specified in the request.</p>
+     * <p>CreationTime: Unix time stamp.</p> <p>Status: The status of container
+     * creation or deletion. The status is one of the following: <code>CREATING</code>,
+     * <code>ACTIVE</code>, or <code>DELETING</code>. While the service is creating the
+     * container, the status is <code>CREATING</code>. When an endpoint is available,
+     * the status changes to <code>ACTIVE</code>.</p> <p>The return value does not
+     * include the container's endpoint. To make downstream requests, you must obtain
+     * this value by using <a>DescribeContainer</a> or <a>ListContainers</a>.</p>
+     */
+    inline void SetContainer(const Container& value) { m_container = value; }
+
+    /**
+     * <p>ContainerARN: The Amazon Resource Name (ARN) of the newly created container.
+     * The ARN has the following format: arn:aws:&lt;region&gt;:&lt;account that owns
+     * this container&gt;:container/&lt;name of container&gt;. For example:
+     * arn:aws:mediastore:us-west-2:111122223333:container/movies </p>
+     * <p>ContainerName: The container name as specified in the request.</p>
+     * <p>CreationTime: Unix time stamp.</p> <p>Status: The status of container
+     * creation or deletion. The status is one of the following: <code>CREATING</code>,
+     * <code>ACTIVE</code>, or <code>DELETING</code>. While the service is creating the
+     * container, the status is <code>CREATING</code>. When an endpoint is available,
+     * the status changes to <code>ACTIVE</code>.</p> <p>The return value does not
+     * include the container's endpoint. To make downstream requests, you must obtain
+     * this value by using <a>DescribeContainer</a> or <a>ListContainers</a>.</p>
+     */
+    inline void SetContainer(Container&& value) { m_container = std::move(value); }
+
+    /**
+     * <p>ContainerARN: The Amazon Resource Name (ARN) of the newly created container.
+     * The ARN has the following format: arn:aws:&lt;region&gt;:&lt;account that owns
+     * this container&gt;:container/&lt;name of container&gt;. For example:
+     * arn:aws:mediastore:us-west-2:111122223333:container/movies </p>
+     * <p>ContainerName: The container name as specified in the request.</p>
+     * <p>CreationTime: Unix time stamp.</p> <p>Status: The status of container
+     * creation or deletion. The status is one of the following: <code>CREATING</code>,
+     * <code>ACTIVE</code>, or <code>DELETING</code>. While the service is creating the
+     * container, the status is <code>CREATING</code>. When an endpoint is available,
+     * the status changes to <code>ACTIVE</code>.</p> <p>The return value does not
+     * include the container's endpoint. To make downstream requests, you must obtain
+     * this value by using <a>DescribeContainer</a> or <a>ListContainers</a>.</p>
+     */
+    inline CreateContainerResult& WithContainer(const Container& value) { SetContainer(value); return *this;}
+
+    /**
+     * <p>ContainerARN: The Amazon Resource Name (ARN) of the newly created container.
+     * The ARN has the following format: arn:aws:&lt;region&gt;:&lt;account that owns
+     * this container&gt;:container/&lt;name of container&gt;. For example:
+     * arn:aws:mediastore:us-west-2:111122223333:container/movies </p>
+     * <p>ContainerName: The container name as specified in the request.</p>
+     * <p>CreationTime: Unix time stamp.</p> <p>Status: The status of container
+     * creation or deletion. The status is one of the following: <code>CREATING</code>,
+     * <code>ACTIVE</code>, or <code>DELETING</code>. While the service is creating the
+     * container, the status is <code>CREATING</code>. When an endpoint is available,
+     * the status changes to <code>ACTIVE</code>.</p> <p>The return value does not
+     * include the container's endpoint. To make downstream requests, you must obtain
+     * this value by using <a>DescribeContainer</a> or <a>ListContainers</a>.</p>
+     */
+    inline CreateContainerResult& WithContainer(Container&& value) { SetContainer(std::move(value)); return *this;}
+
+  private:
+
+    Container m_container;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/DeleteContainerPolicyRequest.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/MediaStoreRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_MEDIASTORE_API DeleteContainerPolicyRequest : public MediaStoreRequest
+  {
+  public:
+    DeleteContainerPolicyRequest();
+
+    // 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 "DeleteContainerPolicy"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the container that holds the policy.</p>
+     */
+    inline const Aws::String& GetContainerName() const{ return m_containerName; }
+
+    /**
+     * <p>The name of the container that holds the policy.</p>
+     */
+    inline bool ContainerNameHasBeenSet() const { return m_containerNameHasBeenSet; }
+
+    /**
+     * <p>The name of the container that holds the policy.</p>
+     */
+    inline void SetContainerName(const Aws::String& value) { m_containerNameHasBeenSet = true; m_containerName = value; }
+
+    /**
+     * <p>The name of the container that holds the policy.</p>
+     */
+    inline void SetContainerName(Aws::String&& value) { m_containerNameHasBeenSet = true; m_containerName = std::move(value); }
+
+    /**
+     * <p>The name of the container that holds the policy.</p>
+     */
+    inline void SetContainerName(const char* value) { m_containerNameHasBeenSet = true; m_containerName.assign(value); }
+
+    /**
+     * <p>The name of the container that holds the policy.</p>
+     */
+    inline DeleteContainerPolicyRequest& WithContainerName(const Aws::String& value) { SetContainerName(value); return *this;}
+
+    /**
+     * <p>The name of the container that holds the policy.</p>
+     */
+    inline DeleteContainerPolicyRequest& WithContainerName(Aws::String&& value) { SetContainerName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the container that holds the policy.</p>
+     */
+    inline DeleteContainerPolicyRequest& WithContainerName(const char* value) { SetContainerName(value); return *this;}
+
+  private:
+
+    Aws::String m_containerName;
+    bool m_containerNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/DeleteContainerPolicyResult.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/mediastore/MediaStore_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace MediaStore
+{
+namespace Model
+{
+  class AWS_MEDIASTORE_API DeleteContainerPolicyResult
+  {
+  public:
+    DeleteContainerPolicyResult();
+    DeleteContainerPolicyResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DeleteContainerPolicyResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/DeleteContainerRequest.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/MediaStoreRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_MEDIASTORE_API DeleteContainerRequest : public MediaStoreRequest
+  {
+  public:
+    DeleteContainerRequest();
+
+    // 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 "DeleteContainer"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the container to delete. </p>
+     */
+    inline const Aws::String& GetContainerName() const{ return m_containerName; }
+
+    /**
+     * <p>The name of the container to delete. </p>
+     */
+    inline bool ContainerNameHasBeenSet() const { return m_containerNameHasBeenSet; }
+
+    /**
+     * <p>The name of the container to delete. </p>
+     */
+    inline void SetContainerName(const Aws::String& value) { m_containerNameHasBeenSet = true; m_containerName = value; }
+
+    /**
+     * <p>The name of the container to delete. </p>
+     */
+    inline void SetContainerName(Aws::String&& value) { m_containerNameHasBeenSet = true; m_containerName = std::move(value); }
+
+    /**
+     * <p>The name of the container to delete. </p>
+     */
+    inline void SetContainerName(const char* value) { m_containerNameHasBeenSet = true; m_containerName.assign(value); }
+
+    /**
+     * <p>The name of the container to delete. </p>
+     */
+    inline DeleteContainerRequest& WithContainerName(const Aws::String& value) { SetContainerName(value); return *this;}
+
+    /**
+     * <p>The name of the container to delete. </p>
+     */
+    inline DeleteContainerRequest& WithContainerName(Aws::String&& value) { SetContainerName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the container to delete. </p>
+     */
+    inline DeleteContainerRequest& WithContainerName(const char* value) { SetContainerName(value); return *this;}
+
+  private:
+
+    Aws::String m_containerName;
+    bool m_containerNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/DeleteContainerResult.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/mediastore/MediaStore_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace MediaStore
+{
+namespace Model
+{
+  class AWS_MEDIASTORE_API DeleteContainerResult
+  {
+  public:
+    DeleteContainerResult();
+    DeleteContainerResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DeleteContainerResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/DeleteCorsPolicyRequest.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/MediaStoreRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_MEDIASTORE_API DeleteCorsPolicyRequest : public MediaStoreRequest
+  {
+  public:
+    DeleteCorsPolicyRequest();
+
+    // 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 "DeleteCorsPolicy"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the container to remove the policy from.</p>
+     */
+    inline const Aws::String& GetContainerName() const{ return m_containerName; }
+
+    /**
+     * <p>The name of the container to remove the policy from.</p>
+     */
+    inline bool ContainerNameHasBeenSet() const { return m_containerNameHasBeenSet; }
+
+    /**
+     * <p>The name of the container to remove the policy from.</p>
+     */
+    inline void SetContainerName(const Aws::String& value) { m_containerNameHasBeenSet = true; m_containerName = value; }
+
+    /**
+     * <p>The name of the container to remove the policy from.</p>
+     */
+    inline void SetContainerName(Aws::String&& value) { m_containerNameHasBeenSet = true; m_containerName = std::move(value); }
+
+    /**
+     * <p>The name of the container to remove the policy from.</p>
+     */
+    inline void SetContainerName(const char* value) { m_containerNameHasBeenSet = true; m_containerName.assign(value); }
+
+    /**
+     * <p>The name of the container to remove the policy from.</p>
+     */
+    inline DeleteCorsPolicyRequest& WithContainerName(const Aws::String& value) { SetContainerName(value); return *this;}
+
+    /**
+     * <p>The name of the container to remove the policy from.</p>
+     */
+    inline DeleteCorsPolicyRequest& WithContainerName(Aws::String&& value) { SetContainerName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the container to remove the policy from.</p>
+     */
+    inline DeleteCorsPolicyRequest& WithContainerName(const char* value) { SetContainerName(value); return *this;}
+
+  private:
+
+    Aws::String m_containerName;
+    bool m_containerNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/DeleteCorsPolicyResult.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/mediastore/MediaStore_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace MediaStore
+{
+namespace Model
+{
+  class AWS_MEDIASTORE_API DeleteCorsPolicyResult
+  {
+  public:
+    DeleteCorsPolicyResult();
+    DeleteCorsPolicyResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DeleteCorsPolicyResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/DeleteLifecyclePolicyRequest.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/MediaStoreRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_MEDIASTORE_API DeleteLifecyclePolicyRequest : public MediaStoreRequest
+  {
+  public:
+    DeleteLifecyclePolicyRequest();
+
+    // 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 "DeleteLifecyclePolicy"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the container that holds the object lifecycle policy.</p>
+     */
+    inline const Aws::String& GetContainerName() const{ return m_containerName; }
+
+    /**
+     * <p>The name of the container that holds the object lifecycle policy.</p>
+     */
+    inline bool ContainerNameHasBeenSet() const { return m_containerNameHasBeenSet; }
+
+    /**
+     * <p>The name of the container that holds the object lifecycle policy.</p>
+     */
+    inline void SetContainerName(const Aws::String& value) { m_containerNameHasBeenSet = true; m_containerName = value; }
+
+    /**
+     * <p>The name of the container that holds the object lifecycle policy.</p>
+     */
+    inline void SetContainerName(Aws::String&& value) { m_containerNameHasBeenSet = true; m_containerName = std::move(value); }
+
+    /**
+     * <p>The name of the container that holds the object lifecycle policy.</p>
+     */
+    inline void SetContainerName(const char* value) { m_containerNameHasBeenSet = true; m_containerName.assign(value); }
+
+    /**
+     * <p>The name of the container that holds the object lifecycle policy.</p>
+     */
+    inline DeleteLifecyclePolicyRequest& WithContainerName(const Aws::String& value) { SetContainerName(value); return *this;}
+
+    /**
+     * <p>The name of the container that holds the object lifecycle policy.</p>
+     */
+    inline DeleteLifecyclePolicyRequest& WithContainerName(Aws::String&& value) { SetContainerName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the container that holds the object lifecycle policy.</p>
+     */
+    inline DeleteLifecyclePolicyRequest& WithContainerName(const char* value) { SetContainerName(value); return *this;}
+
+  private:
+
+    Aws::String m_containerName;
+    bool m_containerNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/DeleteLifecyclePolicyResult.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/mediastore/MediaStore_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace MediaStore
+{
+namespace Model
+{
+  class AWS_MEDIASTORE_API DeleteLifecyclePolicyResult
+  {
+  public:
+    DeleteLifecyclePolicyResult();
+    DeleteLifecyclePolicyResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DeleteLifecyclePolicyResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/DeleteMetricPolicyRequest.h

@@ -0,0 +1,93 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/MediaStoreRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_MEDIASTORE_API DeleteMetricPolicyRequest : public MediaStoreRequest
+  {
+  public:
+    DeleteMetricPolicyRequest();
+
+    // 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 "DeleteMetricPolicy"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the container that is associated with the metric policy that you
+     * want to delete.</p>
+     */
+    inline const Aws::String& GetContainerName() const{ return m_containerName; }
+
+    /**
+     * <p>The name of the container that is associated with the metric policy that you
+     * want to delete.</p>
+     */
+    inline bool ContainerNameHasBeenSet() const { return m_containerNameHasBeenSet; }
+
+    /**
+     * <p>The name of the container that is associated with the metric policy that you
+     * want to delete.</p>
+     */
+    inline void SetContainerName(const Aws::String& value) { m_containerNameHasBeenSet = true; m_containerName = value; }
+
+    /**
+     * <p>The name of the container that is associated with the metric policy that you
+     * want to delete.</p>
+     */
+    inline void SetContainerName(Aws::String&& value) { m_containerNameHasBeenSet = true; m_containerName = std::move(value); }
+
+    /**
+     * <p>The name of the container that is associated with the metric policy that you
+     * want to delete.</p>
+     */
+    inline void SetContainerName(const char* value) { m_containerNameHasBeenSet = true; m_containerName.assign(value); }
+
+    /**
+     * <p>The name of the container that is associated with the metric policy that you
+     * want to delete.</p>
+     */
+    inline DeleteMetricPolicyRequest& WithContainerName(const Aws::String& value) { SetContainerName(value); return *this;}
+
+    /**
+     * <p>The name of the container that is associated with the metric policy that you
+     * want to delete.</p>
+     */
+    inline DeleteMetricPolicyRequest& WithContainerName(Aws::String&& value) { SetContainerName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the container that is associated with the metric policy that you
+     * want to delete.</p>
+     */
+    inline DeleteMetricPolicyRequest& WithContainerName(const char* value) { SetContainerName(value); return *this;}
+
+  private:
+
+    Aws::String m_containerName;
+    bool m_containerNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/DeleteMetricPolicyResult.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/mediastore/MediaStore_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace MediaStore
+{
+namespace Model
+{
+  class AWS_MEDIASTORE_API DeleteMetricPolicyResult
+  {
+  public:
+    DeleteMetricPolicyResult();
+    DeleteMetricPolicyResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DeleteMetricPolicyResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/DescribeContainerRequest.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/MediaStoreRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_MEDIASTORE_API DescribeContainerRequest : public MediaStoreRequest
+  {
+  public:
+    DescribeContainerRequest();
+
+    // 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 "DescribeContainer"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the container to query.</p>
+     */
+    inline const Aws::String& GetContainerName() const{ return m_containerName; }
+
+    /**
+     * <p>The name of the container to query.</p>
+     */
+    inline bool ContainerNameHasBeenSet() const { return m_containerNameHasBeenSet; }
+
+    /**
+     * <p>The name of the container to query.</p>
+     */
+    inline void SetContainerName(const Aws::String& value) { m_containerNameHasBeenSet = true; m_containerName = value; }
+
+    /**
+     * <p>The name of the container to query.</p>
+     */
+    inline void SetContainerName(Aws::String&& value) { m_containerNameHasBeenSet = true; m_containerName = std::move(value); }
+
+    /**
+     * <p>The name of the container to query.</p>
+     */
+    inline void SetContainerName(const char* value) { m_containerNameHasBeenSet = true; m_containerName.assign(value); }
+
+    /**
+     * <p>The name of the container to query.</p>
+     */
+    inline DescribeContainerRequest& WithContainerName(const Aws::String& value) { SetContainerName(value); return *this;}
+
+    /**
+     * <p>The name of the container to query.</p>
+     */
+    inline DescribeContainerRequest& WithContainerName(Aws::String&& value) { SetContainerName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the container to query.</p>
+     */
+    inline DescribeContainerRequest& WithContainerName(const char* value) { SetContainerName(value); return *this;}
+
+  private:
+
+    Aws::String m_containerName;
+    bool m_containerNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/DescribeContainerResult.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/model/Container.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace MediaStore
+{
+namespace Model
+{
+  class AWS_MEDIASTORE_API DescribeContainerResult
+  {
+  public:
+    DescribeContainerResult();
+    DescribeContainerResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeContainerResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The name of the queried container.</p>
+     */
+    inline const Container& GetContainer() const{ return m_container; }
+
+    /**
+     * <p>The name of the queried container.</p>
+     */
+    inline void SetContainer(const Container& value) { m_container = value; }
+
+    /**
+     * <p>The name of the queried container.</p>
+     */
+    inline void SetContainer(Container&& value) { m_container = std::move(value); }
+
+    /**
+     * <p>The name of the queried container.</p>
+     */
+    inline DescribeContainerResult& WithContainer(const Container& value) { SetContainer(value); return *this;}
+
+    /**
+     * <p>The name of the queried container.</p>
+     */
+    inline DescribeContainerResult& WithContainer(Container&& value) { SetContainer(std::move(value)); return *this;}
+
+  private:
+
+    Container m_container;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/GetContainerPolicyRequest.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/MediaStoreRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_MEDIASTORE_API GetContainerPolicyRequest : public MediaStoreRequest
+  {
+  public:
+    GetContainerPolicyRequest();
+
+    // 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 "GetContainerPolicy"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the container. </p>
+     */
+    inline const Aws::String& GetContainerName() const{ return m_containerName; }
+
+    /**
+     * <p>The name of the container. </p>
+     */
+    inline bool ContainerNameHasBeenSet() const { return m_containerNameHasBeenSet; }
+
+    /**
+     * <p>The name of the container. </p>
+     */
+    inline void SetContainerName(const Aws::String& value) { m_containerNameHasBeenSet = true; m_containerName = value; }
+
+    /**
+     * <p>The name of the container. </p>
+     */
+    inline void SetContainerName(Aws::String&& value) { m_containerNameHasBeenSet = true; m_containerName = std::move(value); }
+
+    /**
+     * <p>The name of the container. </p>
+     */
+    inline void SetContainerName(const char* value) { m_containerNameHasBeenSet = true; m_containerName.assign(value); }
+
+    /**
+     * <p>The name of the container. </p>
+     */
+    inline GetContainerPolicyRequest& WithContainerName(const Aws::String& value) { SetContainerName(value); return *this;}
+
+    /**
+     * <p>The name of the container. </p>
+     */
+    inline GetContainerPolicyRequest& WithContainerName(Aws::String&& value) { SetContainerName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the container. </p>
+     */
+    inline GetContainerPolicyRequest& WithContainerName(const char* value) { SetContainerName(value); return *this;}
+
+  private:
+
+    Aws::String m_containerName;
+    bool m_containerNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/GetContainerPolicyResult.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/mediastore/MediaStore_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 MediaStore
+{
+namespace Model
+{
+  class AWS_MEDIASTORE_API GetContainerPolicyResult
+  {
+  public:
+    GetContainerPolicyResult();
+    GetContainerPolicyResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    GetContainerPolicyResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The contents of the access policy.</p>
+     */
+    inline const Aws::String& GetPolicy() const{ return m_policy; }
+
+    /**
+     * <p>The contents of the access policy.</p>
+     */
+    inline void SetPolicy(const Aws::String& value) { m_policy = value; }
+
+    /**
+     * <p>The contents of the access policy.</p>
+     */
+    inline void SetPolicy(Aws::String&& value) { m_policy = std::move(value); }
+
+    /**
+     * <p>The contents of the access policy.</p>
+     */
+    inline void SetPolicy(const char* value) { m_policy.assign(value); }
+
+    /**
+     * <p>The contents of the access policy.</p>
+     */
+    inline GetContainerPolicyResult& WithPolicy(const Aws::String& value) { SetPolicy(value); return *this;}
+
+    /**
+     * <p>The contents of the access policy.</p>
+     */
+    inline GetContainerPolicyResult& WithPolicy(Aws::String&& value) { SetPolicy(std::move(value)); return *this;}
+
+    /**
+     * <p>The contents of the access policy.</p>
+     */
+    inline GetContainerPolicyResult& WithPolicy(const char* value) { SetPolicy(value); return *this;}
+
+  private:
+
+    Aws::String m_policy;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/GetCorsPolicyRequest.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/MediaStoreRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_MEDIASTORE_API GetCorsPolicyRequest : public MediaStoreRequest
+  {
+  public:
+    GetCorsPolicyRequest();
+
+    // 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 "GetCorsPolicy"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the container that the policy is assigned to.</p>
+     */
+    inline const Aws::String& GetContainerName() const{ return m_containerName; }
+
+    /**
+     * <p>The name of the container that the policy is assigned to.</p>
+     */
+    inline bool ContainerNameHasBeenSet() const { return m_containerNameHasBeenSet; }
+
+    /**
+     * <p>The name of the container that the policy is assigned to.</p>
+     */
+    inline void SetContainerName(const Aws::String& value) { m_containerNameHasBeenSet = true; m_containerName = value; }
+
+    /**
+     * <p>The name of the container that the policy is assigned to.</p>
+     */
+    inline void SetContainerName(Aws::String&& value) { m_containerNameHasBeenSet = true; m_containerName = std::move(value); }
+
+    /**
+     * <p>The name of the container that the policy is assigned to.</p>
+     */
+    inline void SetContainerName(const char* value) { m_containerNameHasBeenSet = true; m_containerName.assign(value); }
+
+    /**
+     * <p>The name of the container that the policy is assigned to.</p>
+     */
+    inline GetCorsPolicyRequest& WithContainerName(const Aws::String& value) { SetContainerName(value); return *this;}
+
+    /**
+     * <p>The name of the container that the policy is assigned to.</p>
+     */
+    inline GetCorsPolicyRequest& WithContainerName(Aws::String&& value) { SetContainerName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the container that the policy is assigned to.</p>
+     */
+    inline GetCorsPolicyRequest& WithContainerName(const char* value) { SetContainerName(value); return *this;}
+
+  private:
+
+    Aws::String m_containerName;
+    bool m_containerNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/GetCorsPolicyResult.h

@@ -0,0 +1,78 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/mediastore/model/CorsRule.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace MediaStore
+{
+namespace Model
+{
+  class AWS_MEDIASTORE_API GetCorsPolicyResult
+  {
+  public:
+    GetCorsPolicyResult();
+    GetCorsPolicyResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    GetCorsPolicyResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The CORS policy assigned to the container.</p>
+     */
+    inline const Aws::Vector<CorsRule>& GetCorsPolicy() const{ return m_corsPolicy; }
+
+    /**
+     * <p>The CORS policy assigned to the container.</p>
+     */
+    inline void SetCorsPolicy(const Aws::Vector<CorsRule>& value) { m_corsPolicy = value; }
+
+    /**
+     * <p>The CORS policy assigned to the container.</p>
+     */
+    inline void SetCorsPolicy(Aws::Vector<CorsRule>&& value) { m_corsPolicy = std::move(value); }
+
+    /**
+     * <p>The CORS policy assigned to the container.</p>
+     */
+    inline GetCorsPolicyResult& WithCorsPolicy(const Aws::Vector<CorsRule>& value) { SetCorsPolicy(value); return *this;}
+
+    /**
+     * <p>The CORS policy assigned to the container.</p>
+     */
+    inline GetCorsPolicyResult& WithCorsPolicy(Aws::Vector<CorsRule>&& value) { SetCorsPolicy(std::move(value)); return *this;}
+
+    /**
+     * <p>The CORS policy assigned to the container.</p>
+     */
+    inline GetCorsPolicyResult& AddCorsPolicy(const CorsRule& value) { m_corsPolicy.push_back(value); return *this; }
+
+    /**
+     * <p>The CORS policy assigned to the container.</p>
+     */
+    inline GetCorsPolicyResult& AddCorsPolicy(CorsRule&& value) { m_corsPolicy.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::Vector<CorsRule> m_corsPolicy;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/GetLifecyclePolicyRequest.h

@@ -0,0 +1,93 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/MediaStoreRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_MEDIASTORE_API GetLifecyclePolicyRequest : public MediaStoreRequest
+  {
+  public:
+    GetLifecyclePolicyRequest();
+
+    // 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 "GetLifecyclePolicy"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the container that the object lifecycle policy is assigned
+     * to.</p>
+     */
+    inline const Aws::String& GetContainerName() const{ return m_containerName; }
+
+    /**
+     * <p>The name of the container that the object lifecycle policy is assigned
+     * to.</p>
+     */
+    inline bool ContainerNameHasBeenSet() const { return m_containerNameHasBeenSet; }
+
+    /**
+     * <p>The name of the container that the object lifecycle policy is assigned
+     * to.</p>
+     */
+    inline void SetContainerName(const Aws::String& value) { m_containerNameHasBeenSet = true; m_containerName = value; }
+
+    /**
+     * <p>The name of the container that the object lifecycle policy is assigned
+     * to.</p>
+     */
+    inline void SetContainerName(Aws::String&& value) { m_containerNameHasBeenSet = true; m_containerName = std::move(value); }
+
+    /**
+     * <p>The name of the container that the object lifecycle policy is assigned
+     * to.</p>
+     */
+    inline void SetContainerName(const char* value) { m_containerNameHasBeenSet = true; m_containerName.assign(value); }
+
+    /**
+     * <p>The name of the container that the object lifecycle policy is assigned
+     * to.</p>
+     */
+    inline GetLifecyclePolicyRequest& WithContainerName(const Aws::String& value) { SetContainerName(value); return *this;}
+
+    /**
+     * <p>The name of the container that the object lifecycle policy is assigned
+     * to.</p>
+     */
+    inline GetLifecyclePolicyRequest& WithContainerName(Aws::String&& value) { SetContainerName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the container that the object lifecycle policy is assigned
+     * to.</p>
+     */
+    inline GetLifecyclePolicyRequest& WithContainerName(const char* value) { SetContainerName(value); return *this;}
+
+  private:
+
+    Aws::String m_containerName;
+    bool m_containerNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/GetLifecyclePolicyResult.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/mediastore/MediaStore_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 MediaStore
+{
+namespace Model
+{
+  class AWS_MEDIASTORE_API GetLifecyclePolicyResult
+  {
+  public:
+    GetLifecyclePolicyResult();
+    GetLifecyclePolicyResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    GetLifecyclePolicyResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The object lifecycle policy that is assigned to the container.</p>
+     */
+    inline const Aws::String& GetLifecyclePolicy() const{ return m_lifecyclePolicy; }
+
+    /**
+     * <p>The object lifecycle policy that is assigned to the container.</p>
+     */
+    inline void SetLifecyclePolicy(const Aws::String& value) { m_lifecyclePolicy = value; }
+
+    /**
+     * <p>The object lifecycle policy that is assigned to the container.</p>
+     */
+    inline void SetLifecyclePolicy(Aws::String&& value) { m_lifecyclePolicy = std::move(value); }
+
+    /**
+     * <p>The object lifecycle policy that is assigned to the container.</p>
+     */
+    inline void SetLifecyclePolicy(const char* value) { m_lifecyclePolicy.assign(value); }
+
+    /**
+     * <p>The object lifecycle policy that is assigned to the container.</p>
+     */
+    inline GetLifecyclePolicyResult& WithLifecyclePolicy(const Aws::String& value) { SetLifecyclePolicy(value); return *this;}
+
+    /**
+     * <p>The object lifecycle policy that is assigned to the container.</p>
+     */
+    inline GetLifecyclePolicyResult& WithLifecyclePolicy(Aws::String&& value) { SetLifecyclePolicy(std::move(value)); return *this;}
+
+    /**
+     * <p>The object lifecycle policy that is assigned to the container.</p>
+     */
+    inline GetLifecyclePolicyResult& WithLifecyclePolicy(const char* value) { SetLifecyclePolicy(value); return *this;}
+
+  private:
+
+    Aws::String m_lifecyclePolicy;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/GetMetricPolicyRequest.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/MediaStoreRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_MEDIASTORE_API GetMetricPolicyRequest : public MediaStoreRequest
+  {
+  public:
+    GetMetricPolicyRequest();
+
+    // 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 "GetMetricPolicy"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the container that is associated with the metric policy.</p>
+     */
+    inline const Aws::String& GetContainerName() const{ return m_containerName; }
+
+    /**
+     * <p>The name of the container that is associated with the metric policy.</p>
+     */
+    inline bool ContainerNameHasBeenSet() const { return m_containerNameHasBeenSet; }
+
+    /**
+     * <p>The name of the container that is associated with the metric policy.</p>
+     */
+    inline void SetContainerName(const Aws::String& value) { m_containerNameHasBeenSet = true; m_containerName = value; }
+
+    /**
+     * <p>The name of the container that is associated with the metric policy.</p>
+     */
+    inline void SetContainerName(Aws::String&& value) { m_containerNameHasBeenSet = true; m_containerName = std::move(value); }
+
+    /**
+     * <p>The name of the container that is associated with the metric policy.</p>
+     */
+    inline void SetContainerName(const char* value) { m_containerNameHasBeenSet = true; m_containerName.assign(value); }
+
+    /**
+     * <p>The name of the container that is associated with the metric policy.</p>
+     */
+    inline GetMetricPolicyRequest& WithContainerName(const Aws::String& value) { SetContainerName(value); return *this;}
+
+    /**
+     * <p>The name of the container that is associated with the metric policy.</p>
+     */
+    inline GetMetricPolicyRequest& WithContainerName(Aws::String&& value) { SetContainerName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the container that is associated with the metric policy.</p>
+     */
+    inline GetMetricPolicyRequest& WithContainerName(const char* value) { SetContainerName(value); return *this;}
+
+  private:
+
+    Aws::String m_containerName;
+    bool m_containerNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/GetMetricPolicyResult.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/model/MetricPolicy.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace MediaStore
+{
+namespace Model
+{
+  class AWS_MEDIASTORE_API GetMetricPolicyResult
+  {
+  public:
+    GetMetricPolicyResult();
+    GetMetricPolicyResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    GetMetricPolicyResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The metric policy that is associated with the specific container.</p>
+     */
+    inline const MetricPolicy& GetMetricPolicy() const{ return m_metricPolicy; }
+
+    /**
+     * <p>The metric policy that is associated with the specific container.</p>
+     */
+    inline void SetMetricPolicy(const MetricPolicy& value) { m_metricPolicy = value; }
+
+    /**
+     * <p>The metric policy that is associated with the specific container.</p>
+     */
+    inline void SetMetricPolicy(MetricPolicy&& value) { m_metricPolicy = std::move(value); }
+
+    /**
+     * <p>The metric policy that is associated with the specific container.</p>
+     */
+    inline GetMetricPolicyResult& WithMetricPolicy(const MetricPolicy& value) { SetMetricPolicy(value); return *this;}
+
+    /**
+     * <p>The metric policy that is associated with the specific container.</p>
+     */
+    inline GetMetricPolicyResult& WithMetricPolicy(MetricPolicy&& value) { SetMetricPolicy(std::move(value)); return *this;}
+
+  private:
+
+    MetricPolicy m_metricPolicy;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/ListContainersRequest.h

@@ -0,0 +1,137 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/MediaStoreRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_MEDIASTORE_API ListContainersRequest : public MediaStoreRequest
+  {
+  public:
+    ListContainersRequest();
+
+    // 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 "ListContainers"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>Only if you used <code>MaxResults</code> in the first command, enter the
+     * token (which was included in the previous response) to obtain the next set of
+     * containers. This token is included in a response only if there actually are more
+     * containers to list.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>Only if you used <code>MaxResults</code> in the first command, enter the
+     * token (which was included in the previous response) to obtain the next set of
+     * containers. This token is included in a response only if there actually are more
+     * containers to list.</p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>Only if you used <code>MaxResults</code> in the first command, enter the
+     * token (which was included in the previous response) to obtain the next set of
+     * containers. This token is included in a response only if there actually are more
+     * containers to list.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>Only if you used <code>MaxResults</code> in the first command, enter the
+     * token (which was included in the previous response) to obtain the next set of
+     * containers. This token is included in a response only if there actually are more
+     * containers to list.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>Only if you used <code>MaxResults</code> in the first command, enter the
+     * token (which was included in the previous response) to obtain the next set of
+     * containers. This token is included in a response only if there actually are more
+     * containers to list.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>Only if you used <code>MaxResults</code> in the first command, enter the
+     * token (which was included in the previous response) to obtain the next set of
+     * containers. This token is included in a response only if there actually are more
+     * containers to list.</p>
+     */
+    inline ListContainersRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>Only if you used <code>MaxResults</code> in the first command, enter the
+     * token (which was included in the previous response) to obtain the next set of
+     * containers. This token is included in a response only if there actually are more
+     * containers to list.</p>
+     */
+    inline ListContainersRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>Only if you used <code>MaxResults</code> in the first command, enter the
+     * token (which was included in the previous response) to obtain the next set of
+     * containers. This token is included in a response only if there actually are more
+     * containers to list.</p>
+     */
+    inline ListContainersRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>Enter the maximum number of containers in the response. Use from 1 to 255
+     * characters. </p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>Enter the maximum number of containers in the response. Use from 1 to 255
+     * characters. </p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>Enter the maximum number of containers in the response. Use from 1 to 255
+     * characters. </p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>Enter the maximum number of containers in the response. Use from 1 to 255
+     * characters. </p>
+     */
+    inline ListContainersRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+  private:
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/ListContainersResult.h

@@ -0,0 +1,138 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/mediastore/model/Container.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace MediaStore
+{
+namespace Model
+{
+  class AWS_MEDIASTORE_API ListContainersResult
+  {
+  public:
+    ListContainersResult();
+    ListContainersResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListContainersResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The names of the containers.</p>
+     */
+    inline const Aws::Vector<Container>& GetContainers() const{ return m_containers; }
+
+    /**
+     * <p>The names of the containers.</p>
+     */
+    inline void SetContainers(const Aws::Vector<Container>& value) { m_containers = value; }
+
+    /**
+     * <p>The names of the containers.</p>
+     */
+    inline void SetContainers(Aws::Vector<Container>&& value) { m_containers = std::move(value); }
+
+    /**
+     * <p>The names of the containers.</p>
+     */
+    inline ListContainersResult& WithContainers(const Aws::Vector<Container>& value) { SetContainers(value); return *this;}
+
+    /**
+     * <p>The names of the containers.</p>
+     */
+    inline ListContainersResult& WithContainers(Aws::Vector<Container>&& value) { SetContainers(std::move(value)); return *this;}
+
+    /**
+     * <p>The names of the containers.</p>
+     */
+    inline ListContainersResult& AddContainers(const Container& value) { m_containers.push_back(value); return *this; }
+
+    /**
+     * <p>The names of the containers.</p>
+     */
+    inline ListContainersResult& AddContainers(Container&& value) { m_containers.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p> <code>NextToken</code> is the token to use in the next call to
+     * <code>ListContainers</code>. This token is returned only if you included the
+     * <code>MaxResults</code> tag in the original command, and only if there are still
+     * containers to return. </p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p> <code>NextToken</code> is the token to use in the next call to
+     * <code>ListContainers</code>. This token is returned only if you included the
+     * <code>MaxResults</code> tag in the original command, and only if there are still
+     * containers to return. </p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p> <code>NextToken</code> is the token to use in the next call to
+     * <code>ListContainers</code>. This token is returned only if you included the
+     * <code>MaxResults</code> tag in the original command, and only if there are still
+     * containers to return. </p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p> <code>NextToken</code> is the token to use in the next call to
+     * <code>ListContainers</code>. This token is returned only if you included the
+     * <code>MaxResults</code> tag in the original command, and only if there are still
+     * containers to return. </p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p> <code>NextToken</code> is the token to use in the next call to
+     * <code>ListContainers</code>. This token is returned only if you included the
+     * <code>MaxResults</code> tag in the original command, and only if there are still
+     * containers to return. </p>
+     */
+    inline ListContainersResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p> <code>NextToken</code> is the token to use in the next call to
+     * <code>ListContainers</code>. This token is returned only if you included the
+     * <code>MaxResults</code> tag in the original command, and only if there are still
+     * containers to return. </p>
+     */
+    inline ListContainersResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p> <code>NextToken</code> is the token to use in the next call to
+     * <code>ListContainers</code>. This token is returned only if you included the
+     * <code>MaxResults</code> tag in the original command, and only if there are still
+     * containers to return. </p>
+     */
+    inline ListContainersResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    Aws::Vector<Container> m_containers;
+
+    Aws::String m_nextToken;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

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

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/MediaStoreRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_MEDIASTORE_API ListTagsForResourceRequest : public MediaStoreRequest
+  {
+  public:
+    ListTagsForResourceRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "ListTagsForResource"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container.</p>
+     */
+    inline const Aws::String& GetResource() const{ return m_resource; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container.</p>
+     */
+    inline bool ResourceHasBeenSet() const { return m_resourceHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container.</p>
+     */
+    inline void SetResource(const Aws::String& value) { m_resourceHasBeenSet = true; m_resource = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container.</p>
+     */
+    inline void SetResource(Aws::String&& value) { m_resourceHasBeenSet = true; m_resource = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container.</p>
+     */
+    inline void SetResource(const char* value) { m_resourceHasBeenSet = true; m_resource.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container.</p>
+     */
+    inline ListTagsForResourceRequest& WithResource(const Aws::String& value) { SetResource(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container.</p>
+     */
+    inline ListTagsForResourceRequest& WithResource(Aws::String&& value) { SetResource(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container.</p>
+     */
+    inline ListTagsForResourceRequest& WithResource(const char* value) { SetResource(value); return *this;}
+
+  private:
+
+    Aws::String m_resource;
+    bool m_resourceHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

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

@@ -0,0 +1,78 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/mediastore/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace MediaStore
+{
+namespace Model
+{
+  class AWS_MEDIASTORE_API ListTagsForResourceResult
+  {
+  public:
+    ListTagsForResourceResult();
+    ListTagsForResourceResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListTagsForResourceResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>An array of key:value pairs that are assigned to the container.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>An array of key:value pairs that are assigned to the container.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tags = value; }
+
+    /**
+     * <p>An array of key:value pairs that are assigned to the container.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tags = std::move(value); }
+
+    /**
+     * <p>An array of key:value pairs that are assigned to the container.</p>
+     */
+    inline ListTagsForResourceResult& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>An array of key:value pairs that are assigned to the container.</p>
+     */
+    inline ListTagsForResourceResult& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>An array of key:value pairs that are assigned to the container.</p>
+     */
+    inline ListTagsForResourceResult& AddTags(const Tag& value) { m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>An array of key:value pairs that are assigned to the container.</p>
+     */
+    inline ListTagsForResourceResult& AddTags(Tag&& value) { m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::Vector<Tag> m_tags;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/MethodName.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/mediastore/MediaStore_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+  enum class MethodName
+  {
+    NOT_SET,
+    PUT,
+    GET_,
+    DELETE_,
+    HEAD
+  };
+
+namespace MethodNameMapper
+{
+AWS_MEDIASTORE_API MethodName GetMethodNameForName(const Aws::String& name);
+
+AWS_MEDIASTORE_API Aws::String GetNameForMethodName(MethodName value);
+} // namespace MethodNameMapper
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/MetricPolicy.h

@@ -0,0 +1,171 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/model/ContainerLevelMetrics.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/mediastore/model/MetricPolicyRule.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   * <p>The metric policy that is associated with the container. A metric policy
+   * allows AWS Elemental MediaStore to send metrics to Amazon CloudWatch. In the
+   * policy, you must indicate whether you want MediaStore to send container-level
+   * metrics. You can also include rules to define groups of objects that you want
+   * MediaStore to send object-level metrics for.</p> <p>To view examples of how to
+   * construct a metric policy for your use case, see <a
+   * href="https://docs.aws.amazon.com/mediastore/latest/ug/policies-metric-examples.html">Example
+   * Metric Policies</a>.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/MetricPolicy">AWS
+   * API Reference</a></p>
+   */
+  class AWS_MEDIASTORE_API MetricPolicy
+  {
+  public:
+    MetricPolicy();
+    MetricPolicy(Aws::Utils::Json::JsonView jsonValue);
+    MetricPolicy& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>A setting to enable or disable metrics at the container level.</p>
+     */
+    inline const ContainerLevelMetrics& GetContainerLevelMetrics() const{ return m_containerLevelMetrics; }
+
+    /**
+     * <p>A setting to enable or disable metrics at the container level.</p>
+     */
+    inline bool ContainerLevelMetricsHasBeenSet() const { return m_containerLevelMetricsHasBeenSet; }
+
+    /**
+     * <p>A setting to enable or disable metrics at the container level.</p>
+     */
+    inline void SetContainerLevelMetrics(const ContainerLevelMetrics& value) { m_containerLevelMetricsHasBeenSet = true; m_containerLevelMetrics = value; }
+
+    /**
+     * <p>A setting to enable or disable metrics at the container level.</p>
+     */
+    inline void SetContainerLevelMetrics(ContainerLevelMetrics&& value) { m_containerLevelMetricsHasBeenSet = true; m_containerLevelMetrics = std::move(value); }
+
+    /**
+     * <p>A setting to enable or disable metrics at the container level.</p>
+     */
+    inline MetricPolicy& WithContainerLevelMetrics(const ContainerLevelMetrics& value) { SetContainerLevelMetrics(value); return *this;}
+
+    /**
+     * <p>A setting to enable or disable metrics at the container level.</p>
+     */
+    inline MetricPolicy& WithContainerLevelMetrics(ContainerLevelMetrics&& value) { SetContainerLevelMetrics(std::move(value)); return *this;}
+
+
+    /**
+     * <p>A parameter that holds an array of rules that enable metrics at the object
+     * level. This parameter is optional, but if you choose to include it, you must
+     * also include at least one rule. By default, you can include up to five rules.
+     * You can also <a
+     * href="https://console.aws.amazon.com/servicequotas/home?region=us-east-1#!/services/mediastore/quotas">request
+     * a quota increase</a> to allow up to 300 rules per policy.</p>
+     */
+    inline const Aws::Vector<MetricPolicyRule>& GetMetricPolicyRules() const{ return m_metricPolicyRules; }
+
+    /**
+     * <p>A parameter that holds an array of rules that enable metrics at the object
+     * level. This parameter is optional, but if you choose to include it, you must
+     * also include at least one rule. By default, you can include up to five rules.
+     * You can also <a
+     * href="https://console.aws.amazon.com/servicequotas/home?region=us-east-1#!/services/mediastore/quotas">request
+     * a quota increase</a> to allow up to 300 rules per policy.</p>
+     */
+    inline bool MetricPolicyRulesHasBeenSet() const { return m_metricPolicyRulesHasBeenSet; }
+
+    /**
+     * <p>A parameter that holds an array of rules that enable metrics at the object
+     * level. This parameter is optional, but if you choose to include it, you must
+     * also include at least one rule. By default, you can include up to five rules.
+     * You can also <a
+     * href="https://console.aws.amazon.com/servicequotas/home?region=us-east-1#!/services/mediastore/quotas">request
+     * a quota increase</a> to allow up to 300 rules per policy.</p>
+     */
+    inline void SetMetricPolicyRules(const Aws::Vector<MetricPolicyRule>& value) { m_metricPolicyRulesHasBeenSet = true; m_metricPolicyRules = value; }
+
+    /**
+     * <p>A parameter that holds an array of rules that enable metrics at the object
+     * level. This parameter is optional, but if you choose to include it, you must
+     * also include at least one rule. By default, you can include up to five rules.
+     * You can also <a
+     * href="https://console.aws.amazon.com/servicequotas/home?region=us-east-1#!/services/mediastore/quotas">request
+     * a quota increase</a> to allow up to 300 rules per policy.</p>
+     */
+    inline void SetMetricPolicyRules(Aws::Vector<MetricPolicyRule>&& value) { m_metricPolicyRulesHasBeenSet = true; m_metricPolicyRules = std::move(value); }
+
+    /**
+     * <p>A parameter that holds an array of rules that enable metrics at the object
+     * level. This parameter is optional, but if you choose to include it, you must
+     * also include at least one rule. By default, you can include up to five rules.
+     * You can also <a
+     * href="https://console.aws.amazon.com/servicequotas/home?region=us-east-1#!/services/mediastore/quotas">request
+     * a quota increase</a> to allow up to 300 rules per policy.</p>
+     */
+    inline MetricPolicy& WithMetricPolicyRules(const Aws::Vector<MetricPolicyRule>& value) { SetMetricPolicyRules(value); return *this;}
+
+    /**
+     * <p>A parameter that holds an array of rules that enable metrics at the object
+     * level. This parameter is optional, but if you choose to include it, you must
+     * also include at least one rule. By default, you can include up to five rules.
+     * You can also <a
+     * href="https://console.aws.amazon.com/servicequotas/home?region=us-east-1#!/services/mediastore/quotas">request
+     * a quota increase</a> to allow up to 300 rules per policy.</p>
+     */
+    inline MetricPolicy& WithMetricPolicyRules(Aws::Vector<MetricPolicyRule>&& value) { SetMetricPolicyRules(std::move(value)); return *this;}
+
+    /**
+     * <p>A parameter that holds an array of rules that enable metrics at the object
+     * level. This parameter is optional, but if you choose to include it, you must
+     * also include at least one rule. By default, you can include up to five rules.
+     * You can also <a
+     * href="https://console.aws.amazon.com/servicequotas/home?region=us-east-1#!/services/mediastore/quotas">request
+     * a quota increase</a> to allow up to 300 rules per policy.</p>
+     */
+    inline MetricPolicy& AddMetricPolicyRules(const MetricPolicyRule& value) { m_metricPolicyRulesHasBeenSet = true; m_metricPolicyRules.push_back(value); return *this; }
+
+    /**
+     * <p>A parameter that holds an array of rules that enable metrics at the object
+     * level. This parameter is optional, but if you choose to include it, you must
+     * also include at least one rule. By default, you can include up to five rules.
+     * You can also <a
+     * href="https://console.aws.amazon.com/servicequotas/home?region=us-east-1#!/services/mediastore/quotas">request
+     * a quota increase</a> to allow up to 300 rules per policy.</p>
+     */
+    inline MetricPolicy& AddMetricPolicyRules(MetricPolicyRule&& value) { m_metricPolicyRulesHasBeenSet = true; m_metricPolicyRules.push_back(std::move(value)); return *this; }
+
+  private:
+
+    ContainerLevelMetrics m_containerLevelMetrics;
+    bool m_containerLevelMetricsHasBeenSet;
+
+    Aws::Vector<MetricPolicyRule> m_metricPolicyRules;
+    bool m_metricPolicyRulesHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/MetricPolicyRule.h

@@ -0,0 +1,146 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_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 MediaStore
+{
+namespace Model
+{
+
+  /**
+   * <p>A setting that enables metrics at the object level. Each rule contains an
+   * object group and an object group name. If the policy includes the
+   * MetricPolicyRules parameter, you must include at least one rule. Each metric
+   * policy can include up to five rules by default. You can also <a
+   * href="https://console.aws.amazon.com/servicequotas/home?region=us-east-1#!/services/mediastore/quotas">request
+   * a quota increase</a> to allow up to 300 rules per policy.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/MetricPolicyRule">AWS
+   * API Reference</a></p>
+   */
+  class AWS_MEDIASTORE_API MetricPolicyRule
+  {
+  public:
+    MetricPolicyRule();
+    MetricPolicyRule(Aws::Utils::Json::JsonView jsonValue);
+    MetricPolicyRule& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>A path or file name that defines which objects to include in the group.
+     * Wildcards (*) are acceptable.</p>
+     */
+    inline const Aws::String& GetObjectGroup() const{ return m_objectGroup; }
+
+    /**
+     * <p>A path or file name that defines which objects to include in the group.
+     * Wildcards (*) are acceptable.</p>
+     */
+    inline bool ObjectGroupHasBeenSet() const { return m_objectGroupHasBeenSet; }
+
+    /**
+     * <p>A path or file name that defines which objects to include in the group.
+     * Wildcards (*) are acceptable.</p>
+     */
+    inline void SetObjectGroup(const Aws::String& value) { m_objectGroupHasBeenSet = true; m_objectGroup = value; }
+
+    /**
+     * <p>A path or file name that defines which objects to include in the group.
+     * Wildcards (*) are acceptable.</p>
+     */
+    inline void SetObjectGroup(Aws::String&& value) { m_objectGroupHasBeenSet = true; m_objectGroup = std::move(value); }
+
+    /**
+     * <p>A path or file name that defines which objects to include in the group.
+     * Wildcards (*) are acceptable.</p>
+     */
+    inline void SetObjectGroup(const char* value) { m_objectGroupHasBeenSet = true; m_objectGroup.assign(value); }
+
+    /**
+     * <p>A path or file name that defines which objects to include in the group.
+     * Wildcards (*) are acceptable.</p>
+     */
+    inline MetricPolicyRule& WithObjectGroup(const Aws::String& value) { SetObjectGroup(value); return *this;}
+
+    /**
+     * <p>A path or file name that defines which objects to include in the group.
+     * Wildcards (*) are acceptable.</p>
+     */
+    inline MetricPolicyRule& WithObjectGroup(Aws::String&& value) { SetObjectGroup(std::move(value)); return *this;}
+
+    /**
+     * <p>A path or file name that defines which objects to include in the group.
+     * Wildcards (*) are acceptable.</p>
+     */
+    inline MetricPolicyRule& WithObjectGroup(const char* value) { SetObjectGroup(value); return *this;}
+
+
+    /**
+     * <p>A name that allows you to refer to the object group.</p>
+     */
+    inline const Aws::String& GetObjectGroupName() const{ return m_objectGroupName; }
+
+    /**
+     * <p>A name that allows you to refer to the object group.</p>
+     */
+    inline bool ObjectGroupNameHasBeenSet() const { return m_objectGroupNameHasBeenSet; }
+
+    /**
+     * <p>A name that allows you to refer to the object group.</p>
+     */
+    inline void SetObjectGroupName(const Aws::String& value) { m_objectGroupNameHasBeenSet = true; m_objectGroupName = value; }
+
+    /**
+     * <p>A name that allows you to refer to the object group.</p>
+     */
+    inline void SetObjectGroupName(Aws::String&& value) { m_objectGroupNameHasBeenSet = true; m_objectGroupName = std::move(value); }
+
+    /**
+     * <p>A name that allows you to refer to the object group.</p>
+     */
+    inline void SetObjectGroupName(const char* value) { m_objectGroupNameHasBeenSet = true; m_objectGroupName.assign(value); }
+
+    /**
+     * <p>A name that allows you to refer to the object group.</p>
+     */
+    inline MetricPolicyRule& WithObjectGroupName(const Aws::String& value) { SetObjectGroupName(value); return *this;}
+
+    /**
+     * <p>A name that allows you to refer to the object group.</p>
+     */
+    inline MetricPolicyRule& WithObjectGroupName(Aws::String&& value) { SetObjectGroupName(std::move(value)); return *this;}
+
+    /**
+     * <p>A name that allows you to refer to the object group.</p>
+     */
+    inline MetricPolicyRule& WithObjectGroupName(const char* value) { SetObjectGroupName(value); return *this;}
+
+  private:
+
+    Aws::String m_objectGroup;
+    bool m_objectGroupHasBeenSet;
+
+    Aws::String m_objectGroupName;
+    bool m_objectGroupNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/PutContainerPolicyRequest.h

@@ -0,0 +1,145 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/MediaStoreRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_MEDIASTORE_API PutContainerPolicyRequest : public MediaStoreRequest
+  {
+  public:
+    PutContainerPolicyRequest();
+
+    // 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 "PutContainerPolicy"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the container.</p>
+     */
+    inline const Aws::String& GetContainerName() const{ return m_containerName; }
+
+    /**
+     * <p>The name of the container.</p>
+     */
+    inline bool ContainerNameHasBeenSet() const { return m_containerNameHasBeenSet; }
+
+    /**
+     * <p>The name of the container.</p>
+     */
+    inline void SetContainerName(const Aws::String& value) { m_containerNameHasBeenSet = true; m_containerName = value; }
+
+    /**
+     * <p>The name of the container.</p>
+     */
+    inline void SetContainerName(Aws::String&& value) { m_containerNameHasBeenSet = true; m_containerName = std::move(value); }
+
+    /**
+     * <p>The name of the container.</p>
+     */
+    inline void SetContainerName(const char* value) { m_containerNameHasBeenSet = true; m_containerName.assign(value); }
+
+    /**
+     * <p>The name of the container.</p>
+     */
+    inline PutContainerPolicyRequest& WithContainerName(const Aws::String& value) { SetContainerName(value); return *this;}
+
+    /**
+     * <p>The name of the container.</p>
+     */
+    inline PutContainerPolicyRequest& WithContainerName(Aws::String&& value) { SetContainerName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the container.</p>
+     */
+    inline PutContainerPolicyRequest& WithContainerName(const char* value) { SetContainerName(value); return *this;}
+
+
+    /**
+     * <p>The contents of the policy, which includes the following: </p> <ul> <li>
+     * <p>One <code>Version</code> tag</p> </li> <li> <p>One <code>Statement</code> tag
+     * that contains the standard tags for the policy.</p> </li> </ul>
+     */
+    inline const Aws::String& GetPolicy() const{ return m_policy; }
+
+    /**
+     * <p>The contents of the policy, which includes the following: </p> <ul> <li>
+     * <p>One <code>Version</code> tag</p> </li> <li> <p>One <code>Statement</code> tag
+     * that contains the standard tags for the policy.</p> </li> </ul>
+     */
+    inline bool PolicyHasBeenSet() const { return m_policyHasBeenSet; }
+
+    /**
+     * <p>The contents of the policy, which includes the following: </p> <ul> <li>
+     * <p>One <code>Version</code> tag</p> </li> <li> <p>One <code>Statement</code> tag
+     * that contains the standard tags for the policy.</p> </li> </ul>
+     */
+    inline void SetPolicy(const Aws::String& value) { m_policyHasBeenSet = true; m_policy = value; }
+
+    /**
+     * <p>The contents of the policy, which includes the following: </p> <ul> <li>
+     * <p>One <code>Version</code> tag</p> </li> <li> <p>One <code>Statement</code> tag
+     * that contains the standard tags for the policy.</p> </li> </ul>
+     */
+    inline void SetPolicy(Aws::String&& value) { m_policyHasBeenSet = true; m_policy = std::move(value); }
+
+    /**
+     * <p>The contents of the policy, which includes the following: </p> <ul> <li>
+     * <p>One <code>Version</code> tag</p> </li> <li> <p>One <code>Statement</code> tag
+     * that contains the standard tags for the policy.</p> </li> </ul>
+     */
+    inline void SetPolicy(const char* value) { m_policyHasBeenSet = true; m_policy.assign(value); }
+
+    /**
+     * <p>The contents of the policy, which includes the following: </p> <ul> <li>
+     * <p>One <code>Version</code> tag</p> </li> <li> <p>One <code>Statement</code> tag
+     * that contains the standard tags for the policy.</p> </li> </ul>
+     */
+    inline PutContainerPolicyRequest& WithPolicy(const Aws::String& value) { SetPolicy(value); return *this;}
+
+    /**
+     * <p>The contents of the policy, which includes the following: </p> <ul> <li>
+     * <p>One <code>Version</code> tag</p> </li> <li> <p>One <code>Statement</code> tag
+     * that contains the standard tags for the policy.</p> </li> </ul>
+     */
+    inline PutContainerPolicyRequest& WithPolicy(Aws::String&& value) { SetPolicy(std::move(value)); return *this;}
+
+    /**
+     * <p>The contents of the policy, which includes the following: </p> <ul> <li>
+     * <p>One <code>Version</code> tag</p> </li> <li> <p>One <code>Statement</code> tag
+     * that contains the standard tags for the policy.</p> </li> </ul>
+     */
+    inline PutContainerPolicyRequest& WithPolicy(const char* value) { SetPolicy(value); return *this;}
+
+  private:
+
+    Aws::String m_containerName;
+    bool m_containerNameHasBeenSet;
+
+    Aws::String m_policy;
+    bool m_policyHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/PutContainerPolicyResult.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/mediastore/MediaStore_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace MediaStore
+{
+namespace Model
+{
+  class AWS_MEDIASTORE_API PutContainerPolicyResult
+  {
+  public:
+    PutContainerPolicyResult();
+    PutContainerPolicyResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    PutContainerPolicyResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/PutCorsPolicyRequest.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/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/MediaStoreRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/mediastore/model/CorsRule.h>
+#include <utility>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_MEDIASTORE_API PutCorsPolicyRequest : public MediaStoreRequest
+  {
+  public:
+    PutCorsPolicyRequest();
+
+    // 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 "PutCorsPolicy"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the container that you want to assign the CORS policy to.</p>
+     */
+    inline const Aws::String& GetContainerName() const{ return m_containerName; }
+
+    /**
+     * <p>The name of the container that you want to assign the CORS policy to.</p>
+     */
+    inline bool ContainerNameHasBeenSet() const { return m_containerNameHasBeenSet; }
+
+    /**
+     * <p>The name of the container that you want to assign the CORS policy to.</p>
+     */
+    inline void SetContainerName(const Aws::String& value) { m_containerNameHasBeenSet = true; m_containerName = value; }
+
+    /**
+     * <p>The name of the container that you want to assign the CORS policy to.</p>
+     */
+    inline void SetContainerName(Aws::String&& value) { m_containerNameHasBeenSet = true; m_containerName = std::move(value); }
+
+    /**
+     * <p>The name of the container that you want to assign the CORS policy to.</p>
+     */
+    inline void SetContainerName(const char* value) { m_containerNameHasBeenSet = true; m_containerName.assign(value); }
+
+    /**
+     * <p>The name of the container that you want to assign the CORS policy to.</p>
+     */
+    inline PutCorsPolicyRequest& WithContainerName(const Aws::String& value) { SetContainerName(value); return *this;}
+
+    /**
+     * <p>The name of the container that you want to assign the CORS policy to.</p>
+     */
+    inline PutCorsPolicyRequest& WithContainerName(Aws::String&& value) { SetContainerName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the container that you want to assign the CORS policy to.</p>
+     */
+    inline PutCorsPolicyRequest& WithContainerName(const char* value) { SetContainerName(value); return *this;}
+
+
+    /**
+     * <p>The CORS policy to apply to the container. </p>
+     */
+    inline const Aws::Vector<CorsRule>& GetCorsPolicy() const{ return m_corsPolicy; }
+
+    /**
+     * <p>The CORS policy to apply to the container. </p>
+     */
+    inline bool CorsPolicyHasBeenSet() const { return m_corsPolicyHasBeenSet; }
+
+    /**
+     * <p>The CORS policy to apply to the container. </p>
+     */
+    inline void SetCorsPolicy(const Aws::Vector<CorsRule>& value) { m_corsPolicyHasBeenSet = true; m_corsPolicy = value; }
+
+    /**
+     * <p>The CORS policy to apply to the container. </p>
+     */
+    inline void SetCorsPolicy(Aws::Vector<CorsRule>&& value) { m_corsPolicyHasBeenSet = true; m_corsPolicy = std::move(value); }
+
+    /**
+     * <p>The CORS policy to apply to the container. </p>
+     */
+    inline PutCorsPolicyRequest& WithCorsPolicy(const Aws::Vector<CorsRule>& value) { SetCorsPolicy(value); return *this;}
+
+    /**
+     * <p>The CORS policy to apply to the container. </p>
+     */
+    inline PutCorsPolicyRequest& WithCorsPolicy(Aws::Vector<CorsRule>&& value) { SetCorsPolicy(std::move(value)); return *this;}
+
+    /**
+     * <p>The CORS policy to apply to the container. </p>
+     */
+    inline PutCorsPolicyRequest& AddCorsPolicy(const CorsRule& value) { m_corsPolicyHasBeenSet = true; m_corsPolicy.push_back(value); return *this; }
+
+    /**
+     * <p>The CORS policy to apply to the container. </p>
+     */
+    inline PutCorsPolicyRequest& AddCorsPolicy(CorsRule&& value) { m_corsPolicyHasBeenSet = true; m_corsPolicy.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_containerName;
+    bool m_containerNameHasBeenSet;
+
+    Aws::Vector<CorsRule> m_corsPolicy;
+    bool m_corsPolicyHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/PutCorsPolicyResult.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/mediastore/MediaStore_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace MediaStore
+{
+namespace Model
+{
+  class AWS_MEDIASTORE_API PutCorsPolicyResult
+  {
+  public:
+    PutCorsPolicyResult();
+    PutCorsPolicyResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    PutCorsPolicyResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/PutLifecyclePolicyRequest.h

@@ -0,0 +1,137 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/MediaStoreRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_MEDIASTORE_API PutLifecyclePolicyRequest : public MediaStoreRequest
+  {
+  public:
+    PutLifecyclePolicyRequest();
+
+    // 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 "PutLifecyclePolicy"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the container that you want to assign the object lifecycle policy
+     * to.</p>
+     */
+    inline const Aws::String& GetContainerName() const{ return m_containerName; }
+
+    /**
+     * <p>The name of the container that you want to assign the object lifecycle policy
+     * to.</p>
+     */
+    inline bool ContainerNameHasBeenSet() const { return m_containerNameHasBeenSet; }
+
+    /**
+     * <p>The name of the container that you want to assign the object lifecycle policy
+     * to.</p>
+     */
+    inline void SetContainerName(const Aws::String& value) { m_containerNameHasBeenSet = true; m_containerName = value; }
+
+    /**
+     * <p>The name of the container that you want to assign the object lifecycle policy
+     * to.</p>
+     */
+    inline void SetContainerName(Aws::String&& value) { m_containerNameHasBeenSet = true; m_containerName = std::move(value); }
+
+    /**
+     * <p>The name of the container that you want to assign the object lifecycle policy
+     * to.</p>
+     */
+    inline void SetContainerName(const char* value) { m_containerNameHasBeenSet = true; m_containerName.assign(value); }
+
+    /**
+     * <p>The name of the container that you want to assign the object lifecycle policy
+     * to.</p>
+     */
+    inline PutLifecyclePolicyRequest& WithContainerName(const Aws::String& value) { SetContainerName(value); return *this;}
+
+    /**
+     * <p>The name of the container that you want to assign the object lifecycle policy
+     * to.</p>
+     */
+    inline PutLifecyclePolicyRequest& WithContainerName(Aws::String&& value) { SetContainerName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the container that you want to assign the object lifecycle policy
+     * to.</p>
+     */
+    inline PutLifecyclePolicyRequest& WithContainerName(const char* value) { SetContainerName(value); return *this;}
+
+
+    /**
+     * <p>The object lifecycle policy to apply to the container.</p>
+     */
+    inline const Aws::String& GetLifecyclePolicy() const{ return m_lifecyclePolicy; }
+
+    /**
+     * <p>The object lifecycle policy to apply to the container.</p>
+     */
+    inline bool LifecyclePolicyHasBeenSet() const { return m_lifecyclePolicyHasBeenSet; }
+
+    /**
+     * <p>The object lifecycle policy to apply to the container.</p>
+     */
+    inline void SetLifecyclePolicy(const Aws::String& value) { m_lifecyclePolicyHasBeenSet = true; m_lifecyclePolicy = value; }
+
+    /**
+     * <p>The object lifecycle policy to apply to the container.</p>
+     */
+    inline void SetLifecyclePolicy(Aws::String&& value) { m_lifecyclePolicyHasBeenSet = true; m_lifecyclePolicy = std::move(value); }
+
+    /**
+     * <p>The object lifecycle policy to apply to the container.</p>
+     */
+    inline void SetLifecyclePolicy(const char* value) { m_lifecyclePolicyHasBeenSet = true; m_lifecyclePolicy.assign(value); }
+
+    /**
+     * <p>The object lifecycle policy to apply to the container.</p>
+     */
+    inline PutLifecyclePolicyRequest& WithLifecyclePolicy(const Aws::String& value) { SetLifecyclePolicy(value); return *this;}
+
+    /**
+     * <p>The object lifecycle policy to apply to the container.</p>
+     */
+    inline PutLifecyclePolicyRequest& WithLifecyclePolicy(Aws::String&& value) { SetLifecyclePolicy(std::move(value)); return *this;}
+
+    /**
+     * <p>The object lifecycle policy to apply to the container.</p>
+     */
+    inline PutLifecyclePolicyRequest& WithLifecyclePolicy(const char* value) { SetLifecyclePolicy(value); return *this;}
+
+  private:
+
+    Aws::String m_containerName;
+    bool m_containerNameHasBeenSet;
+
+    Aws::String m_lifecyclePolicy;
+    bool m_lifecyclePolicyHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/PutLifecyclePolicyResult.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/mediastore/MediaStore_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace MediaStore
+{
+namespace Model
+{
+  class AWS_MEDIASTORE_API PutLifecyclePolicyResult
+  {
+  public:
+    PutLifecyclePolicyResult();
+    PutLifecyclePolicyResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    PutLifecyclePolicyResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/PutMetricPolicyRequest.h

@@ -0,0 +1,186 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/MediaStoreRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/mediastore/model/MetricPolicy.h>
+#include <utility>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_MEDIASTORE_API PutMetricPolicyRequest : public MediaStoreRequest
+  {
+  public:
+    PutMetricPolicyRequest();
+
+    // 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 "PutMetricPolicy"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the container that you want to add the metric policy to.</p>
+     */
+    inline const Aws::String& GetContainerName() const{ return m_containerName; }
+
+    /**
+     * <p>The name of the container that you want to add the metric policy to.</p>
+     */
+    inline bool ContainerNameHasBeenSet() const { return m_containerNameHasBeenSet; }
+
+    /**
+     * <p>The name of the container that you want to add the metric policy to.</p>
+     */
+    inline void SetContainerName(const Aws::String& value) { m_containerNameHasBeenSet = true; m_containerName = value; }
+
+    /**
+     * <p>The name of the container that you want to add the metric policy to.</p>
+     */
+    inline void SetContainerName(Aws::String&& value) { m_containerNameHasBeenSet = true; m_containerName = std::move(value); }
+
+    /**
+     * <p>The name of the container that you want to add the metric policy to.</p>
+     */
+    inline void SetContainerName(const char* value) { m_containerNameHasBeenSet = true; m_containerName.assign(value); }
+
+    /**
+     * <p>The name of the container that you want to add the metric policy to.</p>
+     */
+    inline PutMetricPolicyRequest& WithContainerName(const Aws::String& value) { SetContainerName(value); return *this;}
+
+    /**
+     * <p>The name of the container that you want to add the metric policy to.</p>
+     */
+    inline PutMetricPolicyRequest& WithContainerName(Aws::String&& value) { SetContainerName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the container that you want to add the metric policy to.</p>
+     */
+    inline PutMetricPolicyRequest& WithContainerName(const char* value) { SetContainerName(value); return *this;}
+
+
+    /**
+     * <p>The metric policy that you want to associate with the container. In the
+     * policy, you must indicate whether you want MediaStore to send container-level
+     * metrics. You can also include up to five rules to define groups of objects that
+     * you want MediaStore to send object-level metrics for. If you include rules in
+     * the policy, construct each rule with both of the following:</p> <ul> <li> <p>An
+     * object group that defines which objects to include in the group. The definition
+     * can be a path or a file name, but it can't have more than 900 characters. Valid
+     * characters are: a-z, A-Z, 0-9, _ (underscore), = (equal), : (colon), . (period),
+     * - (hyphen), ~ (tilde), / (forward slash), and * (asterisk). Wildcards (*) are
+     * acceptable.</p> </li> <li> <p>An object group name that allows you to refer to
+     * the object group. The name can't have more than 30 characters. Valid characters
+     * are: a-z, A-Z, 0-9, and _ (underscore).</p> </li> </ul>
+     */
+    inline const MetricPolicy& GetMetricPolicy() const{ return m_metricPolicy; }
+
+    /**
+     * <p>The metric policy that you want to associate with the container. In the
+     * policy, you must indicate whether you want MediaStore to send container-level
+     * metrics. You can also include up to five rules to define groups of objects that
+     * you want MediaStore to send object-level metrics for. If you include rules in
+     * the policy, construct each rule with both of the following:</p> <ul> <li> <p>An
+     * object group that defines which objects to include in the group. The definition
+     * can be a path or a file name, but it can't have more than 900 characters. Valid
+     * characters are: a-z, A-Z, 0-9, _ (underscore), = (equal), : (colon), . (period),
+     * - (hyphen), ~ (tilde), / (forward slash), and * (asterisk). Wildcards (*) are
+     * acceptable.</p> </li> <li> <p>An object group name that allows you to refer to
+     * the object group. The name can't have more than 30 characters. Valid characters
+     * are: a-z, A-Z, 0-9, and _ (underscore).</p> </li> </ul>
+     */
+    inline bool MetricPolicyHasBeenSet() const { return m_metricPolicyHasBeenSet; }
+
+    /**
+     * <p>The metric policy that you want to associate with the container. In the
+     * policy, you must indicate whether you want MediaStore to send container-level
+     * metrics. You can also include up to five rules to define groups of objects that
+     * you want MediaStore to send object-level metrics for. If you include rules in
+     * the policy, construct each rule with both of the following:</p> <ul> <li> <p>An
+     * object group that defines which objects to include in the group. The definition
+     * can be a path or a file name, but it can't have more than 900 characters. Valid
+     * characters are: a-z, A-Z, 0-9, _ (underscore), = (equal), : (colon), . (period),
+     * - (hyphen), ~ (tilde), / (forward slash), and * (asterisk). Wildcards (*) are
+     * acceptable.</p> </li> <li> <p>An object group name that allows you to refer to
+     * the object group. The name can't have more than 30 characters. Valid characters
+     * are: a-z, A-Z, 0-9, and _ (underscore).</p> </li> </ul>
+     */
+    inline void SetMetricPolicy(const MetricPolicy& value) { m_metricPolicyHasBeenSet = true; m_metricPolicy = value; }
+
+    /**
+     * <p>The metric policy that you want to associate with the container. In the
+     * policy, you must indicate whether you want MediaStore to send container-level
+     * metrics. You can also include up to five rules to define groups of objects that
+     * you want MediaStore to send object-level metrics for. If you include rules in
+     * the policy, construct each rule with both of the following:</p> <ul> <li> <p>An
+     * object group that defines which objects to include in the group. The definition
+     * can be a path or a file name, but it can't have more than 900 characters. Valid
+     * characters are: a-z, A-Z, 0-9, _ (underscore), = (equal), : (colon), . (period),
+     * - (hyphen), ~ (tilde), / (forward slash), and * (asterisk). Wildcards (*) are
+     * acceptable.</p> </li> <li> <p>An object group name that allows you to refer to
+     * the object group. The name can't have more than 30 characters. Valid characters
+     * are: a-z, A-Z, 0-9, and _ (underscore).</p> </li> </ul>
+     */
+    inline void SetMetricPolicy(MetricPolicy&& value) { m_metricPolicyHasBeenSet = true; m_metricPolicy = std::move(value); }
+
+    /**
+     * <p>The metric policy that you want to associate with the container. In the
+     * policy, you must indicate whether you want MediaStore to send container-level
+     * metrics. You can also include up to five rules to define groups of objects that
+     * you want MediaStore to send object-level metrics for. If you include rules in
+     * the policy, construct each rule with both of the following:</p> <ul> <li> <p>An
+     * object group that defines which objects to include in the group. The definition
+     * can be a path or a file name, but it can't have more than 900 characters. Valid
+     * characters are: a-z, A-Z, 0-9, _ (underscore), = (equal), : (colon), . (period),
+     * - (hyphen), ~ (tilde), / (forward slash), and * (asterisk). Wildcards (*) are
+     * acceptable.</p> </li> <li> <p>An object group name that allows you to refer to
+     * the object group. The name can't have more than 30 characters. Valid characters
+     * are: a-z, A-Z, 0-9, and _ (underscore).</p> </li> </ul>
+     */
+    inline PutMetricPolicyRequest& WithMetricPolicy(const MetricPolicy& value) { SetMetricPolicy(value); return *this;}
+
+    /**
+     * <p>The metric policy that you want to associate with the container. In the
+     * policy, you must indicate whether you want MediaStore to send container-level
+     * metrics. You can also include up to five rules to define groups of objects that
+     * you want MediaStore to send object-level metrics for. If you include rules in
+     * the policy, construct each rule with both of the following:</p> <ul> <li> <p>An
+     * object group that defines which objects to include in the group. The definition
+     * can be a path or a file name, but it can't have more than 900 characters. Valid
+     * characters are: a-z, A-Z, 0-9, _ (underscore), = (equal), : (colon), . (period),
+     * - (hyphen), ~ (tilde), / (forward slash), and * (asterisk). Wildcards (*) are
+     * acceptable.</p> </li> <li> <p>An object group name that allows you to refer to
+     * the object group. The name can't have more than 30 characters. Valid characters
+     * are: a-z, A-Z, 0-9, and _ (underscore).</p> </li> </ul>
+     */
+    inline PutMetricPolicyRequest& WithMetricPolicy(MetricPolicy&& value) { SetMetricPolicy(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_containerName;
+    bool m_containerNameHasBeenSet;
+
+    MetricPolicy m_metricPolicy;
+    bool m_metricPolicyHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/PutMetricPolicyResult.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/mediastore/MediaStore_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace MediaStore
+{
+namespace Model
+{
+  class AWS_MEDIASTORE_API PutMetricPolicyResult
+  {
+  public:
+    PutMetricPolicyResult();
+    PutMetricPolicyResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    PutMetricPolicyResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/StartAccessLoggingRequest.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/MediaStoreRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_MEDIASTORE_API StartAccessLoggingRequest : public MediaStoreRequest
+  {
+  public:
+    StartAccessLoggingRequest();
+
+    // 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 "StartAccessLogging"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the container that you want to start access logging on.</p>
+     */
+    inline const Aws::String& GetContainerName() const{ return m_containerName; }
+
+    /**
+     * <p>The name of the container that you want to start access logging on.</p>
+     */
+    inline bool ContainerNameHasBeenSet() const { return m_containerNameHasBeenSet; }
+
+    /**
+     * <p>The name of the container that you want to start access logging on.</p>
+     */
+    inline void SetContainerName(const Aws::String& value) { m_containerNameHasBeenSet = true; m_containerName = value; }
+
+    /**
+     * <p>The name of the container that you want to start access logging on.</p>
+     */
+    inline void SetContainerName(Aws::String&& value) { m_containerNameHasBeenSet = true; m_containerName = std::move(value); }
+
+    /**
+     * <p>The name of the container that you want to start access logging on.</p>
+     */
+    inline void SetContainerName(const char* value) { m_containerNameHasBeenSet = true; m_containerName.assign(value); }
+
+    /**
+     * <p>The name of the container that you want to start access logging on.</p>
+     */
+    inline StartAccessLoggingRequest& WithContainerName(const Aws::String& value) { SetContainerName(value); return *this;}
+
+    /**
+     * <p>The name of the container that you want to start access logging on.</p>
+     */
+    inline StartAccessLoggingRequest& WithContainerName(Aws::String&& value) { SetContainerName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the container that you want to start access logging on.</p>
+     */
+    inline StartAccessLoggingRequest& WithContainerName(const char* value) { SetContainerName(value); return *this;}
+
+  private:
+
+    Aws::String m_containerName;
+    bool m_containerNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/StartAccessLoggingResult.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/mediastore/MediaStore_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace MediaStore
+{
+namespace Model
+{
+  class AWS_MEDIASTORE_API StartAccessLoggingResult
+  {
+  public:
+    StartAccessLoggingResult();
+    StartAccessLoggingResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    StartAccessLoggingResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/StopAccessLoggingRequest.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/MediaStoreRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_MEDIASTORE_API StopAccessLoggingRequest : public MediaStoreRequest
+  {
+  public:
+    StopAccessLoggingRequest();
+
+    // 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 "StopAccessLogging"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The name of the container that you want to stop access logging on.</p>
+     */
+    inline const Aws::String& GetContainerName() const{ return m_containerName; }
+
+    /**
+     * <p>The name of the container that you want to stop access logging on.</p>
+     */
+    inline bool ContainerNameHasBeenSet() const { return m_containerNameHasBeenSet; }
+
+    /**
+     * <p>The name of the container that you want to stop access logging on.</p>
+     */
+    inline void SetContainerName(const Aws::String& value) { m_containerNameHasBeenSet = true; m_containerName = value; }
+
+    /**
+     * <p>The name of the container that you want to stop access logging on.</p>
+     */
+    inline void SetContainerName(Aws::String&& value) { m_containerNameHasBeenSet = true; m_containerName = std::move(value); }
+
+    /**
+     * <p>The name of the container that you want to stop access logging on.</p>
+     */
+    inline void SetContainerName(const char* value) { m_containerNameHasBeenSet = true; m_containerName.assign(value); }
+
+    /**
+     * <p>The name of the container that you want to stop access logging on.</p>
+     */
+    inline StopAccessLoggingRequest& WithContainerName(const Aws::String& value) { SetContainerName(value); return *this;}
+
+    /**
+     * <p>The name of the container that you want to stop access logging on.</p>
+     */
+    inline StopAccessLoggingRequest& WithContainerName(Aws::String&& value) { SetContainerName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the container that you want to stop access logging on.</p>
+     */
+    inline StopAccessLoggingRequest& WithContainerName(const char* value) { SetContainerName(value); return *this;}
+
+  private:
+
+    Aws::String m_containerName;
+    bool m_containerNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/StopAccessLoggingResult.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/mediastore/MediaStore_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace MediaStore
+{
+namespace Model
+{
+  class AWS_MEDIASTORE_API StopAccessLoggingResult
+  {
+  public:
+    StopAccessLoggingResult();
+    StopAccessLoggingResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    StopAccessLoggingResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/Tag.h

@@ -0,0 +1,171 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_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 MediaStore
+{
+namespace Model
+{
+
+  /**
+   * <p>A collection of tags associated with a container. Each tag consists of a
+   * key:value pair, which can be anything you define. Typically, the tag key
+   * represents a category (such as "environment") and the tag value represents a
+   * specific value within that category (such as "test," "development," or
+   * "production"). You can add up to 50 tags to each container. For more information
+   * about tagging, including naming and usage conventions, see <a
+   * href="https://docs.aws.amazon.com/mediastore/latest/ug/tagging.html">Tagging
+   * Resources in MediaStore</a>.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/mediastore-2017-09-01/Tag">AWS API
+   * Reference</a></p>
+   */
+  class AWS_MEDIASTORE_API Tag
+  {
+  public:
+    Tag();
+    Tag(Aws::Utils::Json::JsonView jsonValue);
+    Tag& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Part of the key:value pair that defines a tag. You can use a tag key to
+     * describe a category of information, such as "customer." Tag keys are
+     * case-sensitive.</p>
+     */
+    inline const Aws::String& GetKey() const{ return m_key; }
+
+    /**
+     * <p>Part of the key:value pair that defines a tag. You can use a tag key to
+     * describe a category of information, such as "customer." Tag keys are
+     * case-sensitive.</p>
+     */
+    inline bool KeyHasBeenSet() const { return m_keyHasBeenSet; }
+
+    /**
+     * <p>Part of the key:value pair that defines a tag. You can use a tag key to
+     * describe a category of information, such as "customer." Tag keys are
+     * case-sensitive.</p>
+     */
+    inline void SetKey(const Aws::String& value) { m_keyHasBeenSet = true; m_key = value; }
+
+    /**
+     * <p>Part of the key:value pair that defines a tag. You can use a tag key to
+     * describe a category of information, such as "customer." Tag keys are
+     * case-sensitive.</p>
+     */
+    inline void SetKey(Aws::String&& value) { m_keyHasBeenSet = true; m_key = std::move(value); }
+
+    /**
+     * <p>Part of the key:value pair that defines a tag. You can use a tag key to
+     * describe a category of information, such as "customer." Tag keys are
+     * case-sensitive.</p>
+     */
+    inline void SetKey(const char* value) { m_keyHasBeenSet = true; m_key.assign(value); }
+
+    /**
+     * <p>Part of the key:value pair that defines a tag. You can use a tag key to
+     * describe a category of information, such as "customer." Tag keys are
+     * case-sensitive.</p>
+     */
+    inline Tag& WithKey(const Aws::String& value) { SetKey(value); return *this;}
+
+    /**
+     * <p>Part of the key:value pair that defines a tag. You can use a tag key to
+     * describe a category of information, such as "customer." Tag keys are
+     * case-sensitive.</p>
+     */
+    inline Tag& WithKey(Aws::String&& value) { SetKey(std::move(value)); return *this;}
+
+    /**
+     * <p>Part of the key:value pair that defines a tag. You can use a tag key to
+     * describe a category of information, such as "customer." Tag keys are
+     * case-sensitive.</p>
+     */
+    inline Tag& WithKey(const char* value) { SetKey(value); return *this;}
+
+
+    /**
+     * <p>Part of the key:value pair that defines a tag. You can use a tag value to
+     * describe a specific value within a category, such as "companyA" or "companyB."
+     * Tag values are case-sensitive.</p>
+     */
+    inline const Aws::String& GetValue() const{ return m_value; }
+
+    /**
+     * <p>Part of the key:value pair that defines a tag. You can use a tag value to
+     * describe a specific value within a category, such as "companyA" or "companyB."
+     * Tag values are case-sensitive.</p>
+     */
+    inline bool ValueHasBeenSet() const { return m_valueHasBeenSet; }
+
+    /**
+     * <p>Part of the key:value pair that defines a tag. You can use a tag value to
+     * describe a specific value within a category, such as "companyA" or "companyB."
+     * Tag values are case-sensitive.</p>
+     */
+    inline void SetValue(const Aws::String& value) { m_valueHasBeenSet = true; m_value = value; }
+
+    /**
+     * <p>Part of the key:value pair that defines a tag. You can use a tag value to
+     * describe a specific value within a category, such as "companyA" or "companyB."
+     * Tag values are case-sensitive.</p>
+     */
+    inline void SetValue(Aws::String&& value) { m_valueHasBeenSet = true; m_value = std::move(value); }
+
+    /**
+     * <p>Part of the key:value pair that defines a tag. You can use a tag value to
+     * describe a specific value within a category, such as "companyA" or "companyB."
+     * Tag values are case-sensitive.</p>
+     */
+    inline void SetValue(const char* value) { m_valueHasBeenSet = true; m_value.assign(value); }
+
+    /**
+     * <p>Part of the key:value pair that defines a tag. You can use a tag value to
+     * describe a specific value within a category, such as "companyA" or "companyB."
+     * Tag values are case-sensitive.</p>
+     */
+    inline Tag& WithValue(const Aws::String& value) { SetValue(value); return *this;}
+
+    /**
+     * <p>Part of the key:value pair that defines a tag. You can use a tag value to
+     * describe a specific value within a category, such as "companyA" or "companyB."
+     * Tag values are case-sensitive.</p>
+     */
+    inline Tag& WithValue(Aws::String&& value) { SetValue(std::move(value)); return *this;}
+
+    /**
+     * <p>Part of the key:value pair that defines a tag. You can use a tag value to
+     * describe a specific value within a category, such as "companyA" or "companyB."
+     * Tag values are case-sensitive.</p>
+     */
+    inline Tag& WithValue(const char* value) { SetValue(value); return *this;}
+
+  private:
+
+    Aws::String m_key;
+    bool m_keyHasBeenSet;
+
+    Aws::String m_value;
+    bool m_valueHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

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

@@ -0,0 +1,179 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/MediaStoreRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/mediastore/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_MEDIASTORE_API TagResourceRequest : public MediaStoreRequest
+  {
+  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;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container. </p>
+     */
+    inline const Aws::String& GetResource() const{ return m_resource; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container. </p>
+     */
+    inline bool ResourceHasBeenSet() const { return m_resourceHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container. </p>
+     */
+    inline void SetResource(const Aws::String& value) { m_resourceHasBeenSet = true; m_resource = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container. </p>
+     */
+    inline void SetResource(Aws::String&& value) { m_resourceHasBeenSet = true; m_resource = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container. </p>
+     */
+    inline void SetResource(const char* value) { m_resourceHasBeenSet = true; m_resource.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container. </p>
+     */
+    inline TagResourceRequest& WithResource(const Aws::String& value) { SetResource(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container. </p>
+     */
+    inline TagResourceRequest& WithResource(Aws::String&& value) { SetResource(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container. </p>
+     */
+    inline TagResourceRequest& WithResource(const char* value) { SetResource(value); return *this;}
+
+
+    /**
+     * <p>An array of key:value pairs that you want to add to the container. You need
+     * to specify only the tags that you want to add or update. For example, suppose a
+     * container already has two tags (customer:CompanyA and priority:High). You want
+     * to change the priority tag and also add a third tag (type:Contract). For
+     * TagResource, you specify the following tags: priority:Medium, type:Contract. The
+     * result is that your container has three tags: customer:CompanyA,
+     * priority:Medium, and type:Contract.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>An array of key:value pairs that you want to add to the container. You need
+     * to specify only the tags that you want to add or update. For example, suppose a
+     * container already has two tags (customer:CompanyA and priority:High). You want
+     * to change the priority tag and also add a third tag (type:Contract). For
+     * TagResource, you specify the following tags: priority:Medium, type:Contract. The
+     * result is that your container has three tags: customer:CompanyA,
+     * priority:Medium, and type:Contract.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>An array of key:value pairs that you want to add to the container. You need
+     * to specify only the tags that you want to add or update. For example, suppose a
+     * container already has two tags (customer:CompanyA and priority:High). You want
+     * to change the priority tag and also add a third tag (type:Contract). For
+     * TagResource, you specify the following tags: priority:Medium, type:Contract. The
+     * result is that your container has three tags: customer:CompanyA,
+     * priority:Medium, and type:Contract.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>An array of key:value pairs that you want to add to the container. You need
+     * to specify only the tags that you want to add or update. For example, suppose a
+     * container already has two tags (customer:CompanyA and priority:High). You want
+     * to change the priority tag and also add a third tag (type:Contract). For
+     * TagResource, you specify the following tags: priority:Medium, type:Contract. The
+     * result is that your container has three tags: customer:CompanyA,
+     * priority:Medium, and type:Contract.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>An array of key:value pairs that you want to add to the container. You need
+     * to specify only the tags that you want to add or update. For example, suppose a
+     * container already has two tags (customer:CompanyA and priority:High). You want
+     * to change the priority tag and also add a third tag (type:Contract). For
+     * TagResource, you specify the following tags: priority:Medium, type:Contract. The
+     * result is that your container has three tags: customer:CompanyA,
+     * priority:Medium, and type:Contract.</p>
+     */
+    inline TagResourceRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>An array of key:value pairs that you want to add to the container. You need
+     * to specify only the tags that you want to add or update. For example, suppose a
+     * container already has two tags (customer:CompanyA and priority:High). You want
+     * to change the priority tag and also add a third tag (type:Contract). For
+     * TagResource, you specify the following tags: priority:Medium, type:Contract. The
+     * result is that your container has three tags: customer:CompanyA,
+     * priority:Medium, and type:Contract.</p>
+     */
+    inline TagResourceRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>An array of key:value pairs that you want to add to the container. You need
+     * to specify only the tags that you want to add or update. For example, suppose a
+     * container already has two tags (customer:CompanyA and priority:High). You want
+     * to change the priority tag and also add a third tag (type:Contract). For
+     * TagResource, you specify the following tags: priority:Medium, type:Contract. The
+     * result is that your container has three tags: customer:CompanyA,
+     * priority:Medium, and type:Contract.</p>
+     */
+    inline TagResourceRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>An array of key:value pairs that you want to add to the container. You need
+     * to specify only the tags that you want to add or update. For example, suppose a
+     * container already has two tags (customer:CompanyA and priority:High). You want
+     * to change the priority tag and also add a third tag (type:Contract). For
+     * TagResource, you specify the following tags: priority:Medium, type:Contract. The
+     * result is that your container has three tags: customer:CompanyA,
+     * priority:Medium, and type:Contract.</p>
+     */
+    inline TagResourceRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_resource;
+    bool m_resourceHasBeenSet;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/TagResourceResult.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/mediastore/MediaStore_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace MediaStore
+{
+namespace Model
+{
+  class AWS_MEDIASTORE_API TagResourceResult
+  {
+  public:
+    TagResourceResult();
+    TagResourceResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    TagResourceResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/model/UntagResourceRequest.h

@@ -0,0 +1,162 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/mediastore/MediaStore_EXPORTS.h>
+#include <aws/mediastore/MediaStoreRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <utility>
+
+namespace Aws
+{
+namespace MediaStore
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_MEDIASTORE_API UntagResourceRequest : public MediaStoreRequest
+  {
+  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;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container.</p>
+     */
+    inline const Aws::String& GetResource() const{ return m_resource; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container.</p>
+     */
+    inline bool ResourceHasBeenSet() const { return m_resourceHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container.</p>
+     */
+    inline void SetResource(const Aws::String& value) { m_resourceHasBeenSet = true; m_resource = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container.</p>
+     */
+    inline void SetResource(Aws::String&& value) { m_resourceHasBeenSet = true; m_resource = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container.</p>
+     */
+    inline void SetResource(const char* value) { m_resourceHasBeenSet = true; m_resource.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container.</p>
+     */
+    inline UntagResourceRequest& WithResource(const Aws::String& value) { SetResource(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container.</p>
+     */
+    inline UntagResourceRequest& WithResource(Aws::String&& value) { SetResource(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the container.</p>
+     */
+    inline UntagResourceRequest& WithResource(const char* value) { SetResource(value); return *this;}
+
+
+    /**
+     * <p>A comma-separated list of keys for tags that you want to remove from the
+     * container. For example, if your container has two tags (customer:CompanyA and
+     * priority:High) and you want to remove one of the tags (priority:High), you
+     * specify the key for the tag that you want to remove (priority).</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetTagKeys() const{ return m_tagKeys; }
+
+    /**
+     * <p>A comma-separated list of keys for tags that you want to remove from the
+     * container. For example, if your container has two tags (customer:CompanyA and
+     * priority:High) and you want to remove one of the tags (priority:High), you
+     * specify the key for the tag that you want to remove (priority).</p>
+     */
+    inline bool TagKeysHasBeenSet() const { return m_tagKeysHasBeenSet; }
+
+    /**
+     * <p>A comma-separated list of keys for tags that you want to remove from the
+     * container. For example, if your container has two tags (customer:CompanyA and
+     * priority:High) and you want to remove one of the tags (priority:High), you
+     * specify the key for the tag that you want to remove (priority).</p>
+     */
+    inline void SetTagKeys(const Aws::Vector<Aws::String>& value) { m_tagKeysHasBeenSet = true; m_tagKeys = value; }
+
+    /**
+     * <p>A comma-separated list of keys for tags that you want to remove from the
+     * container. For example, if your container has two tags (customer:CompanyA and
+     * priority:High) and you want to remove one of the tags (priority:High), you
+     * specify the key for the tag that you want to remove (priority).</p>
+     */
+    inline void SetTagKeys(Aws::Vector<Aws::String>&& value) { m_tagKeysHasBeenSet = true; m_tagKeys = std::move(value); }
+
+    /**
+     * <p>A comma-separated list of keys for tags that you want to remove from the
+     * container. For example, if your container has two tags (customer:CompanyA and
+     * priority:High) and you want to remove one of the tags (priority:High), you
+     * specify the key for the tag that you want to remove (priority).</p>
+     */
+    inline UntagResourceRequest& WithTagKeys(const Aws::Vector<Aws::String>& value) { SetTagKeys(value); return *this;}
+
+    /**
+     * <p>A comma-separated list of keys for tags that you want to remove from the
+     * container. For example, if your container has two tags (customer:CompanyA and
+     * priority:High) and you want to remove one of the tags (priority:High), you
+     * specify the key for the tag that you want to remove (priority).</p>
+     */
+    inline UntagResourceRequest& WithTagKeys(Aws::Vector<Aws::String>&& value) { SetTagKeys(std::move(value)); return *this;}
+
+    /**
+     * <p>A comma-separated list of keys for tags that you want to remove from the
+     * container. For example, if your container has two tags (customer:CompanyA and
+     * priority:High) and you want to remove one of the tags (priority:High), you
+     * specify the key for the tag that you want to remove (priority).</p>
+     */
+    inline UntagResourceRequest& AddTagKeys(const Aws::String& value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(value); return *this; }
+
+    /**
+     * <p>A comma-separated list of keys for tags that you want to remove from the
+     * container. For example, if your container has two tags (customer:CompanyA and
+     * priority:High) and you want to remove one of the tags (priority:High), you
+     * specify the key for the tag that you want to remove (priority).</p>
+     */
+    inline UntagResourceRequest& AddTagKeys(Aws::String&& value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A comma-separated list of keys for tags that you want to remove from the
+     * container. For example, if your container has two tags (customer:CompanyA and
+     * priority:High) and you want to remove one of the tags (priority:High), you
+     * specify the key for the tag that you want to remove (priority).</p>
+     */
+    inline UntagResourceRequest& AddTagKeys(const char* value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(value); return *this; }
+
+  private:
+
+    Aws::String m_resource;
+    bool m_resourceHasBeenSet;
+
+    Aws::Vector<Aws::String> m_tagKeys;
+    bool m_tagKeysHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace MediaStore
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-mediastore/include/aws/mediastore/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/mediastore/MediaStore_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace MediaStore
+{
+namespace Model
+{
+  class AWS_MEDIASTORE_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 MediaStore
+} // namespace Aws