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

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/KinesisVideoClient.h

@@ -0,0 +1,978 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/KinesisVideoErrors.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/kinesisvideo/model/CreateSignalingChannelResult.h>
+#include <aws/kinesisvideo/model/CreateStreamResult.h>
+#include <aws/kinesisvideo/model/DeleteSignalingChannelResult.h>
+#include <aws/kinesisvideo/model/DeleteStreamResult.h>
+#include <aws/kinesisvideo/model/DescribeSignalingChannelResult.h>
+#include <aws/kinesisvideo/model/DescribeStreamResult.h>
+#include <aws/kinesisvideo/model/GetDataEndpointResult.h>
+#include <aws/kinesisvideo/model/GetSignalingChannelEndpointResult.h>
+#include <aws/kinesisvideo/model/ListSignalingChannelsResult.h>
+#include <aws/kinesisvideo/model/ListStreamsResult.h>
+#include <aws/kinesisvideo/model/ListTagsForResourceResult.h>
+#include <aws/kinesisvideo/model/ListTagsForStreamResult.h>
+#include <aws/kinesisvideo/model/TagResourceResult.h>
+#include <aws/kinesisvideo/model/TagStreamResult.h>
+#include <aws/kinesisvideo/model/UntagResourceResult.h>
+#include <aws/kinesisvideo/model/UntagStreamResult.h>
+#include <aws/kinesisvideo/model/UpdateDataRetentionResult.h>
+#include <aws/kinesisvideo/model/UpdateSignalingChannelResult.h>
+#include <aws/kinesisvideo/model/UpdateStreamResult.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 KinesisVideo
+{
+
+namespace Model
+{
+        class CreateSignalingChannelRequest;
+        class CreateStreamRequest;
+        class DeleteSignalingChannelRequest;
+        class DeleteStreamRequest;
+        class DescribeSignalingChannelRequest;
+        class DescribeStreamRequest;
+        class GetDataEndpointRequest;
+        class GetSignalingChannelEndpointRequest;
+        class ListSignalingChannelsRequest;
+        class ListStreamsRequest;
+        class ListTagsForResourceRequest;
+        class ListTagsForStreamRequest;
+        class TagResourceRequest;
+        class TagStreamRequest;
+        class UntagResourceRequest;
+        class UntagStreamRequest;
+        class UpdateDataRetentionRequest;
+        class UpdateSignalingChannelRequest;
+        class UpdateStreamRequest;
+
+        typedef Aws::Utils::Outcome<CreateSignalingChannelResult, KinesisVideoError> CreateSignalingChannelOutcome;
+        typedef Aws::Utils::Outcome<CreateStreamResult, KinesisVideoError> CreateStreamOutcome;
+        typedef Aws::Utils::Outcome<DeleteSignalingChannelResult, KinesisVideoError> DeleteSignalingChannelOutcome;
+        typedef Aws::Utils::Outcome<DeleteStreamResult, KinesisVideoError> DeleteStreamOutcome;
+        typedef Aws::Utils::Outcome<DescribeSignalingChannelResult, KinesisVideoError> DescribeSignalingChannelOutcome;
+        typedef Aws::Utils::Outcome<DescribeStreamResult, KinesisVideoError> DescribeStreamOutcome;
+        typedef Aws::Utils::Outcome<GetDataEndpointResult, KinesisVideoError> GetDataEndpointOutcome;
+        typedef Aws::Utils::Outcome<GetSignalingChannelEndpointResult, KinesisVideoError> GetSignalingChannelEndpointOutcome;
+        typedef Aws::Utils::Outcome<ListSignalingChannelsResult, KinesisVideoError> ListSignalingChannelsOutcome;
+        typedef Aws::Utils::Outcome<ListStreamsResult, KinesisVideoError> ListStreamsOutcome;
+        typedef Aws::Utils::Outcome<ListTagsForResourceResult, KinesisVideoError> ListTagsForResourceOutcome;
+        typedef Aws::Utils::Outcome<ListTagsForStreamResult, KinesisVideoError> ListTagsForStreamOutcome;
+        typedef Aws::Utils::Outcome<TagResourceResult, KinesisVideoError> TagResourceOutcome;
+        typedef Aws::Utils::Outcome<TagStreamResult, KinesisVideoError> TagStreamOutcome;
+        typedef Aws::Utils::Outcome<UntagResourceResult, KinesisVideoError> UntagResourceOutcome;
+        typedef Aws::Utils::Outcome<UntagStreamResult, KinesisVideoError> UntagStreamOutcome;
+        typedef Aws::Utils::Outcome<UpdateDataRetentionResult, KinesisVideoError> UpdateDataRetentionOutcome;
+        typedef Aws::Utils::Outcome<UpdateSignalingChannelResult, KinesisVideoError> UpdateSignalingChannelOutcome;
+        typedef Aws::Utils::Outcome<UpdateStreamResult, KinesisVideoError> UpdateStreamOutcome;
+
+        typedef std::future<CreateSignalingChannelOutcome> CreateSignalingChannelOutcomeCallable;
+        typedef std::future<CreateStreamOutcome> CreateStreamOutcomeCallable;
+        typedef std::future<DeleteSignalingChannelOutcome> DeleteSignalingChannelOutcomeCallable;
+        typedef std::future<DeleteStreamOutcome> DeleteStreamOutcomeCallable;
+        typedef std::future<DescribeSignalingChannelOutcome> DescribeSignalingChannelOutcomeCallable;
+        typedef std::future<DescribeStreamOutcome> DescribeStreamOutcomeCallable;
+        typedef std::future<GetDataEndpointOutcome> GetDataEndpointOutcomeCallable;
+        typedef std::future<GetSignalingChannelEndpointOutcome> GetSignalingChannelEndpointOutcomeCallable;
+        typedef std::future<ListSignalingChannelsOutcome> ListSignalingChannelsOutcomeCallable;
+        typedef std::future<ListStreamsOutcome> ListStreamsOutcomeCallable;
+        typedef std::future<ListTagsForResourceOutcome> ListTagsForResourceOutcomeCallable;
+        typedef std::future<ListTagsForStreamOutcome> ListTagsForStreamOutcomeCallable;
+        typedef std::future<TagResourceOutcome> TagResourceOutcomeCallable;
+        typedef std::future<TagStreamOutcome> TagStreamOutcomeCallable;
+        typedef std::future<UntagResourceOutcome> UntagResourceOutcomeCallable;
+        typedef std::future<UntagStreamOutcome> UntagStreamOutcomeCallable;
+        typedef std::future<UpdateDataRetentionOutcome> UpdateDataRetentionOutcomeCallable;
+        typedef std::future<UpdateSignalingChannelOutcome> UpdateSignalingChannelOutcomeCallable;
+        typedef std::future<UpdateStreamOutcome> UpdateStreamOutcomeCallable;
+} // namespace Model
+
+  class KinesisVideoClient;
+
+    typedef std::function<void(const KinesisVideoClient*, const Model::CreateSignalingChannelRequest&, const Model::CreateSignalingChannelOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateSignalingChannelResponseReceivedHandler;
+    typedef std::function<void(const KinesisVideoClient*, const Model::CreateStreamRequest&, const Model::CreateStreamOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateStreamResponseReceivedHandler;
+    typedef std::function<void(const KinesisVideoClient*, const Model::DeleteSignalingChannelRequest&, const Model::DeleteSignalingChannelOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteSignalingChannelResponseReceivedHandler;
+    typedef std::function<void(const KinesisVideoClient*, const Model::DeleteStreamRequest&, const Model::DeleteStreamOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteStreamResponseReceivedHandler;
+    typedef std::function<void(const KinesisVideoClient*, const Model::DescribeSignalingChannelRequest&, const Model::DescribeSignalingChannelOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeSignalingChannelResponseReceivedHandler;
+    typedef std::function<void(const KinesisVideoClient*, const Model::DescribeStreamRequest&, const Model::DescribeStreamOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeStreamResponseReceivedHandler;
+    typedef std::function<void(const KinesisVideoClient*, const Model::GetDataEndpointRequest&, const Model::GetDataEndpointOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetDataEndpointResponseReceivedHandler;
+    typedef std::function<void(const KinesisVideoClient*, const Model::GetSignalingChannelEndpointRequest&, const Model::GetSignalingChannelEndpointOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetSignalingChannelEndpointResponseReceivedHandler;
+    typedef std::function<void(const KinesisVideoClient*, const Model::ListSignalingChannelsRequest&, const Model::ListSignalingChannelsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListSignalingChannelsResponseReceivedHandler;
+    typedef std::function<void(const KinesisVideoClient*, const Model::ListStreamsRequest&, const Model::ListStreamsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListStreamsResponseReceivedHandler;
+    typedef std::function<void(const KinesisVideoClient*, const Model::ListTagsForResourceRequest&, const Model::ListTagsForResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTagsForResourceResponseReceivedHandler;
+    typedef std::function<void(const KinesisVideoClient*, const Model::ListTagsForStreamRequest&, const Model::ListTagsForStreamOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTagsForStreamResponseReceivedHandler;
+    typedef std::function<void(const KinesisVideoClient*, const Model::TagResourceRequest&, const Model::TagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > TagResourceResponseReceivedHandler;
+    typedef std::function<void(const KinesisVideoClient*, const Model::TagStreamRequest&, const Model::TagStreamOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > TagStreamResponseReceivedHandler;
+    typedef std::function<void(const KinesisVideoClient*, const Model::UntagResourceRequest&, const Model::UntagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UntagResourceResponseReceivedHandler;
+    typedef std::function<void(const KinesisVideoClient*, const Model::UntagStreamRequest&, const Model::UntagStreamOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UntagStreamResponseReceivedHandler;
+    typedef std::function<void(const KinesisVideoClient*, const Model::UpdateDataRetentionRequest&, const Model::UpdateDataRetentionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateDataRetentionResponseReceivedHandler;
+    typedef std::function<void(const KinesisVideoClient*, const Model::UpdateSignalingChannelRequest&, const Model::UpdateSignalingChannelOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateSignalingChannelResponseReceivedHandler;
+    typedef std::function<void(const KinesisVideoClient*, const Model::UpdateStreamRequest&, const Model::UpdateStreamOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateStreamResponseReceivedHandler;
+
+  /**
+   * <p/>
+   */
+  class AWS_KINESISVIDEO_API KinesisVideoClient : 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.
+        */
+        KinesisVideoClient(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.
+        */
+        KinesisVideoClient(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
+        */
+        KinesisVideoClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
+            const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());
+
+        virtual ~KinesisVideoClient();
+
+
+        /**
+         * <p>Creates a signaling channel. </p> <p> <code>CreateSignalingChannel</code> is
+         * an asynchronous operation.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/CreateSignalingChannel">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::CreateSignalingChannelOutcome CreateSignalingChannel(const Model::CreateSignalingChannelRequest& request) const;
+
+        /**
+         * <p>Creates a signaling channel. </p> <p> <code>CreateSignalingChannel</code> is
+         * an asynchronous operation.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/CreateSignalingChannel">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::CreateSignalingChannelOutcomeCallable CreateSignalingChannelCallable(const Model::CreateSignalingChannelRequest& request) const;
+
+        /**
+         * <p>Creates a signaling channel. </p> <p> <code>CreateSignalingChannel</code> is
+         * an asynchronous operation.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/CreateSignalingChannel">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void CreateSignalingChannelAsync(const Model::CreateSignalingChannelRequest& request, const CreateSignalingChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Creates a new Kinesis video stream. </p> <p>When you create a new stream,
+         * Kinesis Video Streams assigns it a version number. When you change the stream's
+         * metadata, Kinesis Video Streams updates the version. </p> <p>
+         * <code>CreateStream</code> is an asynchronous operation.</p> <p>For information
+         * about how the service works, see <a
+         * href="https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/how-it-works.html">How
+         * it Works</a>. </p> <p>You must have permissions for the
+         * <code>KinesisVideo:CreateStream</code> action.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/CreateStream">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::CreateStreamOutcome CreateStream(const Model::CreateStreamRequest& request) const;
+
+        /**
+         * <p>Creates a new Kinesis video stream. </p> <p>When you create a new stream,
+         * Kinesis Video Streams assigns it a version number. When you change the stream's
+         * metadata, Kinesis Video Streams updates the version. </p> <p>
+         * <code>CreateStream</code> is an asynchronous operation.</p> <p>For information
+         * about how the service works, see <a
+         * href="https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/how-it-works.html">How
+         * it Works</a>. </p> <p>You must have permissions for the
+         * <code>KinesisVideo:CreateStream</code> action.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/CreateStream">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::CreateStreamOutcomeCallable CreateStreamCallable(const Model::CreateStreamRequest& request) const;
+
+        /**
+         * <p>Creates a new Kinesis video stream. </p> <p>When you create a new stream,
+         * Kinesis Video Streams assigns it a version number. When you change the stream's
+         * metadata, Kinesis Video Streams updates the version. </p> <p>
+         * <code>CreateStream</code> is an asynchronous operation.</p> <p>For information
+         * about how the service works, see <a
+         * href="https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/how-it-works.html">How
+         * it Works</a>. </p> <p>You must have permissions for the
+         * <code>KinesisVideo:CreateStream</code> action.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/CreateStream">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void CreateStreamAsync(const Model::CreateStreamRequest& request, const CreateStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Deletes a specified signaling channel. <code>DeleteSignalingChannel</code> is
+         * an asynchronous operation. If you don't specify the channel's current version,
+         * the most recent version is deleted.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/DeleteSignalingChannel">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DeleteSignalingChannelOutcome DeleteSignalingChannel(const Model::DeleteSignalingChannelRequest& request) const;
+
+        /**
+         * <p>Deletes a specified signaling channel. <code>DeleteSignalingChannel</code> is
+         * an asynchronous operation. If you don't specify the channel's current version,
+         * the most recent version is deleted.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/DeleteSignalingChannel">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DeleteSignalingChannelOutcomeCallable DeleteSignalingChannelCallable(const Model::DeleteSignalingChannelRequest& request) const;
+
+        /**
+         * <p>Deletes a specified signaling channel. <code>DeleteSignalingChannel</code> is
+         * an asynchronous operation. If you don't specify the channel's current version,
+         * the most recent version is deleted.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/DeleteSignalingChannel">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DeleteSignalingChannelAsync(const Model::DeleteSignalingChannelRequest& request, const DeleteSignalingChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Deletes a Kinesis video stream and the data contained in the stream. </p>
+         * <p>This method marks the stream for deletion, and makes the data in the stream
+         * inaccessible immediately.</p> <p> </p> <p> To ensure that you have the latest
+         * version of the stream before deleting it, you can specify the stream version.
+         * Kinesis Video Streams assigns a version to each stream. When you update a
+         * stream, Kinesis Video Streams assigns a new version number. To get the latest
+         * stream version, use the <code>DescribeStream</code> API. </p> <p>This operation
+         * requires permission for the <code>KinesisVideo:DeleteStream</code>
+         * action.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/DeleteStream">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DeleteStreamOutcome DeleteStream(const Model::DeleteStreamRequest& request) const;
+
+        /**
+         * <p>Deletes a Kinesis video stream and the data contained in the stream. </p>
+         * <p>This method marks the stream for deletion, and makes the data in the stream
+         * inaccessible immediately.</p> <p> </p> <p> To ensure that you have the latest
+         * version of the stream before deleting it, you can specify the stream version.
+         * Kinesis Video Streams assigns a version to each stream. When you update a
+         * stream, Kinesis Video Streams assigns a new version number. To get the latest
+         * stream version, use the <code>DescribeStream</code> API. </p> <p>This operation
+         * requires permission for the <code>KinesisVideo:DeleteStream</code>
+         * action.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/DeleteStream">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DeleteStreamOutcomeCallable DeleteStreamCallable(const Model::DeleteStreamRequest& request) const;
+
+        /**
+         * <p>Deletes a Kinesis video stream and the data contained in the stream. </p>
+         * <p>This method marks the stream for deletion, and makes the data in the stream
+         * inaccessible immediately.</p> <p> </p> <p> To ensure that you have the latest
+         * version of the stream before deleting it, you can specify the stream version.
+         * Kinesis Video Streams assigns a version to each stream. When you update a
+         * stream, Kinesis Video Streams assigns a new version number. To get the latest
+         * stream version, use the <code>DescribeStream</code> API. </p> <p>This operation
+         * requires permission for the <code>KinesisVideo:DeleteStream</code>
+         * action.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/DeleteStream">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DeleteStreamAsync(const Model::DeleteStreamRequest& request, const DeleteStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Returns the most current information about the signaling channel. You must
+         * specify either the name or the Amazon Resource Name (ARN) of the channel that
+         * you want to describe.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/DescribeSignalingChannel">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DescribeSignalingChannelOutcome DescribeSignalingChannel(const Model::DescribeSignalingChannelRequest& request) const;
+
+        /**
+         * <p>Returns the most current information about the signaling channel. You must
+         * specify either the name or the Amazon Resource Name (ARN) of the channel that
+         * you want to describe.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/DescribeSignalingChannel">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DescribeSignalingChannelOutcomeCallable DescribeSignalingChannelCallable(const Model::DescribeSignalingChannelRequest& request) const;
+
+        /**
+         * <p>Returns the most current information about the signaling channel. You must
+         * specify either the name or the Amazon Resource Name (ARN) of the channel that
+         * you want to describe.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/DescribeSignalingChannel">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DescribeSignalingChannelAsync(const Model::DescribeSignalingChannelRequest& request, const DescribeSignalingChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Returns the most current information about the specified stream. You must
+         * specify either the <code>StreamName</code> or the <code>StreamARN</code>.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/DescribeStream">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DescribeStreamOutcome DescribeStream(const Model::DescribeStreamRequest& request) const;
+
+        /**
+         * <p>Returns the most current information about the specified stream. You must
+         * specify either the <code>StreamName</code> or the <code>StreamARN</code>.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/DescribeStream">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DescribeStreamOutcomeCallable DescribeStreamCallable(const Model::DescribeStreamRequest& request) const;
+
+        /**
+         * <p>Returns the most current information about the specified stream. You must
+         * specify either the <code>StreamName</code> or the <code>StreamARN</code>.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/DescribeStream">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DescribeStreamAsync(const Model::DescribeStreamRequest& request, const DescribeStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Gets an endpoint for a specified stream for either reading or writing. Use
+         * this endpoint in your application to read from the specified stream (using the
+         * <code>GetMedia</code> or <code>GetMediaForFragmentList</code> operations) or
+         * write to it (using the <code>PutMedia</code> operation). </p>  <p>The
+         * returned endpoint does not have the API name appended. The client needs to add
+         * the API name to the returned endpoint.</p>  <p>In the request, specify
+         * the stream either by <code>StreamName</code> or
+         * <code>StreamARN</code>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/GetDataEndpoint">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::GetDataEndpointOutcome GetDataEndpoint(const Model::GetDataEndpointRequest& request) const;
+
+        /**
+         * <p>Gets an endpoint for a specified stream for either reading or writing. Use
+         * this endpoint in your application to read from the specified stream (using the
+         * <code>GetMedia</code> or <code>GetMediaForFragmentList</code> operations) or
+         * write to it (using the <code>PutMedia</code> operation). </p>  <p>The
+         * returned endpoint does not have the API name appended. The client needs to add
+         * the API name to the returned endpoint.</p>  <p>In the request, specify
+         * the stream either by <code>StreamName</code> or
+         * <code>StreamARN</code>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/GetDataEndpoint">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::GetDataEndpointOutcomeCallable GetDataEndpointCallable(const Model::GetDataEndpointRequest& request) const;
+
+        /**
+         * <p>Gets an endpoint for a specified stream for either reading or writing. Use
+         * this endpoint in your application to read from the specified stream (using the
+         * <code>GetMedia</code> or <code>GetMediaForFragmentList</code> operations) or
+         * write to it (using the <code>PutMedia</code> operation). </p>  <p>The
+         * returned endpoint does not have the API name appended. The client needs to add
+         * the API name to the returned endpoint.</p>  <p>In the request, specify
+         * the stream either by <code>StreamName</code> or
+         * <code>StreamARN</code>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/GetDataEndpoint">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void GetDataEndpointAsync(const Model::GetDataEndpointRequest& request, const GetDataEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Provides an endpoint for the specified signaling channel to send and receive
+         * messages. This API uses the
+         * <code>SingleMasterChannelEndpointConfiguration</code> input parameter, which
+         * consists of the <code>Protocols</code> and <code>Role</code> properties.</p> <p>
+         * <code>Protocols</code> is used to determine the communication mechanism. For
+         * example, if you specify <code>WSS</code> as the protocol, this API produces a
+         * secure websocket endpoint. If you specify <code>HTTPS</code> as the protocol,
+         * this API generates an HTTPS endpoint. </p> <p> <code>Role</code> determines the
+         * messaging permissions. A <code>MASTER</code> role results in this API generating
+         * an endpoint that a client can use to communicate with any of the viewers on the
+         * channel. A <code>VIEWER</code> role results in this API generating an endpoint
+         * that a client can use to communicate only with a <code>MASTER</code>.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/GetSignalingChannelEndpoint">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::GetSignalingChannelEndpointOutcome GetSignalingChannelEndpoint(const Model::GetSignalingChannelEndpointRequest& request) const;
+
+        /**
+         * <p>Provides an endpoint for the specified signaling channel to send and receive
+         * messages. This API uses the
+         * <code>SingleMasterChannelEndpointConfiguration</code> input parameter, which
+         * consists of the <code>Protocols</code> and <code>Role</code> properties.</p> <p>
+         * <code>Protocols</code> is used to determine the communication mechanism. For
+         * example, if you specify <code>WSS</code> as the protocol, this API produces a
+         * secure websocket endpoint. If you specify <code>HTTPS</code> as the protocol,
+         * this API generates an HTTPS endpoint. </p> <p> <code>Role</code> determines the
+         * messaging permissions. A <code>MASTER</code> role results in this API generating
+         * an endpoint that a client can use to communicate with any of the viewers on the
+         * channel. A <code>VIEWER</code> role results in this API generating an endpoint
+         * that a client can use to communicate only with a <code>MASTER</code>.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/GetSignalingChannelEndpoint">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::GetSignalingChannelEndpointOutcomeCallable GetSignalingChannelEndpointCallable(const Model::GetSignalingChannelEndpointRequest& request) const;
+
+        /**
+         * <p>Provides an endpoint for the specified signaling channel to send and receive
+         * messages. This API uses the
+         * <code>SingleMasterChannelEndpointConfiguration</code> input parameter, which
+         * consists of the <code>Protocols</code> and <code>Role</code> properties.</p> <p>
+         * <code>Protocols</code> is used to determine the communication mechanism. For
+         * example, if you specify <code>WSS</code> as the protocol, this API produces a
+         * secure websocket endpoint. If you specify <code>HTTPS</code> as the protocol,
+         * this API generates an HTTPS endpoint. </p> <p> <code>Role</code> determines the
+         * messaging permissions. A <code>MASTER</code> role results in this API generating
+         * an endpoint that a client can use to communicate with any of the viewers on the
+         * channel. A <code>VIEWER</code> role results in this API generating an endpoint
+         * that a client can use to communicate only with a <code>MASTER</code>.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/GetSignalingChannelEndpoint">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void GetSignalingChannelEndpointAsync(const Model::GetSignalingChannelEndpointRequest& request, const GetSignalingChannelEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Returns an array of <code>ChannelInfo</code> objects. Each object describes a
+         * signaling channel. To retrieve only those channels that satisfy a specific
+         * condition, you can specify a <code>ChannelNameCondition</code>.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/ListSignalingChannels">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ListSignalingChannelsOutcome ListSignalingChannels(const Model::ListSignalingChannelsRequest& request) const;
+
+        /**
+         * <p>Returns an array of <code>ChannelInfo</code> objects. Each object describes a
+         * signaling channel. To retrieve only those channels that satisfy a specific
+         * condition, you can specify a <code>ChannelNameCondition</code>.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/ListSignalingChannels">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::ListSignalingChannelsOutcomeCallable ListSignalingChannelsCallable(const Model::ListSignalingChannelsRequest& request) const;
+
+        /**
+         * <p>Returns an array of <code>ChannelInfo</code> objects. Each object describes a
+         * signaling channel. To retrieve only those channels that satisfy a specific
+         * condition, you can specify a <code>ChannelNameCondition</code>.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/ListSignalingChannels">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void ListSignalingChannelsAsync(const Model::ListSignalingChannelsRequest& request, const ListSignalingChannelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Returns an array of <code>StreamInfo</code> objects. Each object describes a
+         * stream. To retrieve only streams that satisfy a specific condition, you can
+         * specify a <code>StreamNameCondition</code>. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/ListStreams">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ListStreamsOutcome ListStreams(const Model::ListStreamsRequest& request) const;
+
+        /**
+         * <p>Returns an array of <code>StreamInfo</code> objects. Each object describes a
+         * stream. To retrieve only streams that satisfy a specific condition, you can
+         * specify a <code>StreamNameCondition</code>. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/ListStreams">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::ListStreamsOutcomeCallable ListStreamsCallable(const Model::ListStreamsRequest& request) const;
+
+        /**
+         * <p>Returns an array of <code>StreamInfo</code> objects. Each object describes a
+         * stream. To retrieve only streams that satisfy a specific condition, you can
+         * specify a <code>StreamNameCondition</code>. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/ListStreams">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void ListStreamsAsync(const Model::ListStreamsRequest& request, const ListStreamsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Returns a list of tags associated with the specified signaling
+         * channel.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/ListTagsForResource">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
+
+        /**
+         * <p>Returns a list of tags associated with the specified signaling
+         * channel.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/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 tags associated with the specified signaling
+         * channel.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/ListTagsForResource">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void ListTagsForResourceAsync(const Model::ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Returns a list of tags associated with the specified stream.</p> <p>In the
+         * request, you must specify either the <code>StreamName</code> or the
+         * <code>StreamARN</code>. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/ListTagsForStream">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ListTagsForStreamOutcome ListTagsForStream(const Model::ListTagsForStreamRequest& request) const;
+
+        /**
+         * <p>Returns a list of tags associated with the specified stream.</p> <p>In the
+         * request, you must specify either the <code>StreamName</code> or the
+         * <code>StreamARN</code>. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/ListTagsForStream">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::ListTagsForStreamOutcomeCallable ListTagsForStreamCallable(const Model::ListTagsForStreamRequest& request) const;
+
+        /**
+         * <p>Returns a list of tags associated with the specified stream.</p> <p>In the
+         * request, you must specify either the <code>StreamName</code> or the
+         * <code>StreamARN</code>. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/ListTagsForStream">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void ListTagsForStreamAsync(const Model::ListTagsForStreamRequest& request, const ListTagsForStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Adds one or more tags to a signaling channel. A <i>tag</i> is a key-value
+         * pair (the value is optional) that you can define and assign to AWS resources. If
+         * you specify a tag that already exists, the tag value is replaced with the value
+         * that you specify in the request. For more information, see <a
+         * href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html">Using
+         * Cost Allocation Tags</a> in the <i>AWS Billing and Cost Management User
+         * Guide</i>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/TagResource">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
+
+        /**
+         * <p>Adds one or more tags to a signaling channel. A <i>tag</i> is a key-value
+         * pair (the value is optional) that you can define and assign to AWS resources. If
+         * you specify a tag that already exists, the tag value is replaced with the value
+         * that you specify in the request. For more information, see <a
+         * href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html">Using
+         * Cost Allocation Tags</a> in the <i>AWS Billing and Cost Management User
+         * Guide</i>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/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 one or more tags to a signaling channel. A <i>tag</i> is a key-value
+         * pair (the value is optional) that you can define and assign to AWS resources. If
+         * you specify a tag that already exists, the tag value is replaced with the value
+         * that you specify in the request. For more information, see <a
+         * href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html">Using
+         * Cost Allocation Tags</a> in the <i>AWS Billing and Cost Management User
+         * Guide</i>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/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>Adds one or more tags to a stream. A <i>tag</i> is a key-value pair (the
+         * value is optional) that you can define and assign to AWS resources. If you
+         * specify a tag that already exists, the tag value is replaced with the value that
+         * you specify in the request. For more information, see <a
+         * href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html">Using
+         * Cost Allocation Tags</a> in the <i>AWS Billing and Cost Management User
+         * Guide</i>. </p> <p>You must provide either the <code>StreamName</code> or the
+         * <code>StreamARN</code>.</p> <p>This operation requires permission for the
+         * <code>KinesisVideo:TagStream</code> action.</p> <p>Kinesis video streams support
+         * up to 50 tags.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/TagStream">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::TagStreamOutcome TagStream(const Model::TagStreamRequest& request) const;
+
+        /**
+         * <p>Adds one or more tags to a stream. A <i>tag</i> is a key-value pair (the
+         * value is optional) that you can define and assign to AWS resources. If you
+         * specify a tag that already exists, the tag value is replaced with the value that
+         * you specify in the request. For more information, see <a
+         * href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html">Using
+         * Cost Allocation Tags</a> in the <i>AWS Billing and Cost Management User
+         * Guide</i>. </p> <p>You must provide either the <code>StreamName</code> or the
+         * <code>StreamARN</code>.</p> <p>This operation requires permission for the
+         * <code>KinesisVideo:TagStream</code> action.</p> <p>Kinesis video streams support
+         * up to 50 tags.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/TagStream">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::TagStreamOutcomeCallable TagStreamCallable(const Model::TagStreamRequest& request) const;
+
+        /**
+         * <p>Adds one or more tags to a stream. A <i>tag</i> is a key-value pair (the
+         * value is optional) that you can define and assign to AWS resources. If you
+         * specify a tag that already exists, the tag value is replaced with the value that
+         * you specify in the request. For more information, see <a
+         * href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html">Using
+         * Cost Allocation Tags</a> in the <i>AWS Billing and Cost Management User
+         * Guide</i>. </p> <p>You must provide either the <code>StreamName</code> or the
+         * <code>StreamARN</code>.</p> <p>This operation requires permission for the
+         * <code>KinesisVideo:TagStream</code> action.</p> <p>Kinesis video streams support
+         * up to 50 tags.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/TagStream">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void TagStreamAsync(const Model::TagStreamRequest& request, const TagStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Removes one or more tags from a signaling channel. In the request, specify
+         * only a tag key or keys; don't specify the value. If you specify a tag key that
+         * does not exist, it's ignored.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/UntagResource">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
+
+        /**
+         * <p>Removes one or more tags from a signaling channel. In the request, specify
+         * only a tag key or keys; don't specify the value. If you specify a tag key that
+         * does not exist, it's ignored.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/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 one or more tags from a signaling channel. In the request, specify
+         * only a tag key or keys; don't specify the value. If you specify a tag key that
+         * does not exist, it's ignored.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/UntagResource">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void UntagResourceAsync(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Removes one or more tags from a stream. In the request, specify only a tag
+         * key or keys; don't specify the value. If you specify a tag key that does not
+         * exist, it's ignored.</p> <p>In the request, you must provide the
+         * <code>StreamName</code> or <code>StreamARN</code>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/UntagStream">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::UntagStreamOutcome UntagStream(const Model::UntagStreamRequest& request) const;
+
+        /**
+         * <p>Removes one or more tags from a stream. In the request, specify only a tag
+         * key or keys; don't specify the value. If you specify a tag key that does not
+         * exist, it's ignored.</p> <p>In the request, you must provide the
+         * <code>StreamName</code> or <code>StreamARN</code>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/UntagStream">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::UntagStreamOutcomeCallable UntagStreamCallable(const Model::UntagStreamRequest& request) const;
+
+        /**
+         * <p>Removes one or more tags from a stream. In the request, specify only a tag
+         * key or keys; don't specify the value. If you specify a tag key that does not
+         * exist, it's ignored.</p> <p>In the request, you must provide the
+         * <code>StreamName</code> or <code>StreamARN</code>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/UntagStream">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void UntagStreamAsync(const Model::UntagStreamRequest& request, const UntagStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p> Increases or decreases the stream's data retention period by the value that
+         * you specify. To indicate whether you want to increase or decrease the data
+         * retention period, specify the <code>Operation</code> parameter in the request
+         * body. In the request, you must specify either the <code>StreamName</code> or the
+         * <code>StreamARN</code>. </p>  <p>The retention period that you specify
+         * replaces the current value.</p>  <p>This operation requires permission
+         * for the <code>KinesisVideo:UpdateDataRetention</code> action.</p> <p>Changing
+         * the data retention period affects the data in the stream as follows:</p> <ul>
+         * <li> <p>If the data retention period is increased, existing data is retained for
+         * the new retention period. For example, if the data retention period is increased
+         * from one hour to seven hours, all existing data is retained for seven hours.</p>
+         * </li> <li> <p>If the data retention period is decreased, existing data is
+         * retained for the new retention period. For example, if the data retention period
+         * is decreased from seven hours to one hour, all existing data is retained for one
+         * hour, and any data older than one hour is deleted immediately.</p> </li>
+         * </ul><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/UpdateDataRetention">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::UpdateDataRetentionOutcome UpdateDataRetention(const Model::UpdateDataRetentionRequest& request) const;
+
+        /**
+         * <p> Increases or decreases the stream's data retention period by the value that
+         * you specify. To indicate whether you want to increase or decrease the data
+         * retention period, specify the <code>Operation</code> parameter in the request
+         * body. In the request, you must specify either the <code>StreamName</code> or the
+         * <code>StreamARN</code>. </p>  <p>The retention period that you specify
+         * replaces the current value.</p>  <p>This operation requires permission
+         * for the <code>KinesisVideo:UpdateDataRetention</code> action.</p> <p>Changing
+         * the data retention period affects the data in the stream as follows:</p> <ul>
+         * <li> <p>If the data retention period is increased, existing data is retained for
+         * the new retention period. For example, if the data retention period is increased
+         * from one hour to seven hours, all existing data is retained for seven hours.</p>
+         * </li> <li> <p>If the data retention period is decreased, existing data is
+         * retained for the new retention period. For example, if the data retention period
+         * is decreased from seven hours to one hour, all existing data is retained for one
+         * hour, and any data older than one hour is deleted immediately.</p> </li>
+         * </ul><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/UpdateDataRetention">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::UpdateDataRetentionOutcomeCallable UpdateDataRetentionCallable(const Model::UpdateDataRetentionRequest& request) const;
+
+        /**
+         * <p> Increases or decreases the stream's data retention period by the value that
+         * you specify. To indicate whether you want to increase or decrease the data
+         * retention period, specify the <code>Operation</code> parameter in the request
+         * body. In the request, you must specify either the <code>StreamName</code> or the
+         * <code>StreamARN</code>. </p>  <p>The retention period that you specify
+         * replaces the current value.</p>  <p>This operation requires permission
+         * for the <code>KinesisVideo:UpdateDataRetention</code> action.</p> <p>Changing
+         * the data retention period affects the data in the stream as follows:</p> <ul>
+         * <li> <p>If the data retention period is increased, existing data is retained for
+         * the new retention period. For example, if the data retention period is increased
+         * from one hour to seven hours, all existing data is retained for seven hours.</p>
+         * </li> <li> <p>If the data retention period is decreased, existing data is
+         * retained for the new retention period. For example, if the data retention period
+         * is decreased from seven hours to one hour, all existing data is retained for one
+         * hour, and any data older than one hour is deleted immediately.</p> </li>
+         * </ul><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/UpdateDataRetention">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void UpdateDataRetentionAsync(const Model::UpdateDataRetentionRequest& request, const UpdateDataRetentionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Updates the existing signaling channel. This is an asynchronous operation and
+         * takes time to complete. </p> <p>If the <code>MessageTtlSeconds</code> value is
+         * updated (either increased or reduced), it only applies to new messages sent via
+         * this channel after it's been updated. Existing messages are still expired as per
+         * the previous <code>MessageTtlSeconds</code> value.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/UpdateSignalingChannel">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::UpdateSignalingChannelOutcome UpdateSignalingChannel(const Model::UpdateSignalingChannelRequest& request) const;
+
+        /**
+         * <p>Updates the existing signaling channel. This is an asynchronous operation and
+         * takes time to complete. </p> <p>If the <code>MessageTtlSeconds</code> value is
+         * updated (either increased or reduced), it only applies to new messages sent via
+         * this channel after it's been updated. Existing messages are still expired as per
+         * the previous <code>MessageTtlSeconds</code> value.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/UpdateSignalingChannel">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::UpdateSignalingChannelOutcomeCallable UpdateSignalingChannelCallable(const Model::UpdateSignalingChannelRequest& request) const;
+
+        /**
+         * <p>Updates the existing signaling channel. This is an asynchronous operation and
+         * takes time to complete. </p> <p>If the <code>MessageTtlSeconds</code> value is
+         * updated (either increased or reduced), it only applies to new messages sent via
+         * this channel after it's been updated. Existing messages are still expired as per
+         * the previous <code>MessageTtlSeconds</code> value.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/UpdateSignalingChannel">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void UpdateSignalingChannelAsync(const Model::UpdateSignalingChannelRequest& request, const UpdateSignalingChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Updates stream metadata, such as the device name and media type.</p> <p>You
+         * must provide the stream name or the Amazon Resource Name (ARN) of the
+         * stream.</p> <p>To make sure that you have the latest version of the stream
+         * before updating it, you can specify the stream version. Kinesis Video Streams
+         * assigns a version to each stream. When you update a stream, Kinesis Video
+         * Streams assigns a new version number. To get the latest stream version, use the
+         * <code>DescribeStream</code> API. </p> <p> <code>UpdateStream</code> is an
+         * asynchronous operation, and takes time to complete.</p><p><h3>See Also:</h3>  
+         * <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/UpdateStream">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::UpdateStreamOutcome UpdateStream(const Model::UpdateStreamRequest& request) const;
+
+        /**
+         * <p>Updates stream metadata, such as the device name and media type.</p> <p>You
+         * must provide the stream name or the Amazon Resource Name (ARN) of the
+         * stream.</p> <p>To make sure that you have the latest version of the stream
+         * before updating it, you can specify the stream version. Kinesis Video Streams
+         * assigns a version to each stream. When you update a stream, Kinesis Video
+         * Streams assigns a new version number. To get the latest stream version, use the
+         * <code>DescribeStream</code> API. </p> <p> <code>UpdateStream</code> is an
+         * asynchronous operation, and takes time to complete.</p><p><h3>See Also:</h3>  
+         * <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/UpdateStream">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::UpdateStreamOutcomeCallable UpdateStreamCallable(const Model::UpdateStreamRequest& request) const;
+
+        /**
+         * <p>Updates stream metadata, such as the device name and media type.</p> <p>You
+         * must provide the stream name or the Amazon Resource Name (ARN) of the
+         * stream.</p> <p>To make sure that you have the latest version of the stream
+         * before updating it, you can specify the stream version. Kinesis Video Streams
+         * assigns a version to each stream. When you update a stream, Kinesis Video
+         * Streams assigns a new version number. To get the latest stream version, use the
+         * <code>DescribeStream</code> API. </p> <p> <code>UpdateStream</code> is an
+         * asynchronous operation, and takes time to complete.</p><p><h3>See Also:</h3>  
+         * <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/UpdateStream">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void UpdateStreamAsync(const Model::UpdateStreamRequest& request, const UpdateStreamResponseReceivedHandler& 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 CreateSignalingChannelAsyncHelper(const Model::CreateSignalingChannelRequest& request, const CreateSignalingChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void CreateStreamAsyncHelper(const Model::CreateStreamRequest& request, const CreateStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DeleteSignalingChannelAsyncHelper(const Model::DeleteSignalingChannelRequest& request, const DeleteSignalingChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DeleteStreamAsyncHelper(const Model::DeleteStreamRequest& request, const DeleteStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DescribeSignalingChannelAsyncHelper(const Model::DescribeSignalingChannelRequest& request, const DescribeSignalingChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DescribeStreamAsyncHelper(const Model::DescribeStreamRequest& request, const DescribeStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void GetDataEndpointAsyncHelper(const Model::GetDataEndpointRequest& request, const GetDataEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void GetSignalingChannelEndpointAsyncHelper(const Model::GetSignalingChannelEndpointRequest& request, const GetSignalingChannelEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void ListSignalingChannelsAsyncHelper(const Model::ListSignalingChannelsRequest& request, const ListSignalingChannelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void ListStreamsAsyncHelper(const Model::ListStreamsRequest& request, const ListStreamsResponseReceivedHandler& 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 ListTagsForStreamAsyncHelper(const Model::ListTagsForStreamRequest& request, const ListTagsForStreamResponseReceivedHandler& 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 TagStreamAsyncHelper(const Model::TagStreamRequest& request, const TagStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void UntagResourceAsyncHelper(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void UntagStreamAsyncHelper(const Model::UntagStreamRequest& request, const UntagStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void UpdateDataRetentionAsyncHelper(const Model::UpdateDataRetentionRequest& request, const UpdateDataRetentionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void UpdateSignalingChannelAsyncHelper(const Model::UpdateSignalingChannelRequest& request, const UpdateSignalingChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void UpdateStreamAsyncHelper(const Model::UpdateStreamRequest& request, const UpdateStreamResponseReceivedHandler& 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 KinesisVideo
+} // namespace Aws

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

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/KinesisVideoErrorMarshaller.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/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/core/client/AWSErrorMarshaller.h>
+
+namespace Aws
+{
+namespace Client
+{
+
+class AWS_KINESISVIDEO_API KinesisVideoErrorMarshaller : 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-kinesisvideo/include/aws/kinesisvideo/KinesisVideoErrors.h

@@ -0,0 +1,82 @@
+/**
+ * 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/kinesisvideo/KinesisVideo_EXPORTS.h>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+enum class KinesisVideoErrors
+{
+  //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,
+  ///////////////////////////////////////////////////////////////////////////////////////////
+
+  ACCOUNT_CHANNEL_LIMIT_EXCEEDED= static_cast<int>(Aws::Client::CoreErrors::SERVICE_EXTENSION_START_RANGE) + 1,
+  ACCOUNT_STREAM_LIMIT_EXCEEDED,
+  CLIENT_LIMIT_EXCEEDED,
+  DEVICE_STREAM_LIMIT_EXCEEDED,
+  INVALID_ARGUMENT,
+  INVALID_DEVICE,
+  INVALID_RESOURCE_FORMAT,
+  NOT_AUTHORIZED,
+  RESOURCE_IN_USE,
+  TAGS_PER_RESOURCE_EXCEEDED_LIMIT,
+  VERSION_MISMATCH
+};
+
+class AWS_KINESISVIDEO_API KinesisVideoError : public Aws::Client::AWSError<KinesisVideoErrors>
+{
+public:
+  KinesisVideoError() {}
+  KinesisVideoError(const Aws::Client::AWSError<Aws::Client::CoreErrors>& rhs) : Aws::Client::AWSError<KinesisVideoErrors>(rhs) {}
+  KinesisVideoError(Aws::Client::AWSError<Aws::Client::CoreErrors>&& rhs) : Aws::Client::AWSError<KinesisVideoErrors>(rhs) {}
+  KinesisVideoError(const Aws::Client::AWSError<KinesisVideoErrors>& rhs) : Aws::Client::AWSError<KinesisVideoErrors>(rhs) {}
+  KinesisVideoError(Aws::Client::AWSError<KinesisVideoErrors>&& rhs) : Aws::Client::AWSError<KinesisVideoErrors>(rhs) {}
+
+  template <typename T>
+  T GetModeledError();
+};
+
+namespace KinesisVideoErrorMapper
+{
+  AWS_KINESISVIDEO_API Aws::Client::AWSError<Aws::Client::CoreErrors> GetErrorForName(const char* errorName);
+}
+
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/KinesisVideoRequest.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/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/core/AmazonSerializableWebServiceRequest.h>
+#include <aws/core/utils/UnreferencedParam.h>
+#include <aws/core/http/HttpRequest.h>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+  class AWS_KINESISVIDEO_API KinesisVideoRequest : public Aws::AmazonSerializableWebServiceRequest
+  {
+  public:
+    virtual ~KinesisVideoRequest () {}
+
+    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-30"));
+      return headers;
+    }
+
+  protected:
+    virtual Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const { return Aws::Http::HeaderValueCollection(); }
+
+  };
+
+
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/KinesisVideo_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_KINESISVIDEO_EXPORTS
+            #define AWS_KINESISVIDEO_API __declspec(dllexport)
+        #else
+            #define AWS_KINESISVIDEO_API __declspec(dllimport)
+        #endif /* AWS_KINESISVIDEO_EXPORTS */
+    #else
+        #define AWS_KINESISVIDEO_API
+    #endif // USE_IMPORT_EXPORT
+#else // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)
+    #define AWS_KINESISVIDEO_API
+#endif // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/APIName.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/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+  enum class APIName
+  {
+    NOT_SET,
+    PUT_MEDIA,
+    GET_MEDIA,
+    LIST_FRAGMENTS,
+    GET_MEDIA_FOR_FRAGMENT_LIST,
+    GET_HLS_STREAMING_SESSION_URL,
+    GET_DASH_STREAMING_SESSION_URL,
+    GET_CLIP
+  };
+
+namespace APINameMapper
+{
+AWS_KINESISVIDEO_API APIName GetAPINameForName(const Aws::String& name);
+
+AWS_KINESISVIDEO_API Aws::String GetNameForAPIName(APIName value);
+} // namespace APINameMapper
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/ChannelInfo.h

@@ -0,0 +1,323 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/kinesisvideo/model/ChannelType.h>
+#include <aws/kinesisvideo/model/Status.h>
+#include <aws/core/utils/DateTime.h>
+#include <aws/kinesisvideo/model/SingleMasterConfiguration.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   * <p>A structure that encapsulates a signaling channel's metadata and
+   * properties.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/ChannelInfo">AWS
+   * API Reference</a></p>
+   */
+  class AWS_KINESISVIDEO_API ChannelInfo
+  {
+  public:
+    ChannelInfo();
+    ChannelInfo(Aws::Utils::Json::JsonView jsonValue);
+    ChannelInfo& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the signaling channel.</p>
+     */
+    inline const Aws::String& GetChannelName() const{ return m_channelName; }
+
+    /**
+     * <p>The name of the signaling channel.</p>
+     */
+    inline bool ChannelNameHasBeenSet() const { return m_channelNameHasBeenSet; }
+
+    /**
+     * <p>The name of the signaling channel.</p>
+     */
+    inline void SetChannelName(const Aws::String& value) { m_channelNameHasBeenSet = true; m_channelName = value; }
+
+    /**
+     * <p>The name of the signaling channel.</p>
+     */
+    inline void SetChannelName(Aws::String&& value) { m_channelNameHasBeenSet = true; m_channelName = std::move(value); }
+
+    /**
+     * <p>The name of the signaling channel.</p>
+     */
+    inline void SetChannelName(const char* value) { m_channelNameHasBeenSet = true; m_channelName.assign(value); }
+
+    /**
+     * <p>The name of the signaling channel.</p>
+     */
+    inline ChannelInfo& WithChannelName(const Aws::String& value) { SetChannelName(value); return *this;}
+
+    /**
+     * <p>The name of the signaling channel.</p>
+     */
+    inline ChannelInfo& WithChannelName(Aws::String&& value) { SetChannelName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the signaling channel.</p>
+     */
+    inline ChannelInfo& WithChannelName(const char* value) { SetChannelName(value); return *this;}
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel.</p>
+     */
+    inline const Aws::String& GetChannelARN() const{ return m_channelARN; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel.</p>
+     */
+    inline bool ChannelARNHasBeenSet() const { return m_channelARNHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel.</p>
+     */
+    inline void SetChannelARN(const Aws::String& value) { m_channelARNHasBeenSet = true; m_channelARN = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel.</p>
+     */
+    inline void SetChannelARN(Aws::String&& value) { m_channelARNHasBeenSet = true; m_channelARN = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel.</p>
+     */
+    inline void SetChannelARN(const char* value) { m_channelARNHasBeenSet = true; m_channelARN.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel.</p>
+     */
+    inline ChannelInfo& WithChannelARN(const Aws::String& value) { SetChannelARN(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel.</p>
+     */
+    inline ChannelInfo& WithChannelARN(Aws::String&& value) { SetChannelARN(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel.</p>
+     */
+    inline ChannelInfo& WithChannelARN(const char* value) { SetChannelARN(value); return *this;}
+
+
+    /**
+     * <p>The type of the signaling channel.</p>
+     */
+    inline const ChannelType& GetChannelType() const{ return m_channelType; }
+
+    /**
+     * <p>The type of the signaling channel.</p>
+     */
+    inline bool ChannelTypeHasBeenSet() const { return m_channelTypeHasBeenSet; }
+
+    /**
+     * <p>The type of the signaling channel.</p>
+     */
+    inline void SetChannelType(const ChannelType& value) { m_channelTypeHasBeenSet = true; m_channelType = value; }
+
+    /**
+     * <p>The type of the signaling channel.</p>
+     */
+    inline void SetChannelType(ChannelType&& value) { m_channelTypeHasBeenSet = true; m_channelType = std::move(value); }
+
+    /**
+     * <p>The type of the signaling channel.</p>
+     */
+    inline ChannelInfo& WithChannelType(const ChannelType& value) { SetChannelType(value); return *this;}
+
+    /**
+     * <p>The type of the signaling channel.</p>
+     */
+    inline ChannelInfo& WithChannelType(ChannelType&& value) { SetChannelType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Current status of the signaling channel.</p>
+     */
+    inline const Status& GetChannelStatus() const{ return m_channelStatus; }
+
+    /**
+     * <p>Current status of the signaling channel.</p>
+     */
+    inline bool ChannelStatusHasBeenSet() const { return m_channelStatusHasBeenSet; }
+
+    /**
+     * <p>Current status of the signaling channel.</p>
+     */
+    inline void SetChannelStatus(const Status& value) { m_channelStatusHasBeenSet = true; m_channelStatus = value; }
+
+    /**
+     * <p>Current status of the signaling channel.</p>
+     */
+    inline void SetChannelStatus(Status&& value) { m_channelStatusHasBeenSet = true; m_channelStatus = std::move(value); }
+
+    /**
+     * <p>Current status of the signaling channel.</p>
+     */
+    inline ChannelInfo& WithChannelStatus(const Status& value) { SetChannelStatus(value); return *this;}
+
+    /**
+     * <p>Current status of the signaling channel.</p>
+     */
+    inline ChannelInfo& WithChannelStatus(Status&& value) { SetChannelStatus(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The time at which the signaling channel was created.</p>
+     */
+    inline const Aws::Utils::DateTime& GetCreationTime() const{ return m_creationTime; }
+
+    /**
+     * <p>The time at which the signaling channel was created.</p>
+     */
+    inline bool CreationTimeHasBeenSet() const { return m_creationTimeHasBeenSet; }
+
+    /**
+     * <p>The time at which the signaling channel was created.</p>
+     */
+    inline void SetCreationTime(const Aws::Utils::DateTime& value) { m_creationTimeHasBeenSet = true; m_creationTime = value; }
+
+    /**
+     * <p>The time at which the signaling channel was created.</p>
+     */
+    inline void SetCreationTime(Aws::Utils::DateTime&& value) { m_creationTimeHasBeenSet = true; m_creationTime = std::move(value); }
+
+    /**
+     * <p>The time at which the signaling channel was created.</p>
+     */
+    inline ChannelInfo& WithCreationTime(const Aws::Utils::DateTime& value) { SetCreationTime(value); return *this;}
+
+    /**
+     * <p>The time at which the signaling channel was created.</p>
+     */
+    inline ChannelInfo& WithCreationTime(Aws::Utils::DateTime&& value) { SetCreationTime(std::move(value)); return *this;}
+
+
+    /**
+     * <p>A structure that contains the configuration for the
+     * <code>SINGLE_MASTER</code> channel type.</p>
+     */
+    inline const SingleMasterConfiguration& GetSingleMasterConfiguration() const{ return m_singleMasterConfiguration; }
+
+    /**
+     * <p>A structure that contains the configuration for the
+     * <code>SINGLE_MASTER</code> channel type.</p>
+     */
+    inline bool SingleMasterConfigurationHasBeenSet() const { return m_singleMasterConfigurationHasBeenSet; }
+
+    /**
+     * <p>A structure that contains the configuration for the
+     * <code>SINGLE_MASTER</code> channel type.</p>
+     */
+    inline void SetSingleMasterConfiguration(const SingleMasterConfiguration& value) { m_singleMasterConfigurationHasBeenSet = true; m_singleMasterConfiguration = value; }
+
+    /**
+     * <p>A structure that contains the configuration for the
+     * <code>SINGLE_MASTER</code> channel type.</p>
+     */
+    inline void SetSingleMasterConfiguration(SingleMasterConfiguration&& value) { m_singleMasterConfigurationHasBeenSet = true; m_singleMasterConfiguration = std::move(value); }
+
+    /**
+     * <p>A structure that contains the configuration for the
+     * <code>SINGLE_MASTER</code> channel type.</p>
+     */
+    inline ChannelInfo& WithSingleMasterConfiguration(const SingleMasterConfiguration& value) { SetSingleMasterConfiguration(value); return *this;}
+
+    /**
+     * <p>A structure that contains the configuration for the
+     * <code>SINGLE_MASTER</code> channel type.</p>
+     */
+    inline ChannelInfo& WithSingleMasterConfiguration(SingleMasterConfiguration&& value) { SetSingleMasterConfiguration(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The current version of the signaling channel.</p>
+     */
+    inline const Aws::String& GetVersion() const{ return m_version; }
+
+    /**
+     * <p>The current version of the signaling channel.</p>
+     */
+    inline bool VersionHasBeenSet() const { return m_versionHasBeenSet; }
+
+    /**
+     * <p>The current version of the signaling channel.</p>
+     */
+    inline void SetVersion(const Aws::String& value) { m_versionHasBeenSet = true; m_version = value; }
+
+    /**
+     * <p>The current version of the signaling channel.</p>
+     */
+    inline void SetVersion(Aws::String&& value) { m_versionHasBeenSet = true; m_version = std::move(value); }
+
+    /**
+     * <p>The current version of the signaling channel.</p>
+     */
+    inline void SetVersion(const char* value) { m_versionHasBeenSet = true; m_version.assign(value); }
+
+    /**
+     * <p>The current version of the signaling channel.</p>
+     */
+    inline ChannelInfo& WithVersion(const Aws::String& value) { SetVersion(value); return *this;}
+
+    /**
+     * <p>The current version of the signaling channel.</p>
+     */
+    inline ChannelInfo& WithVersion(Aws::String&& value) { SetVersion(std::move(value)); return *this;}
+
+    /**
+     * <p>The current version of the signaling channel.</p>
+     */
+    inline ChannelInfo& WithVersion(const char* value) { SetVersion(value); return *this;}
+
+  private:
+
+    Aws::String m_channelName;
+    bool m_channelNameHasBeenSet;
+
+    Aws::String m_channelARN;
+    bool m_channelARNHasBeenSet;
+
+    ChannelType m_channelType;
+    bool m_channelTypeHasBeenSet;
+
+    Status m_channelStatus;
+    bool m_channelStatusHasBeenSet;
+
+    Aws::Utils::DateTime m_creationTime;
+    bool m_creationTimeHasBeenSet;
+
+    SingleMasterConfiguration m_singleMasterConfiguration;
+    bool m_singleMasterConfigurationHasBeenSet;
+
+    Aws::String m_version;
+    bool m_versionHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/ChannelNameCondition.h

@@ -0,0 +1,139 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/model/ComparisonOperator.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 KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   * <p>An optional input parameter for the <code>ListSignalingChannels</code> API.
+   * When this parameter is specified while invoking
+   * <code>ListSignalingChannels</code>, the API returns only the channels that
+   * satisfy a condition specified in
+   * <code>ChannelNameCondition</code>.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/ChannelNameCondition">AWS
+   * API Reference</a></p>
+   */
+  class AWS_KINESISVIDEO_API ChannelNameCondition
+  {
+  public:
+    ChannelNameCondition();
+    ChannelNameCondition(Aws::Utils::Json::JsonView jsonValue);
+    ChannelNameCondition& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>A comparison operator. Currently, you can only specify the
+     * <code>BEGINS_WITH</code> operator, which finds signaling channels whose names
+     * begin with a given prefix.</p>
+     */
+    inline const ComparisonOperator& GetComparisonOperator() const{ return m_comparisonOperator; }
+
+    /**
+     * <p>A comparison operator. Currently, you can only specify the
+     * <code>BEGINS_WITH</code> operator, which finds signaling channels whose names
+     * begin with a given prefix.</p>
+     */
+    inline bool ComparisonOperatorHasBeenSet() const { return m_comparisonOperatorHasBeenSet; }
+
+    /**
+     * <p>A comparison operator. Currently, you can only specify the
+     * <code>BEGINS_WITH</code> operator, which finds signaling channels whose names
+     * begin with a given prefix.</p>
+     */
+    inline void SetComparisonOperator(const ComparisonOperator& value) { m_comparisonOperatorHasBeenSet = true; m_comparisonOperator = value; }
+
+    /**
+     * <p>A comparison operator. Currently, you can only specify the
+     * <code>BEGINS_WITH</code> operator, which finds signaling channels whose names
+     * begin with a given prefix.</p>
+     */
+    inline void SetComparisonOperator(ComparisonOperator&& value) { m_comparisonOperatorHasBeenSet = true; m_comparisonOperator = std::move(value); }
+
+    /**
+     * <p>A comparison operator. Currently, you can only specify the
+     * <code>BEGINS_WITH</code> operator, which finds signaling channels whose names
+     * begin with a given prefix.</p>
+     */
+    inline ChannelNameCondition& WithComparisonOperator(const ComparisonOperator& value) { SetComparisonOperator(value); return *this;}
+
+    /**
+     * <p>A comparison operator. Currently, you can only specify the
+     * <code>BEGINS_WITH</code> operator, which finds signaling channels whose names
+     * begin with a given prefix.</p>
+     */
+    inline ChannelNameCondition& WithComparisonOperator(ComparisonOperator&& value) { SetComparisonOperator(std::move(value)); return *this;}
+
+
+    /**
+     * <p>A value to compare.</p>
+     */
+    inline const Aws::String& GetComparisonValue() const{ return m_comparisonValue; }
+
+    /**
+     * <p>A value to compare.</p>
+     */
+    inline bool ComparisonValueHasBeenSet() const { return m_comparisonValueHasBeenSet; }
+
+    /**
+     * <p>A value to compare.</p>
+     */
+    inline void SetComparisonValue(const Aws::String& value) { m_comparisonValueHasBeenSet = true; m_comparisonValue = value; }
+
+    /**
+     * <p>A value to compare.</p>
+     */
+    inline void SetComparisonValue(Aws::String&& value) { m_comparisonValueHasBeenSet = true; m_comparisonValue = std::move(value); }
+
+    /**
+     * <p>A value to compare.</p>
+     */
+    inline void SetComparisonValue(const char* value) { m_comparisonValueHasBeenSet = true; m_comparisonValue.assign(value); }
+
+    /**
+     * <p>A value to compare.</p>
+     */
+    inline ChannelNameCondition& WithComparisonValue(const Aws::String& value) { SetComparisonValue(value); return *this;}
+
+    /**
+     * <p>A value to compare.</p>
+     */
+    inline ChannelNameCondition& WithComparisonValue(Aws::String&& value) { SetComparisonValue(std::move(value)); return *this;}
+
+    /**
+     * <p>A value to compare.</p>
+     */
+    inline ChannelNameCondition& WithComparisonValue(const char* value) { SetComparisonValue(value); return *this;}
+
+  private:
+
+    ComparisonOperator m_comparisonOperator;
+    bool m_comparisonOperatorHasBeenSet;
+
+    Aws::String m_comparisonValue;
+    bool m_comparisonValueHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/ChannelProtocol.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/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+  enum class ChannelProtocol
+  {
+    NOT_SET,
+    WSS,
+    HTTPS
+  };
+
+namespace ChannelProtocolMapper
+{
+AWS_KINESISVIDEO_API ChannelProtocol GetChannelProtocolForName(const Aws::String& name);
+
+AWS_KINESISVIDEO_API Aws::String GetNameForChannelProtocol(ChannelProtocol value);
+} // namespace ChannelProtocolMapper
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/ChannelRole.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/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+  enum class ChannelRole
+  {
+    NOT_SET,
+    MASTER,
+    VIEWER
+  };
+
+namespace ChannelRoleMapper
+{
+AWS_KINESISVIDEO_API ChannelRole GetChannelRoleForName(const Aws::String& name);
+
+AWS_KINESISVIDEO_API Aws::String GetNameForChannelRole(ChannelRole value);
+} // namespace ChannelRoleMapper
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/ChannelType.h

@@ -0,0 +1,30 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+  enum class ChannelType
+  {
+    NOT_SET,
+    SINGLE_MASTER
+  };
+
+namespace ChannelTypeMapper
+{
+AWS_KINESISVIDEO_API ChannelType GetChannelTypeForName(const Aws::String& name);
+
+AWS_KINESISVIDEO_API Aws::String GetNameForChannelType(ChannelType value);
+} // namespace ChannelTypeMapper
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/ComparisonOperator.h

@@ -0,0 +1,30 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+  enum class ComparisonOperator
+  {
+    NOT_SET,
+    BEGINS_WITH
+  };
+
+namespace ComparisonOperatorMapper
+{
+AWS_KINESISVIDEO_API ComparisonOperator GetComparisonOperatorForName(const Aws::String& name);
+
+AWS_KINESISVIDEO_API Aws::String GetNameForComparisonOperator(ComparisonOperator value);
+} // namespace ComparisonOperatorMapper
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/CreateSignalingChannelRequest.h

@@ -0,0 +1,227 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/KinesisVideoRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/kinesisvideo/model/ChannelType.h>
+#include <aws/kinesisvideo/model/SingleMasterConfiguration.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/kinesisvideo/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_KINESISVIDEO_API CreateSignalingChannelRequest : public KinesisVideoRequest
+  {
+  public:
+    CreateSignalingChannelRequest();
+
+    // 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 "CreateSignalingChannel"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>A name for the signaling channel that you are creating. It must be unique for
+     * each AWS account and AWS Region.</p>
+     */
+    inline const Aws::String& GetChannelName() const{ return m_channelName; }
+
+    /**
+     * <p>A name for the signaling channel that you are creating. It must be unique for
+     * each AWS account and AWS Region.</p>
+     */
+    inline bool ChannelNameHasBeenSet() const { return m_channelNameHasBeenSet; }
+
+    /**
+     * <p>A name for the signaling channel that you are creating. It must be unique for
+     * each AWS account and AWS Region.</p>
+     */
+    inline void SetChannelName(const Aws::String& value) { m_channelNameHasBeenSet = true; m_channelName = value; }
+
+    /**
+     * <p>A name for the signaling channel that you are creating. It must be unique for
+     * each AWS account and AWS Region.</p>
+     */
+    inline void SetChannelName(Aws::String&& value) { m_channelNameHasBeenSet = true; m_channelName = std::move(value); }
+
+    /**
+     * <p>A name for the signaling channel that you are creating. It must be unique for
+     * each AWS account and AWS Region.</p>
+     */
+    inline void SetChannelName(const char* value) { m_channelNameHasBeenSet = true; m_channelName.assign(value); }
+
+    /**
+     * <p>A name for the signaling channel that you are creating. It must be unique for
+     * each AWS account and AWS Region.</p>
+     */
+    inline CreateSignalingChannelRequest& WithChannelName(const Aws::String& value) { SetChannelName(value); return *this;}
+
+    /**
+     * <p>A name for the signaling channel that you are creating. It must be unique for
+     * each AWS account and AWS Region.</p>
+     */
+    inline CreateSignalingChannelRequest& WithChannelName(Aws::String&& value) { SetChannelName(std::move(value)); return *this;}
+
+    /**
+     * <p>A name for the signaling channel that you are creating. It must be unique for
+     * each AWS account and AWS Region.</p>
+     */
+    inline CreateSignalingChannelRequest& WithChannelName(const char* value) { SetChannelName(value); return *this;}
+
+
+    /**
+     * <p>A type of the signaling channel that you are creating. Currently,
+     * <code>SINGLE_MASTER</code> is the only supported channel type. </p>
+     */
+    inline const ChannelType& GetChannelType() const{ return m_channelType; }
+
+    /**
+     * <p>A type of the signaling channel that you are creating. Currently,
+     * <code>SINGLE_MASTER</code> is the only supported channel type. </p>
+     */
+    inline bool ChannelTypeHasBeenSet() const { return m_channelTypeHasBeenSet; }
+
+    /**
+     * <p>A type of the signaling channel that you are creating. Currently,
+     * <code>SINGLE_MASTER</code> is the only supported channel type. </p>
+     */
+    inline void SetChannelType(const ChannelType& value) { m_channelTypeHasBeenSet = true; m_channelType = value; }
+
+    /**
+     * <p>A type of the signaling channel that you are creating. Currently,
+     * <code>SINGLE_MASTER</code> is the only supported channel type. </p>
+     */
+    inline void SetChannelType(ChannelType&& value) { m_channelTypeHasBeenSet = true; m_channelType = std::move(value); }
+
+    /**
+     * <p>A type of the signaling channel that you are creating. Currently,
+     * <code>SINGLE_MASTER</code> is the only supported channel type. </p>
+     */
+    inline CreateSignalingChannelRequest& WithChannelType(const ChannelType& value) { SetChannelType(value); return *this;}
+
+    /**
+     * <p>A type of the signaling channel that you are creating. Currently,
+     * <code>SINGLE_MASTER</code> is the only supported channel type. </p>
+     */
+    inline CreateSignalingChannelRequest& WithChannelType(ChannelType&& value) { SetChannelType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>A structure containing the configuration for the <code>SINGLE_MASTER</code>
+     * channel type. </p>
+     */
+    inline const SingleMasterConfiguration& GetSingleMasterConfiguration() const{ return m_singleMasterConfiguration; }
+
+    /**
+     * <p>A structure containing the configuration for the <code>SINGLE_MASTER</code>
+     * channel type. </p>
+     */
+    inline bool SingleMasterConfigurationHasBeenSet() const { return m_singleMasterConfigurationHasBeenSet; }
+
+    /**
+     * <p>A structure containing the configuration for the <code>SINGLE_MASTER</code>
+     * channel type. </p>
+     */
+    inline void SetSingleMasterConfiguration(const SingleMasterConfiguration& value) { m_singleMasterConfigurationHasBeenSet = true; m_singleMasterConfiguration = value; }
+
+    /**
+     * <p>A structure containing the configuration for the <code>SINGLE_MASTER</code>
+     * channel type. </p>
+     */
+    inline void SetSingleMasterConfiguration(SingleMasterConfiguration&& value) { m_singleMasterConfigurationHasBeenSet = true; m_singleMasterConfiguration = std::move(value); }
+
+    /**
+     * <p>A structure containing the configuration for the <code>SINGLE_MASTER</code>
+     * channel type. </p>
+     */
+    inline CreateSignalingChannelRequest& WithSingleMasterConfiguration(const SingleMasterConfiguration& value) { SetSingleMasterConfiguration(value); return *this;}
+
+    /**
+     * <p>A structure containing the configuration for the <code>SINGLE_MASTER</code>
+     * channel type. </p>
+     */
+    inline CreateSignalingChannelRequest& WithSingleMasterConfiguration(SingleMasterConfiguration&& value) { SetSingleMasterConfiguration(std::move(value)); return *this;}
+
+
+    /**
+     * <p>A set of tags (key-value pairs) that you want to associate with this
+     * channel.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>A set of tags (key-value pairs) that you want to associate with this
+     * channel.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>A set of tags (key-value pairs) that you want to associate with this
+     * channel.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>A set of tags (key-value pairs) that you want to associate with this
+     * channel.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>A set of tags (key-value pairs) that you want to associate with this
+     * channel.</p>
+     */
+    inline CreateSignalingChannelRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>A set of tags (key-value pairs) that you want to associate with this
+     * channel.</p>
+     */
+    inline CreateSignalingChannelRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>A set of tags (key-value pairs) that you want to associate with this
+     * channel.</p>
+     */
+    inline CreateSignalingChannelRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>A set of tags (key-value pairs) that you want to associate with this
+     * channel.</p>
+     */
+    inline CreateSignalingChannelRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_channelName;
+    bool m_channelNameHasBeenSet;
+
+    ChannelType m_channelType;
+    bool m_channelTypeHasBeenSet;
+
+    SingleMasterConfiguration m_singleMasterConfiguration;
+    bool m_singleMasterConfigurationHasBeenSet;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/CreateSignalingChannelResult.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/kinesisvideo/KinesisVideo_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 KinesisVideo
+{
+namespace Model
+{
+  class AWS_KINESISVIDEO_API CreateSignalingChannelResult
+  {
+  public:
+    CreateSignalingChannelResult();
+    CreateSignalingChannelResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    CreateSignalingChannelResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the created channel.</p>
+     */
+    inline const Aws::String& GetChannelARN() const{ return m_channelARN; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the created channel.</p>
+     */
+    inline void SetChannelARN(const Aws::String& value) { m_channelARN = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the created channel.</p>
+     */
+    inline void SetChannelARN(Aws::String&& value) { m_channelARN = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the created channel.</p>
+     */
+    inline void SetChannelARN(const char* value) { m_channelARN.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the created channel.</p>
+     */
+    inline CreateSignalingChannelResult& WithChannelARN(const Aws::String& value) { SetChannelARN(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the created channel.</p>
+     */
+    inline CreateSignalingChannelResult& WithChannelARN(Aws::String&& value) { SetChannelARN(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the created channel.</p>
+     */
+    inline CreateSignalingChannelResult& WithChannelARN(const char* value) { SetChannelARN(value); return *this;}
+
+  private:
+
+    Aws::String m_channelARN;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/CreateStreamRequest.h

@@ -0,0 +1,478 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/KinesisVideoRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_KINESISVIDEO_API CreateStreamRequest : public KinesisVideoRequest
+  {
+  public:
+    CreateStreamRequest();
+
+    // 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 "CreateStream"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The name of the device that is writing to the stream. </p>  <p>In the
+     * current implementation, Kinesis Video Streams does not use this name.</p>
+     * 
+     */
+    inline const Aws::String& GetDeviceName() const{ return m_deviceName; }
+
+    /**
+     * <p>The name of the device that is writing to the stream. </p>  <p>In the
+     * current implementation, Kinesis Video Streams does not use this name.</p>
+     * 
+     */
+    inline bool DeviceNameHasBeenSet() const { return m_deviceNameHasBeenSet; }
+
+    /**
+     * <p>The name of the device that is writing to the stream. </p>  <p>In the
+     * current implementation, Kinesis Video Streams does not use this name.</p>
+     * 
+     */
+    inline void SetDeviceName(const Aws::String& value) { m_deviceNameHasBeenSet = true; m_deviceName = value; }
+
+    /**
+     * <p>The name of the device that is writing to the stream. </p>  <p>In the
+     * current implementation, Kinesis Video Streams does not use this name.</p>
+     * 
+     */
+    inline void SetDeviceName(Aws::String&& value) { m_deviceNameHasBeenSet = true; m_deviceName = std::move(value); }
+
+    /**
+     * <p>The name of the device that is writing to the stream. </p>  <p>In the
+     * current implementation, Kinesis Video Streams does not use this name.</p>
+     * 
+     */
+    inline void SetDeviceName(const char* value) { m_deviceNameHasBeenSet = true; m_deviceName.assign(value); }
+
+    /**
+     * <p>The name of the device that is writing to the stream. </p>  <p>In the
+     * current implementation, Kinesis Video Streams does not use this name.</p>
+     * 
+     */
+    inline CreateStreamRequest& WithDeviceName(const Aws::String& value) { SetDeviceName(value); return *this;}
+
+    /**
+     * <p>The name of the device that is writing to the stream. </p>  <p>In the
+     * current implementation, Kinesis Video Streams does not use this name.</p>
+     * 
+     */
+    inline CreateStreamRequest& WithDeviceName(Aws::String&& value) { SetDeviceName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the device that is writing to the stream. </p>  <p>In the
+     * current implementation, Kinesis Video Streams does not use this name.</p>
+     * 
+     */
+    inline CreateStreamRequest& WithDeviceName(const char* value) { SetDeviceName(value); return *this;}
+
+
+    /**
+     * <p>A name for the stream that you are creating.</p> <p>The stream name is an
+     * identifier for the stream, and must be unique for each account and region.</p>
+     */
+    inline const Aws::String& GetStreamName() const{ return m_streamName; }
+
+    /**
+     * <p>A name for the stream that you are creating.</p> <p>The stream name is an
+     * identifier for the stream, and must be unique for each account and region.</p>
+     */
+    inline bool StreamNameHasBeenSet() const { return m_streamNameHasBeenSet; }
+
+    /**
+     * <p>A name for the stream that you are creating.</p> <p>The stream name is an
+     * identifier for the stream, and must be unique for each account and region.</p>
+     */
+    inline void SetStreamName(const Aws::String& value) { m_streamNameHasBeenSet = true; m_streamName = value; }
+
+    /**
+     * <p>A name for the stream that you are creating.</p> <p>The stream name is an
+     * identifier for the stream, and must be unique for each account and region.</p>
+     */
+    inline void SetStreamName(Aws::String&& value) { m_streamNameHasBeenSet = true; m_streamName = std::move(value); }
+
+    /**
+     * <p>A name for the stream that you are creating.</p> <p>The stream name is an
+     * identifier for the stream, and must be unique for each account and region.</p>
+     */
+    inline void SetStreamName(const char* value) { m_streamNameHasBeenSet = true; m_streamName.assign(value); }
+
+    /**
+     * <p>A name for the stream that you are creating.</p> <p>The stream name is an
+     * identifier for the stream, and must be unique for each account and region.</p>
+     */
+    inline CreateStreamRequest& WithStreamName(const Aws::String& value) { SetStreamName(value); return *this;}
+
+    /**
+     * <p>A name for the stream that you are creating.</p> <p>The stream name is an
+     * identifier for the stream, and must be unique for each account and region.</p>
+     */
+    inline CreateStreamRequest& WithStreamName(Aws::String&& value) { SetStreamName(std::move(value)); return *this;}
+
+    /**
+     * <p>A name for the stream that you are creating.</p> <p>The stream name is an
+     * identifier for the stream, and must be unique for each account and region.</p>
+     */
+    inline CreateStreamRequest& WithStreamName(const char* value) { SetStreamName(value); return *this;}
+
+
+    /**
+     * <p>The media type of the stream. Consumers of the stream can use this
+     * information when processing the stream. For more information about media types,
+     * see <a
+     * href="http://www.iana.org/assignments/media-types/media-types.xhtml">Media
+     * Types</a>. If you choose to specify the <code>MediaType</code>, see <a
+     * href="https://tools.ietf.org/html/rfc6838#section-4.2">Naming Requirements</a>
+     * for guidelines.</p> <p>Example valid values include "video/h264" and
+     * "video/h264,audio/aac".</p> <p>This parameter is optional; the default value is
+     * <code>null</code> (or empty in JSON).</p>
+     */
+    inline const Aws::String& GetMediaType() const{ return m_mediaType; }
+
+    /**
+     * <p>The media type of the stream. Consumers of the stream can use this
+     * information when processing the stream. For more information about media types,
+     * see <a
+     * href="http://www.iana.org/assignments/media-types/media-types.xhtml">Media
+     * Types</a>. If you choose to specify the <code>MediaType</code>, see <a
+     * href="https://tools.ietf.org/html/rfc6838#section-4.2">Naming Requirements</a>
+     * for guidelines.</p> <p>Example valid values include "video/h264" and
+     * "video/h264,audio/aac".</p> <p>This parameter is optional; the default value is
+     * <code>null</code> (or empty in JSON).</p>
+     */
+    inline bool MediaTypeHasBeenSet() const { return m_mediaTypeHasBeenSet; }
+
+    /**
+     * <p>The media type of the stream. Consumers of the stream can use this
+     * information when processing the stream. For more information about media types,
+     * see <a
+     * href="http://www.iana.org/assignments/media-types/media-types.xhtml">Media
+     * Types</a>. If you choose to specify the <code>MediaType</code>, see <a
+     * href="https://tools.ietf.org/html/rfc6838#section-4.2">Naming Requirements</a>
+     * for guidelines.</p> <p>Example valid values include "video/h264" and
+     * "video/h264,audio/aac".</p> <p>This parameter is optional; the default value is
+     * <code>null</code> (or empty in JSON).</p>
+     */
+    inline void SetMediaType(const Aws::String& value) { m_mediaTypeHasBeenSet = true; m_mediaType = value; }
+
+    /**
+     * <p>The media type of the stream. Consumers of the stream can use this
+     * information when processing the stream. For more information about media types,
+     * see <a
+     * href="http://www.iana.org/assignments/media-types/media-types.xhtml">Media
+     * Types</a>. If you choose to specify the <code>MediaType</code>, see <a
+     * href="https://tools.ietf.org/html/rfc6838#section-4.2">Naming Requirements</a>
+     * for guidelines.</p> <p>Example valid values include "video/h264" and
+     * "video/h264,audio/aac".</p> <p>This parameter is optional; the default value is
+     * <code>null</code> (or empty in JSON).</p>
+     */
+    inline void SetMediaType(Aws::String&& value) { m_mediaTypeHasBeenSet = true; m_mediaType = std::move(value); }
+
+    /**
+     * <p>The media type of the stream. Consumers of the stream can use this
+     * information when processing the stream. For more information about media types,
+     * see <a
+     * href="http://www.iana.org/assignments/media-types/media-types.xhtml">Media
+     * Types</a>. If you choose to specify the <code>MediaType</code>, see <a
+     * href="https://tools.ietf.org/html/rfc6838#section-4.2">Naming Requirements</a>
+     * for guidelines.</p> <p>Example valid values include "video/h264" and
+     * "video/h264,audio/aac".</p> <p>This parameter is optional; the default value is
+     * <code>null</code> (or empty in JSON).</p>
+     */
+    inline void SetMediaType(const char* value) { m_mediaTypeHasBeenSet = true; m_mediaType.assign(value); }
+
+    /**
+     * <p>The media type of the stream. Consumers of the stream can use this
+     * information when processing the stream. For more information about media types,
+     * see <a
+     * href="http://www.iana.org/assignments/media-types/media-types.xhtml">Media
+     * Types</a>. If you choose to specify the <code>MediaType</code>, see <a
+     * href="https://tools.ietf.org/html/rfc6838#section-4.2">Naming Requirements</a>
+     * for guidelines.</p> <p>Example valid values include "video/h264" and
+     * "video/h264,audio/aac".</p> <p>This parameter is optional; the default value is
+     * <code>null</code> (or empty in JSON).</p>
+     */
+    inline CreateStreamRequest& WithMediaType(const Aws::String& value) { SetMediaType(value); return *this;}
+
+    /**
+     * <p>The media type of the stream. Consumers of the stream can use this
+     * information when processing the stream. For more information about media types,
+     * see <a
+     * href="http://www.iana.org/assignments/media-types/media-types.xhtml">Media
+     * Types</a>. If you choose to specify the <code>MediaType</code>, see <a
+     * href="https://tools.ietf.org/html/rfc6838#section-4.2">Naming Requirements</a>
+     * for guidelines.</p> <p>Example valid values include "video/h264" and
+     * "video/h264,audio/aac".</p> <p>This parameter is optional; the default value is
+     * <code>null</code> (or empty in JSON).</p>
+     */
+    inline CreateStreamRequest& WithMediaType(Aws::String&& value) { SetMediaType(std::move(value)); return *this;}
+
+    /**
+     * <p>The media type of the stream. Consumers of the stream can use this
+     * information when processing the stream. For more information about media types,
+     * see <a
+     * href="http://www.iana.org/assignments/media-types/media-types.xhtml">Media
+     * Types</a>. If you choose to specify the <code>MediaType</code>, see <a
+     * href="https://tools.ietf.org/html/rfc6838#section-4.2">Naming Requirements</a>
+     * for guidelines.</p> <p>Example valid values include "video/h264" and
+     * "video/h264,audio/aac".</p> <p>This parameter is optional; the default value is
+     * <code>null</code> (or empty in JSON).</p>
+     */
+    inline CreateStreamRequest& WithMediaType(const char* value) { SetMediaType(value); return *this;}
+
+
+    /**
+     * <p>The ID of the AWS Key Management Service (AWS KMS) key that you want Kinesis
+     * Video Streams to use to encrypt stream data.</p> <p>If no key ID is specified,
+     * the default, Kinesis Video-managed key (<code>aws/kinesisvideo</code>) is
+     * used.</p> <p> For more information, see <a
+     * href="https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html#API_DescribeKey_RequestParameters">DescribeKey</a>.
+     * </p>
+     */
+    inline const Aws::String& GetKmsKeyId() const{ return m_kmsKeyId; }
+
+    /**
+     * <p>The ID of the AWS Key Management Service (AWS KMS) key that you want Kinesis
+     * Video Streams to use to encrypt stream data.</p> <p>If no key ID is specified,
+     * the default, Kinesis Video-managed key (<code>aws/kinesisvideo</code>) is
+     * used.</p> <p> For more information, see <a
+     * href="https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html#API_DescribeKey_RequestParameters">DescribeKey</a>.
+     * </p>
+     */
+    inline bool KmsKeyIdHasBeenSet() const { return m_kmsKeyIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the AWS Key Management Service (AWS KMS) key that you want Kinesis
+     * Video Streams to use to encrypt stream data.</p> <p>If no key ID is specified,
+     * the default, Kinesis Video-managed key (<code>aws/kinesisvideo</code>) is
+     * used.</p> <p> For more information, see <a
+     * href="https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html#API_DescribeKey_RequestParameters">DescribeKey</a>.
+     * </p>
+     */
+    inline void SetKmsKeyId(const Aws::String& value) { m_kmsKeyIdHasBeenSet = true; m_kmsKeyId = value; }
+
+    /**
+     * <p>The ID of the AWS Key Management Service (AWS KMS) key that you want Kinesis
+     * Video Streams to use to encrypt stream data.</p> <p>If no key ID is specified,
+     * the default, Kinesis Video-managed key (<code>aws/kinesisvideo</code>) is
+     * used.</p> <p> For more information, see <a
+     * href="https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html#API_DescribeKey_RequestParameters">DescribeKey</a>.
+     * </p>
+     */
+    inline void SetKmsKeyId(Aws::String&& value) { m_kmsKeyIdHasBeenSet = true; m_kmsKeyId = std::move(value); }
+
+    /**
+     * <p>The ID of the AWS Key Management Service (AWS KMS) key that you want Kinesis
+     * Video Streams to use to encrypt stream data.</p> <p>If no key ID is specified,
+     * the default, Kinesis Video-managed key (<code>aws/kinesisvideo</code>) is
+     * used.</p> <p> For more information, see <a
+     * href="https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html#API_DescribeKey_RequestParameters">DescribeKey</a>.
+     * </p>
+     */
+    inline void SetKmsKeyId(const char* value) { m_kmsKeyIdHasBeenSet = true; m_kmsKeyId.assign(value); }
+
+    /**
+     * <p>The ID of the AWS Key Management Service (AWS KMS) key that you want Kinesis
+     * Video Streams to use to encrypt stream data.</p> <p>If no key ID is specified,
+     * the default, Kinesis Video-managed key (<code>aws/kinesisvideo</code>) is
+     * used.</p> <p> For more information, see <a
+     * href="https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html#API_DescribeKey_RequestParameters">DescribeKey</a>.
+     * </p>
+     */
+    inline CreateStreamRequest& WithKmsKeyId(const Aws::String& value) { SetKmsKeyId(value); return *this;}
+
+    /**
+     * <p>The ID of the AWS Key Management Service (AWS KMS) key that you want Kinesis
+     * Video Streams to use to encrypt stream data.</p> <p>If no key ID is specified,
+     * the default, Kinesis Video-managed key (<code>aws/kinesisvideo</code>) is
+     * used.</p> <p> For more information, see <a
+     * href="https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html#API_DescribeKey_RequestParameters">DescribeKey</a>.
+     * </p>
+     */
+    inline CreateStreamRequest& WithKmsKeyId(Aws::String&& value) { SetKmsKeyId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the AWS Key Management Service (AWS KMS) key that you want Kinesis
+     * Video Streams to use to encrypt stream data.</p> <p>If no key ID is specified,
+     * the default, Kinesis Video-managed key (<code>aws/kinesisvideo</code>) is
+     * used.</p> <p> For more information, see <a
+     * href="https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html#API_DescribeKey_RequestParameters">DescribeKey</a>.
+     * </p>
+     */
+    inline CreateStreamRequest& WithKmsKeyId(const char* value) { SetKmsKeyId(value); return *this;}
+
+
+    /**
+     * <p>The number of hours that you want to retain the data in the stream. Kinesis
+     * Video Streams retains the data in a data store that is associated with the
+     * stream.</p> <p>The default value is 0, indicating that the stream does not
+     * persist data.</p> <p>When the <code>DataRetentionInHours</code> value is 0,
+     * consumers can still consume the fragments that remain in the service host
+     * buffer, which has a retention time limit of 5 minutes and a retention memory
+     * limit of 200 MB. Fragments are removed from the buffer when either limit is
+     * reached.</p>
+     */
+    inline int GetDataRetentionInHours() const{ return m_dataRetentionInHours; }
+
+    /**
+     * <p>The number of hours that you want to retain the data in the stream. Kinesis
+     * Video Streams retains the data in a data store that is associated with the
+     * stream.</p> <p>The default value is 0, indicating that the stream does not
+     * persist data.</p> <p>When the <code>DataRetentionInHours</code> value is 0,
+     * consumers can still consume the fragments that remain in the service host
+     * buffer, which has a retention time limit of 5 minutes and a retention memory
+     * limit of 200 MB. Fragments are removed from the buffer when either limit is
+     * reached.</p>
+     */
+    inline bool DataRetentionInHoursHasBeenSet() const { return m_dataRetentionInHoursHasBeenSet; }
+
+    /**
+     * <p>The number of hours that you want to retain the data in the stream. Kinesis
+     * Video Streams retains the data in a data store that is associated with the
+     * stream.</p> <p>The default value is 0, indicating that the stream does not
+     * persist data.</p> <p>When the <code>DataRetentionInHours</code> value is 0,
+     * consumers can still consume the fragments that remain in the service host
+     * buffer, which has a retention time limit of 5 minutes and a retention memory
+     * limit of 200 MB. Fragments are removed from the buffer when either limit is
+     * reached.</p>
+     */
+    inline void SetDataRetentionInHours(int value) { m_dataRetentionInHoursHasBeenSet = true; m_dataRetentionInHours = value; }
+
+    /**
+     * <p>The number of hours that you want to retain the data in the stream. Kinesis
+     * Video Streams retains the data in a data store that is associated with the
+     * stream.</p> <p>The default value is 0, indicating that the stream does not
+     * persist data.</p> <p>When the <code>DataRetentionInHours</code> value is 0,
+     * consumers can still consume the fragments that remain in the service host
+     * buffer, which has a retention time limit of 5 minutes and a retention memory
+     * limit of 200 MB. Fragments are removed from the buffer when either limit is
+     * reached.</p>
+     */
+    inline CreateStreamRequest& WithDataRetentionInHours(int value) { SetDataRetentionInHours(value); return *this;}
+
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline void SetTags(const Aws::Map<Aws::String, Aws::String>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline void SetTags(Aws::Map<Aws::String, Aws::String>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline CreateStreamRequest& WithTags(const Aws::Map<Aws::String, Aws::String>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline CreateStreamRequest& WithTags(Aws::Map<Aws::String, Aws::String>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline CreateStreamRequest& AddTags(const Aws::String& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline CreateStreamRequest& AddTags(Aws::String&& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline CreateStreamRequest& AddTags(const Aws::String& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline CreateStreamRequest& AddTags(Aws::String&& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline CreateStreamRequest& AddTags(const char* key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline CreateStreamRequest& AddTags(Aws::String&& key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline CreateStreamRequest& AddTags(const char* key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+  private:
+
+    Aws::String m_deviceName;
+    bool m_deviceNameHasBeenSet;
+
+    Aws::String m_streamName;
+    bool m_streamNameHasBeenSet;
+
+    Aws::String m_mediaType;
+    bool m_mediaTypeHasBeenSet;
+
+    Aws::String m_kmsKeyId;
+    bool m_kmsKeyIdHasBeenSet;
+
+    int m_dataRetentionInHours;
+    bool m_dataRetentionInHoursHasBeenSet;
+
+    Aws::Map<Aws::String, Aws::String> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/CreateStreamResult.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/kinesisvideo/KinesisVideo_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 KinesisVideo
+{
+namespace Model
+{
+  class AWS_KINESISVIDEO_API CreateStreamResult
+  {
+  public:
+    CreateStreamResult();
+    CreateStreamResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    CreateStreamResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline const Aws::String& GetStreamARN() const{ return m_streamARN; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline void SetStreamARN(const Aws::String& value) { m_streamARN = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline void SetStreamARN(Aws::String&& value) { m_streamARN = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline void SetStreamARN(const char* value) { m_streamARN.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline CreateStreamResult& WithStreamARN(const Aws::String& value) { SetStreamARN(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline CreateStreamResult& WithStreamARN(Aws::String&& value) { SetStreamARN(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline CreateStreamResult& WithStreamARN(const char* value) { SetStreamARN(value); return *this;}
+
+  private:
+
+    Aws::String m_streamARN;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/DeleteSignalingChannelRequest.h

@@ -0,0 +1,151 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/KinesisVideoRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_KINESISVIDEO_API DeleteSignalingChannelRequest : public KinesisVideoRequest
+  {
+  public:
+    DeleteSignalingChannelRequest();
+
+    // 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 "DeleteSignalingChannel"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel that you want to
+     * delete.</p>
+     */
+    inline const Aws::String& GetChannelARN() const{ return m_channelARN; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel that you want to
+     * delete.</p>
+     */
+    inline bool ChannelARNHasBeenSet() const { return m_channelARNHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel that you want to
+     * delete.</p>
+     */
+    inline void SetChannelARN(const Aws::String& value) { m_channelARNHasBeenSet = true; m_channelARN = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel that you want to
+     * delete.</p>
+     */
+    inline void SetChannelARN(Aws::String&& value) { m_channelARNHasBeenSet = true; m_channelARN = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel that you want to
+     * delete.</p>
+     */
+    inline void SetChannelARN(const char* value) { m_channelARNHasBeenSet = true; m_channelARN.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel that you want to
+     * delete.</p>
+     */
+    inline DeleteSignalingChannelRequest& WithChannelARN(const Aws::String& value) { SetChannelARN(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel that you want to
+     * delete.</p>
+     */
+    inline DeleteSignalingChannelRequest& WithChannelARN(Aws::String&& value) { SetChannelARN(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel that you want to
+     * delete.</p>
+     */
+    inline DeleteSignalingChannelRequest& WithChannelARN(const char* value) { SetChannelARN(value); return *this;}
+
+
+    /**
+     * <p>The current version of the signaling channel that you want to delete. You can
+     * obtain the current version by invoking the <code>DescribeSignalingChannel</code>
+     * or <code>ListSignalingChannels</code> API operations.</p>
+     */
+    inline const Aws::String& GetCurrentVersion() const{ return m_currentVersion; }
+
+    /**
+     * <p>The current version of the signaling channel that you want to delete. You can
+     * obtain the current version by invoking the <code>DescribeSignalingChannel</code>
+     * or <code>ListSignalingChannels</code> API operations.</p>
+     */
+    inline bool CurrentVersionHasBeenSet() const { return m_currentVersionHasBeenSet; }
+
+    /**
+     * <p>The current version of the signaling channel that you want to delete. You can
+     * obtain the current version by invoking the <code>DescribeSignalingChannel</code>
+     * or <code>ListSignalingChannels</code> API operations.</p>
+     */
+    inline void SetCurrentVersion(const Aws::String& value) { m_currentVersionHasBeenSet = true; m_currentVersion = value; }
+
+    /**
+     * <p>The current version of the signaling channel that you want to delete. You can
+     * obtain the current version by invoking the <code>DescribeSignalingChannel</code>
+     * or <code>ListSignalingChannels</code> API operations.</p>
+     */
+    inline void SetCurrentVersion(Aws::String&& value) { m_currentVersionHasBeenSet = true; m_currentVersion = std::move(value); }
+
+    /**
+     * <p>The current version of the signaling channel that you want to delete. You can
+     * obtain the current version by invoking the <code>DescribeSignalingChannel</code>
+     * or <code>ListSignalingChannels</code> API operations.</p>
+     */
+    inline void SetCurrentVersion(const char* value) { m_currentVersionHasBeenSet = true; m_currentVersion.assign(value); }
+
+    /**
+     * <p>The current version of the signaling channel that you want to delete. You can
+     * obtain the current version by invoking the <code>DescribeSignalingChannel</code>
+     * or <code>ListSignalingChannels</code> API operations.</p>
+     */
+    inline DeleteSignalingChannelRequest& WithCurrentVersion(const Aws::String& value) { SetCurrentVersion(value); return *this;}
+
+    /**
+     * <p>The current version of the signaling channel that you want to delete. You can
+     * obtain the current version by invoking the <code>DescribeSignalingChannel</code>
+     * or <code>ListSignalingChannels</code> API operations.</p>
+     */
+    inline DeleteSignalingChannelRequest& WithCurrentVersion(Aws::String&& value) { SetCurrentVersion(std::move(value)); return *this;}
+
+    /**
+     * <p>The current version of the signaling channel that you want to delete. You can
+     * obtain the current version by invoking the <code>DescribeSignalingChannel</code>
+     * or <code>ListSignalingChannels</code> API operations.</p>
+     */
+    inline DeleteSignalingChannelRequest& WithCurrentVersion(const char* value) { SetCurrentVersion(value); return *this;}
+
+  private:
+
+    Aws::String m_channelARN;
+    bool m_channelARNHasBeenSet;
+
+    Aws::String m_currentVersion;
+    bool m_currentVersionHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

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

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/DeleteStreamRequest.h

@@ -0,0 +1,159 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/KinesisVideoRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_KINESISVIDEO_API DeleteStreamRequest : public KinesisVideoRequest
+  {
+  public:
+    DeleteStreamRequest();
+
+    // 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 "DeleteStream"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to delete. </p>
+     */
+    inline const Aws::String& GetStreamARN() const{ return m_streamARN; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to delete. </p>
+     */
+    inline bool StreamARNHasBeenSet() const { return m_streamARNHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to delete. </p>
+     */
+    inline void SetStreamARN(const Aws::String& value) { m_streamARNHasBeenSet = true; m_streamARN = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to delete. </p>
+     */
+    inline void SetStreamARN(Aws::String&& value) { m_streamARNHasBeenSet = true; m_streamARN = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to delete. </p>
+     */
+    inline void SetStreamARN(const char* value) { m_streamARNHasBeenSet = true; m_streamARN.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to delete. </p>
+     */
+    inline DeleteStreamRequest& WithStreamARN(const Aws::String& value) { SetStreamARN(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to delete. </p>
+     */
+    inline DeleteStreamRequest& WithStreamARN(Aws::String&& value) { SetStreamARN(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to delete. </p>
+     */
+    inline DeleteStreamRequest& WithStreamARN(const char* value) { SetStreamARN(value); return *this;}
+
+
+    /**
+     * <p>Optional: The version of the stream that you want to delete. </p> <p>Specify
+     * the version as a safeguard to ensure that your are deleting the correct stream.
+     * To get the stream version, use the <code>DescribeStream</code> API.</p> <p>If
+     * not specified, only the <code>CreationTime</code> is checked before deleting the
+     * stream.</p>
+     */
+    inline const Aws::String& GetCurrentVersion() const{ return m_currentVersion; }
+
+    /**
+     * <p>Optional: The version of the stream that you want to delete. </p> <p>Specify
+     * the version as a safeguard to ensure that your are deleting the correct stream.
+     * To get the stream version, use the <code>DescribeStream</code> API.</p> <p>If
+     * not specified, only the <code>CreationTime</code> is checked before deleting the
+     * stream.</p>
+     */
+    inline bool CurrentVersionHasBeenSet() const { return m_currentVersionHasBeenSet; }
+
+    /**
+     * <p>Optional: The version of the stream that you want to delete. </p> <p>Specify
+     * the version as a safeguard to ensure that your are deleting the correct stream.
+     * To get the stream version, use the <code>DescribeStream</code> API.</p> <p>If
+     * not specified, only the <code>CreationTime</code> is checked before deleting the
+     * stream.</p>
+     */
+    inline void SetCurrentVersion(const Aws::String& value) { m_currentVersionHasBeenSet = true; m_currentVersion = value; }
+
+    /**
+     * <p>Optional: The version of the stream that you want to delete. </p> <p>Specify
+     * the version as a safeguard to ensure that your are deleting the correct stream.
+     * To get the stream version, use the <code>DescribeStream</code> API.</p> <p>If
+     * not specified, only the <code>CreationTime</code> is checked before deleting the
+     * stream.</p>
+     */
+    inline void SetCurrentVersion(Aws::String&& value) { m_currentVersionHasBeenSet = true; m_currentVersion = std::move(value); }
+
+    /**
+     * <p>Optional: The version of the stream that you want to delete. </p> <p>Specify
+     * the version as a safeguard to ensure that your are deleting the correct stream.
+     * To get the stream version, use the <code>DescribeStream</code> API.</p> <p>If
+     * not specified, only the <code>CreationTime</code> is checked before deleting the
+     * stream.</p>
+     */
+    inline void SetCurrentVersion(const char* value) { m_currentVersionHasBeenSet = true; m_currentVersion.assign(value); }
+
+    /**
+     * <p>Optional: The version of the stream that you want to delete. </p> <p>Specify
+     * the version as a safeguard to ensure that your are deleting the correct stream.
+     * To get the stream version, use the <code>DescribeStream</code> API.</p> <p>If
+     * not specified, only the <code>CreationTime</code> is checked before deleting the
+     * stream.</p>
+     */
+    inline DeleteStreamRequest& WithCurrentVersion(const Aws::String& value) { SetCurrentVersion(value); return *this;}
+
+    /**
+     * <p>Optional: The version of the stream that you want to delete. </p> <p>Specify
+     * the version as a safeguard to ensure that your are deleting the correct stream.
+     * To get the stream version, use the <code>DescribeStream</code> API.</p> <p>If
+     * not specified, only the <code>CreationTime</code> is checked before deleting the
+     * stream.</p>
+     */
+    inline DeleteStreamRequest& WithCurrentVersion(Aws::String&& value) { SetCurrentVersion(std::move(value)); return *this;}
+
+    /**
+     * <p>Optional: The version of the stream that you want to delete. </p> <p>Specify
+     * the version as a safeguard to ensure that your are deleting the correct stream.
+     * To get the stream version, use the <code>DescribeStream</code> API.</p> <p>If
+     * not specified, only the <code>CreationTime</code> is checked before deleting the
+     * stream.</p>
+     */
+    inline DeleteStreamRequest& WithCurrentVersion(const char* value) { SetCurrentVersion(value); return *this;}
+
+  private:
+
+    Aws::String m_streamARN;
+    bool m_streamARNHasBeenSet;
+
+    Aws::String m_currentVersion;
+    bool m_currentVersionHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

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

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/DescribeSignalingChannelRequest.h

@@ -0,0 +1,127 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/KinesisVideoRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_KINESISVIDEO_API DescribeSignalingChannelRequest : public KinesisVideoRequest
+  {
+  public:
+    DescribeSignalingChannelRequest();
+
+    // 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 "DescribeSignalingChannel"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The name of the signaling channel that you want to describe.</p>
+     */
+    inline const Aws::String& GetChannelName() const{ return m_channelName; }
+
+    /**
+     * <p>The name of the signaling channel that you want to describe.</p>
+     */
+    inline bool ChannelNameHasBeenSet() const { return m_channelNameHasBeenSet; }
+
+    /**
+     * <p>The name of the signaling channel that you want to describe.</p>
+     */
+    inline void SetChannelName(const Aws::String& value) { m_channelNameHasBeenSet = true; m_channelName = value; }
+
+    /**
+     * <p>The name of the signaling channel that you want to describe.</p>
+     */
+    inline void SetChannelName(Aws::String&& value) { m_channelNameHasBeenSet = true; m_channelName = std::move(value); }
+
+    /**
+     * <p>The name of the signaling channel that you want to describe.</p>
+     */
+    inline void SetChannelName(const char* value) { m_channelNameHasBeenSet = true; m_channelName.assign(value); }
+
+    /**
+     * <p>The name of the signaling channel that you want to describe.</p>
+     */
+    inline DescribeSignalingChannelRequest& WithChannelName(const Aws::String& value) { SetChannelName(value); return *this;}
+
+    /**
+     * <p>The name of the signaling channel that you want to describe.</p>
+     */
+    inline DescribeSignalingChannelRequest& WithChannelName(Aws::String&& value) { SetChannelName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the signaling channel that you want to describe.</p>
+     */
+    inline DescribeSignalingChannelRequest& WithChannelName(const char* value) { SetChannelName(value); return *this;}
+
+
+    /**
+     * <p>The ARN of the signaling channel that you want to describe.</p>
+     */
+    inline const Aws::String& GetChannelARN() const{ return m_channelARN; }
+
+    /**
+     * <p>The ARN of the signaling channel that you want to describe.</p>
+     */
+    inline bool ChannelARNHasBeenSet() const { return m_channelARNHasBeenSet; }
+
+    /**
+     * <p>The ARN of the signaling channel that you want to describe.</p>
+     */
+    inline void SetChannelARN(const Aws::String& value) { m_channelARNHasBeenSet = true; m_channelARN = value; }
+
+    /**
+     * <p>The ARN of the signaling channel that you want to describe.</p>
+     */
+    inline void SetChannelARN(Aws::String&& value) { m_channelARNHasBeenSet = true; m_channelARN = std::move(value); }
+
+    /**
+     * <p>The ARN of the signaling channel that you want to describe.</p>
+     */
+    inline void SetChannelARN(const char* value) { m_channelARNHasBeenSet = true; m_channelARN.assign(value); }
+
+    /**
+     * <p>The ARN of the signaling channel that you want to describe.</p>
+     */
+    inline DescribeSignalingChannelRequest& WithChannelARN(const Aws::String& value) { SetChannelARN(value); return *this;}
+
+    /**
+     * <p>The ARN of the signaling channel that you want to describe.</p>
+     */
+    inline DescribeSignalingChannelRequest& WithChannelARN(Aws::String&& value) { SetChannelARN(std::move(value)); return *this;}
+
+    /**
+     * <p>The ARN of the signaling channel that you want to describe.</p>
+     */
+    inline DescribeSignalingChannelRequest& WithChannelARN(const char* value) { SetChannelARN(value); return *this;}
+
+  private:
+
+    Aws::String m_channelName;
+    bool m_channelNameHasBeenSet;
+
+    Aws::String m_channelARN;
+    bool m_channelARNHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/DescribeSignalingChannelResult.h

@@ -0,0 +1,72 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/model/ChannelInfo.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace KinesisVideo
+{
+namespace Model
+{
+  class AWS_KINESISVIDEO_API DescribeSignalingChannelResult
+  {
+  public:
+    DescribeSignalingChannelResult();
+    DescribeSignalingChannelResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeSignalingChannelResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>A structure that encapsulates the specified signaling channel's metadata and
+     * properties.</p>
+     */
+    inline const ChannelInfo& GetChannelInfo() const{ return m_channelInfo; }
+
+    /**
+     * <p>A structure that encapsulates the specified signaling channel's metadata and
+     * properties.</p>
+     */
+    inline void SetChannelInfo(const ChannelInfo& value) { m_channelInfo = value; }
+
+    /**
+     * <p>A structure that encapsulates the specified signaling channel's metadata and
+     * properties.</p>
+     */
+    inline void SetChannelInfo(ChannelInfo&& value) { m_channelInfo = std::move(value); }
+
+    /**
+     * <p>A structure that encapsulates the specified signaling channel's metadata and
+     * properties.</p>
+     */
+    inline DescribeSignalingChannelResult& WithChannelInfo(const ChannelInfo& value) { SetChannelInfo(value); return *this;}
+
+    /**
+     * <p>A structure that encapsulates the specified signaling channel's metadata and
+     * properties.</p>
+     */
+    inline DescribeSignalingChannelResult& WithChannelInfo(ChannelInfo&& value) { SetChannelInfo(std::move(value)); return *this;}
+
+  private:
+
+    ChannelInfo m_channelInfo;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/DescribeStreamRequest.h

@@ -0,0 +1,127 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/KinesisVideoRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_KINESISVIDEO_API DescribeStreamRequest : public KinesisVideoRequest
+  {
+  public:
+    DescribeStreamRequest();
+
+    // 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 "DescribeStream"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The name of the stream.</p>
+     */
+    inline const Aws::String& GetStreamName() const{ return m_streamName; }
+
+    /**
+     * <p>The name of the stream.</p>
+     */
+    inline bool StreamNameHasBeenSet() const { return m_streamNameHasBeenSet; }
+
+    /**
+     * <p>The name of the stream.</p>
+     */
+    inline void SetStreamName(const Aws::String& value) { m_streamNameHasBeenSet = true; m_streamName = value; }
+
+    /**
+     * <p>The name of the stream.</p>
+     */
+    inline void SetStreamName(Aws::String&& value) { m_streamNameHasBeenSet = true; m_streamName = std::move(value); }
+
+    /**
+     * <p>The name of the stream.</p>
+     */
+    inline void SetStreamName(const char* value) { m_streamNameHasBeenSet = true; m_streamName.assign(value); }
+
+    /**
+     * <p>The name of the stream.</p>
+     */
+    inline DescribeStreamRequest& WithStreamName(const Aws::String& value) { SetStreamName(value); return *this;}
+
+    /**
+     * <p>The name of the stream.</p>
+     */
+    inline DescribeStreamRequest& WithStreamName(Aws::String&& value) { SetStreamName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the stream.</p>
+     */
+    inline DescribeStreamRequest& WithStreamName(const char* value) { SetStreamName(value); return *this;}
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline const Aws::String& GetStreamARN() const{ return m_streamARN; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline bool StreamARNHasBeenSet() const { return m_streamARNHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline void SetStreamARN(const Aws::String& value) { m_streamARNHasBeenSet = true; m_streamARN = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline void SetStreamARN(Aws::String&& value) { m_streamARNHasBeenSet = true; m_streamARN = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline void SetStreamARN(const char* value) { m_streamARNHasBeenSet = true; m_streamARN.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline DescribeStreamRequest& WithStreamARN(const Aws::String& value) { SetStreamARN(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline DescribeStreamRequest& WithStreamARN(Aws::String&& value) { SetStreamARN(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline DescribeStreamRequest& WithStreamARN(const char* value) { SetStreamARN(value); return *this;}
+
+  private:
+
+    Aws::String m_streamName;
+    bool m_streamNameHasBeenSet;
+
+    Aws::String m_streamARN;
+    bool m_streamARNHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/DescribeStreamResult.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/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/model/StreamInfo.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace KinesisVideo
+{
+namespace Model
+{
+  class AWS_KINESISVIDEO_API DescribeStreamResult
+  {
+  public:
+    DescribeStreamResult();
+    DescribeStreamResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DescribeStreamResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>An object that describes the stream.</p>
+     */
+    inline const StreamInfo& GetStreamInfo() const{ return m_streamInfo; }
+
+    /**
+     * <p>An object that describes the stream.</p>
+     */
+    inline void SetStreamInfo(const StreamInfo& value) { m_streamInfo = value; }
+
+    /**
+     * <p>An object that describes the stream.</p>
+     */
+    inline void SetStreamInfo(StreamInfo&& value) { m_streamInfo = std::move(value); }
+
+    /**
+     * <p>An object that describes the stream.</p>
+     */
+    inline DescribeStreamResult& WithStreamInfo(const StreamInfo& value) { SetStreamInfo(value); return *this;}
+
+    /**
+     * <p>An object that describes the stream.</p>
+     */
+    inline DescribeStreamResult& WithStreamInfo(StreamInfo&& value) { SetStreamInfo(std::move(value)); return *this;}
+
+  private:
+
+    StreamInfo m_streamInfo;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/GetDataEndpointRequest.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/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/KinesisVideoRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/kinesisvideo/model/APIName.h>
+#include <utility>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_KINESISVIDEO_API GetDataEndpointRequest : public KinesisVideoRequest
+  {
+  public:
+    GetDataEndpointRequest();
+
+    // 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 "GetDataEndpoint"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The name of the stream that you want to get the endpoint for. You must
+     * specify either this parameter or a <code>StreamARN</code> in the request.</p>
+     */
+    inline const Aws::String& GetStreamName() const{ return m_streamName; }
+
+    /**
+     * <p>The name of the stream that you want to get the endpoint for. You must
+     * specify either this parameter or a <code>StreamARN</code> in the request.</p>
+     */
+    inline bool StreamNameHasBeenSet() const { return m_streamNameHasBeenSet; }
+
+    /**
+     * <p>The name of the stream that you want to get the endpoint for. You must
+     * specify either this parameter or a <code>StreamARN</code> in the request.</p>
+     */
+    inline void SetStreamName(const Aws::String& value) { m_streamNameHasBeenSet = true; m_streamName = value; }
+
+    /**
+     * <p>The name of the stream that you want to get the endpoint for. You must
+     * specify either this parameter or a <code>StreamARN</code> in the request.</p>
+     */
+    inline void SetStreamName(Aws::String&& value) { m_streamNameHasBeenSet = true; m_streamName = std::move(value); }
+
+    /**
+     * <p>The name of the stream that you want to get the endpoint for. You must
+     * specify either this parameter or a <code>StreamARN</code> in the request.</p>
+     */
+    inline void SetStreamName(const char* value) { m_streamNameHasBeenSet = true; m_streamName.assign(value); }
+
+    /**
+     * <p>The name of the stream that you want to get the endpoint for. You must
+     * specify either this parameter or a <code>StreamARN</code> in the request.</p>
+     */
+    inline GetDataEndpointRequest& WithStreamName(const Aws::String& value) { SetStreamName(value); return *this;}
+
+    /**
+     * <p>The name of the stream that you want to get the endpoint for. You must
+     * specify either this parameter or a <code>StreamARN</code> in the request.</p>
+     */
+    inline GetDataEndpointRequest& WithStreamName(Aws::String&& value) { SetStreamName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the stream that you want to get the endpoint for. You must
+     * specify either this parameter or a <code>StreamARN</code> in the request.</p>
+     */
+    inline GetDataEndpointRequest& WithStreamName(const char* value) { SetStreamName(value); return *this;}
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to get the
+     * endpoint for. You must specify either this parameter or a
+     * <code>StreamName</code> in the request. </p>
+     */
+    inline const Aws::String& GetStreamARN() const{ return m_streamARN; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to get the
+     * endpoint for. You must specify either this parameter or a
+     * <code>StreamName</code> in the request. </p>
+     */
+    inline bool StreamARNHasBeenSet() const { return m_streamARNHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to get the
+     * endpoint for. You must specify either this parameter or a
+     * <code>StreamName</code> in the request. </p>
+     */
+    inline void SetStreamARN(const Aws::String& value) { m_streamARNHasBeenSet = true; m_streamARN = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to get the
+     * endpoint for. You must specify either this parameter or a
+     * <code>StreamName</code> in the request. </p>
+     */
+    inline void SetStreamARN(Aws::String&& value) { m_streamARNHasBeenSet = true; m_streamARN = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to get the
+     * endpoint for. You must specify either this parameter or a
+     * <code>StreamName</code> in the request. </p>
+     */
+    inline void SetStreamARN(const char* value) { m_streamARNHasBeenSet = true; m_streamARN.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to get the
+     * endpoint for. You must specify either this parameter or a
+     * <code>StreamName</code> in the request. </p>
+     */
+    inline GetDataEndpointRequest& WithStreamARN(const Aws::String& value) { SetStreamARN(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to get the
+     * endpoint for. You must specify either this parameter or a
+     * <code>StreamName</code> in the request. </p>
+     */
+    inline GetDataEndpointRequest& WithStreamARN(Aws::String&& value) { SetStreamARN(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to get the
+     * endpoint for. You must specify either this parameter or a
+     * <code>StreamName</code> in the request. </p>
+     */
+    inline GetDataEndpointRequest& WithStreamARN(const char* value) { SetStreamARN(value); return *this;}
+
+
+    /**
+     * <p>The name of the API action for which to get an endpoint.</p>
+     */
+    inline const APIName& GetAPIName() const{ return m_aPIName; }
+
+    /**
+     * <p>The name of the API action for which to get an endpoint.</p>
+     */
+    inline bool APINameHasBeenSet() const { return m_aPINameHasBeenSet; }
+
+    /**
+     * <p>The name of the API action for which to get an endpoint.</p>
+     */
+    inline void SetAPIName(const APIName& value) { m_aPINameHasBeenSet = true; m_aPIName = value; }
+
+    /**
+     * <p>The name of the API action for which to get an endpoint.</p>
+     */
+    inline void SetAPIName(APIName&& value) { m_aPINameHasBeenSet = true; m_aPIName = std::move(value); }
+
+    /**
+     * <p>The name of the API action for which to get an endpoint.</p>
+     */
+    inline GetDataEndpointRequest& WithAPIName(const APIName& value) { SetAPIName(value); return *this;}
+
+    /**
+     * <p>The name of the API action for which to get an endpoint.</p>
+     */
+    inline GetDataEndpointRequest& WithAPIName(APIName&& value) { SetAPIName(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_streamName;
+    bool m_streamNameHasBeenSet;
+
+    Aws::String m_streamARN;
+    bool m_streamARNHasBeenSet;
+
+    APIName m_aPIName;
+    bool m_aPINameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/GetDataEndpointResult.h

@@ -0,0 +1,84 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_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 KinesisVideo
+{
+namespace Model
+{
+  class AWS_KINESISVIDEO_API GetDataEndpointResult
+  {
+  public:
+    GetDataEndpointResult();
+    GetDataEndpointResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    GetDataEndpointResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The endpoint value. To read data from the stream or to write data to it,
+     * specify this endpoint in your application.</p>
+     */
+    inline const Aws::String& GetDataEndpoint() const{ return m_dataEndpoint; }
+
+    /**
+     * <p>The endpoint value. To read data from the stream or to write data to it,
+     * specify this endpoint in your application.</p>
+     */
+    inline void SetDataEndpoint(const Aws::String& value) { m_dataEndpoint = value; }
+
+    /**
+     * <p>The endpoint value. To read data from the stream or to write data to it,
+     * specify this endpoint in your application.</p>
+     */
+    inline void SetDataEndpoint(Aws::String&& value) { m_dataEndpoint = std::move(value); }
+
+    /**
+     * <p>The endpoint value. To read data from the stream or to write data to it,
+     * specify this endpoint in your application.</p>
+     */
+    inline void SetDataEndpoint(const char* value) { m_dataEndpoint.assign(value); }
+
+    /**
+     * <p>The endpoint value. To read data from the stream or to write data to it,
+     * specify this endpoint in your application.</p>
+     */
+    inline GetDataEndpointResult& WithDataEndpoint(const Aws::String& value) { SetDataEndpoint(value); return *this;}
+
+    /**
+     * <p>The endpoint value. To read data from the stream or to write data to it,
+     * specify this endpoint in your application.</p>
+     */
+    inline GetDataEndpointResult& WithDataEndpoint(Aws::String&& value) { SetDataEndpoint(std::move(value)); return *this;}
+
+    /**
+     * <p>The endpoint value. To read data from the stream or to write data to it,
+     * specify this endpoint in your application.</p>
+     */
+    inline GetDataEndpointResult& WithDataEndpoint(const char* value) { SetDataEndpoint(value); return *this;}
+
+  private:
+
+    Aws::String m_dataEndpoint;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/GetSignalingChannelEndpointRequest.h

@@ -0,0 +1,132 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/KinesisVideoRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/kinesisvideo/model/SingleMasterChannelEndpointConfiguration.h>
+#include <utility>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_KINESISVIDEO_API GetSignalingChannelEndpointRequest : public KinesisVideoRequest
+  {
+  public:
+    GetSignalingChannelEndpointRequest();
+
+    // 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 "GetSignalingChannelEndpoint"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signalling channel for which you want
+     * to get an endpoint.</p>
+     */
+    inline const Aws::String& GetChannelARN() const{ return m_channelARN; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signalling channel for which you want
+     * to get an endpoint.</p>
+     */
+    inline bool ChannelARNHasBeenSet() const { return m_channelARNHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signalling channel for which you want
+     * to get an endpoint.</p>
+     */
+    inline void SetChannelARN(const Aws::String& value) { m_channelARNHasBeenSet = true; m_channelARN = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signalling channel for which you want
+     * to get an endpoint.</p>
+     */
+    inline void SetChannelARN(Aws::String&& value) { m_channelARNHasBeenSet = true; m_channelARN = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signalling channel for which you want
+     * to get an endpoint.</p>
+     */
+    inline void SetChannelARN(const char* value) { m_channelARNHasBeenSet = true; m_channelARN.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signalling channel for which you want
+     * to get an endpoint.</p>
+     */
+    inline GetSignalingChannelEndpointRequest& WithChannelARN(const Aws::String& value) { SetChannelARN(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signalling channel for which you want
+     * to get an endpoint.</p>
+     */
+    inline GetSignalingChannelEndpointRequest& WithChannelARN(Aws::String&& value) { SetChannelARN(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signalling channel for which you want
+     * to get an endpoint.</p>
+     */
+    inline GetSignalingChannelEndpointRequest& WithChannelARN(const char* value) { SetChannelARN(value); return *this;}
+
+
+    /**
+     * <p>A structure containing the endpoint configuration for the
+     * <code>SINGLE_MASTER</code> channel type.</p>
+     */
+    inline const SingleMasterChannelEndpointConfiguration& GetSingleMasterChannelEndpointConfiguration() const{ return m_singleMasterChannelEndpointConfiguration; }
+
+    /**
+     * <p>A structure containing the endpoint configuration for the
+     * <code>SINGLE_MASTER</code> channel type.</p>
+     */
+    inline bool SingleMasterChannelEndpointConfigurationHasBeenSet() const { return m_singleMasterChannelEndpointConfigurationHasBeenSet; }
+
+    /**
+     * <p>A structure containing the endpoint configuration for the
+     * <code>SINGLE_MASTER</code> channel type.</p>
+     */
+    inline void SetSingleMasterChannelEndpointConfiguration(const SingleMasterChannelEndpointConfiguration& value) { m_singleMasterChannelEndpointConfigurationHasBeenSet = true; m_singleMasterChannelEndpointConfiguration = value; }
+
+    /**
+     * <p>A structure containing the endpoint configuration for the
+     * <code>SINGLE_MASTER</code> channel type.</p>
+     */
+    inline void SetSingleMasterChannelEndpointConfiguration(SingleMasterChannelEndpointConfiguration&& value) { m_singleMasterChannelEndpointConfigurationHasBeenSet = true; m_singleMasterChannelEndpointConfiguration = std::move(value); }
+
+    /**
+     * <p>A structure containing the endpoint configuration for the
+     * <code>SINGLE_MASTER</code> channel type.</p>
+     */
+    inline GetSignalingChannelEndpointRequest& WithSingleMasterChannelEndpointConfiguration(const SingleMasterChannelEndpointConfiguration& value) { SetSingleMasterChannelEndpointConfiguration(value); return *this;}
+
+    /**
+     * <p>A structure containing the endpoint configuration for the
+     * <code>SINGLE_MASTER</code> channel type.</p>
+     */
+    inline GetSignalingChannelEndpointRequest& WithSingleMasterChannelEndpointConfiguration(SingleMasterChannelEndpointConfiguration&& value) { SetSingleMasterChannelEndpointConfiguration(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_channelARN;
+    bool m_channelARNHasBeenSet;
+
+    SingleMasterChannelEndpointConfiguration m_singleMasterChannelEndpointConfiguration;
+    bool m_singleMasterChannelEndpointConfigurationHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/GetSignalingChannelEndpointResult.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/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/kinesisvideo/model/ResourceEndpointListItem.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace KinesisVideo
+{
+namespace Model
+{
+  class AWS_KINESISVIDEO_API GetSignalingChannelEndpointResult
+  {
+  public:
+    GetSignalingChannelEndpointResult();
+    GetSignalingChannelEndpointResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    GetSignalingChannelEndpointResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>A list of endpoints for the specified signaling channel.</p>
+     */
+    inline const Aws::Vector<ResourceEndpointListItem>& GetResourceEndpointList() const{ return m_resourceEndpointList; }
+
+    /**
+     * <p>A list of endpoints for the specified signaling channel.</p>
+     */
+    inline void SetResourceEndpointList(const Aws::Vector<ResourceEndpointListItem>& value) { m_resourceEndpointList = value; }
+
+    /**
+     * <p>A list of endpoints for the specified signaling channel.</p>
+     */
+    inline void SetResourceEndpointList(Aws::Vector<ResourceEndpointListItem>&& value) { m_resourceEndpointList = std::move(value); }
+
+    /**
+     * <p>A list of endpoints for the specified signaling channel.</p>
+     */
+    inline GetSignalingChannelEndpointResult& WithResourceEndpointList(const Aws::Vector<ResourceEndpointListItem>& value) { SetResourceEndpointList(value); return *this;}
+
+    /**
+     * <p>A list of endpoints for the specified signaling channel.</p>
+     */
+    inline GetSignalingChannelEndpointResult& WithResourceEndpointList(Aws::Vector<ResourceEndpointListItem>&& value) { SetResourceEndpointList(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of endpoints for the specified signaling channel.</p>
+     */
+    inline GetSignalingChannelEndpointResult& AddResourceEndpointList(const ResourceEndpointListItem& value) { m_resourceEndpointList.push_back(value); return *this; }
+
+    /**
+     * <p>A list of endpoints for the specified signaling channel.</p>
+     */
+    inline GetSignalingChannelEndpointResult& AddResourceEndpointList(ResourceEndpointListItem&& value) { m_resourceEndpointList.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::Vector<ResourceEndpointListItem> m_resourceEndpointList;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/ListSignalingChannelsRequest.h

@@ -0,0 +1,170 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/KinesisVideoRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/kinesisvideo/model/ChannelNameCondition.h>
+#include <utility>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_KINESISVIDEO_API ListSignalingChannelsRequest : public KinesisVideoRequest
+  {
+  public:
+    ListSignalingChannelsRequest();
+
+    // 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 "ListSignalingChannels"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The maximum number of channels to return in the response. The default is
+     * 500.</p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>The maximum number of channels to return in the response. The default is
+     * 500.</p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>The maximum number of channels to return in the response. The default is
+     * 500.</p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>The maximum number of channels to return in the response. The default is
+     * 500.</p>
+     */
+    inline ListSignalingChannelsRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+
+    /**
+     * <p>If you specify this parameter, when the result of a
+     * <code>ListSignalingChannels</code> operation is truncated, the call returns the
+     * <code>NextToken</code> in the response. To get another batch of channels,
+     * provide this token in your next request.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>If you specify this parameter, when the result of a
+     * <code>ListSignalingChannels</code> operation is truncated, the call returns the
+     * <code>NextToken</code> in the response. To get another batch of channels,
+     * provide this token in your next request.</p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>If you specify this parameter, when the result of a
+     * <code>ListSignalingChannels</code> operation is truncated, the call returns the
+     * <code>NextToken</code> in the response. To get another batch of channels,
+     * provide this token in your next request.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>If you specify this parameter, when the result of a
+     * <code>ListSignalingChannels</code> operation is truncated, the call returns the
+     * <code>NextToken</code> in the response. To get another batch of channels,
+     * provide this token in your next request.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>If you specify this parameter, when the result of a
+     * <code>ListSignalingChannels</code> operation is truncated, the call returns the
+     * <code>NextToken</code> in the response. To get another batch of channels,
+     * provide this token in your next request.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>If you specify this parameter, when the result of a
+     * <code>ListSignalingChannels</code> operation is truncated, the call returns the
+     * <code>NextToken</code> in the response. To get another batch of channels,
+     * provide this token in your next request.</p>
+     */
+    inline ListSignalingChannelsRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>If you specify this parameter, when the result of a
+     * <code>ListSignalingChannels</code> operation is truncated, the call returns the
+     * <code>NextToken</code> in the response. To get another batch of channels,
+     * provide this token in your next request.</p>
+     */
+    inline ListSignalingChannelsRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If you specify this parameter, when the result of a
+     * <code>ListSignalingChannels</code> operation is truncated, the call returns the
+     * <code>NextToken</code> in the response. To get another batch of channels,
+     * provide this token in your next request.</p>
+     */
+    inline ListSignalingChannelsRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>Optional: Returns only the channels that satisfy a specific condition.</p>
+     */
+    inline const ChannelNameCondition& GetChannelNameCondition() const{ return m_channelNameCondition; }
+
+    /**
+     * <p>Optional: Returns only the channels that satisfy a specific condition.</p>
+     */
+    inline bool ChannelNameConditionHasBeenSet() const { return m_channelNameConditionHasBeenSet; }
+
+    /**
+     * <p>Optional: Returns only the channels that satisfy a specific condition.</p>
+     */
+    inline void SetChannelNameCondition(const ChannelNameCondition& value) { m_channelNameConditionHasBeenSet = true; m_channelNameCondition = value; }
+
+    /**
+     * <p>Optional: Returns only the channels that satisfy a specific condition.</p>
+     */
+    inline void SetChannelNameCondition(ChannelNameCondition&& value) { m_channelNameConditionHasBeenSet = true; m_channelNameCondition = std::move(value); }
+
+    /**
+     * <p>Optional: Returns only the channels that satisfy a specific condition.</p>
+     */
+    inline ListSignalingChannelsRequest& WithChannelNameCondition(const ChannelNameCondition& value) { SetChannelNameCondition(value); return *this;}
+
+    /**
+     * <p>Optional: Returns only the channels that satisfy a specific condition.</p>
+     */
+    inline ListSignalingChannelsRequest& WithChannelNameCondition(ChannelNameCondition&& value) { SetChannelNameCondition(std::move(value)); return *this;}
+
+  private:
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+
+    ChannelNameCondition m_channelNameCondition;
+    bool m_channelNameConditionHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/ListSignalingChannelsResult.h

@@ -0,0 +1,124 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/kinesisvideo/model/ChannelInfo.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace KinesisVideo
+{
+namespace Model
+{
+  class AWS_KINESISVIDEO_API ListSignalingChannelsResult
+  {
+  public:
+    ListSignalingChannelsResult();
+    ListSignalingChannelsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListSignalingChannelsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>An array of <code>ChannelInfo</code> objects.</p>
+     */
+    inline const Aws::Vector<ChannelInfo>& GetChannelInfoList() const{ return m_channelInfoList; }
+
+    /**
+     * <p>An array of <code>ChannelInfo</code> objects.</p>
+     */
+    inline void SetChannelInfoList(const Aws::Vector<ChannelInfo>& value) { m_channelInfoList = value; }
+
+    /**
+     * <p>An array of <code>ChannelInfo</code> objects.</p>
+     */
+    inline void SetChannelInfoList(Aws::Vector<ChannelInfo>&& value) { m_channelInfoList = std::move(value); }
+
+    /**
+     * <p>An array of <code>ChannelInfo</code> objects.</p>
+     */
+    inline ListSignalingChannelsResult& WithChannelInfoList(const Aws::Vector<ChannelInfo>& value) { SetChannelInfoList(value); return *this;}
+
+    /**
+     * <p>An array of <code>ChannelInfo</code> objects.</p>
+     */
+    inline ListSignalingChannelsResult& WithChannelInfoList(Aws::Vector<ChannelInfo>&& value) { SetChannelInfoList(std::move(value)); return *this;}
+
+    /**
+     * <p>An array of <code>ChannelInfo</code> objects.</p>
+     */
+    inline ListSignalingChannelsResult& AddChannelInfoList(const ChannelInfo& value) { m_channelInfoList.push_back(value); return *this; }
+
+    /**
+     * <p>An array of <code>ChannelInfo</code> objects.</p>
+     */
+    inline ListSignalingChannelsResult& AddChannelInfoList(ChannelInfo&& value) { m_channelInfoList.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>If the response is truncated, the call returns this element with a token. To
+     * get the next batch of streams, use this token in your next request.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>If the response is truncated, the call returns this element with a token. To
+     * get the next batch of streams, use this token in your next request.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>If the response is truncated, the call returns this element with a token. To
+     * get the next batch of streams, use this token in your next request.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>If the response is truncated, the call returns this element with a token. To
+     * get the next batch of streams, use this token in your next request.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>If the response is truncated, the call returns this element with a token. To
+     * get the next batch of streams, use this token in your next request.</p>
+     */
+    inline ListSignalingChannelsResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>If the response is truncated, the call returns this element with a token. To
+     * get the next batch of streams, use this token in your next request.</p>
+     */
+    inline ListSignalingChannelsResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If the response is truncated, the call returns this element with a token. To
+     * get the next batch of streams, use this token in your next request.</p>
+     */
+    inline ListSignalingChannelsResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    Aws::Vector<ChannelInfo> m_channelInfoList;
+
+    Aws::String m_nextToken;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/ListStreamsRequest.h

@@ -0,0 +1,176 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/KinesisVideoRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/kinesisvideo/model/StreamNameCondition.h>
+#include <utility>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_KINESISVIDEO_API ListStreamsRequest : public KinesisVideoRequest
+  {
+  public:
+    ListStreamsRequest();
+
+    // 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 "ListStreams"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The maximum number of streams to return in the response. The default is
+     * 10,000.</p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>The maximum number of streams to return in the response. The default is
+     * 10,000.</p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>The maximum number of streams to return in the response. The default is
+     * 10,000.</p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>The maximum number of streams to return in the response. The default is
+     * 10,000.</p>
+     */
+    inline ListStreamsRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+
+    /**
+     * <p>If you specify this parameter, when the result of a <code>ListStreams</code>
+     * operation is truncated, the call returns the <code>NextToken</code> in the
+     * response. To get another batch of streams, provide this token in your next
+     * request.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>If you specify this parameter, when the result of a <code>ListStreams</code>
+     * operation is truncated, the call returns the <code>NextToken</code> in the
+     * response. To get another batch of streams, provide this token in your next
+     * request.</p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>If you specify this parameter, when the result of a <code>ListStreams</code>
+     * operation is truncated, the call returns the <code>NextToken</code> in the
+     * response. To get another batch of streams, provide this token in your next
+     * request.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>If you specify this parameter, when the result of a <code>ListStreams</code>
+     * operation is truncated, the call returns the <code>NextToken</code> in the
+     * response. To get another batch of streams, provide this token in your next
+     * request.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>If you specify this parameter, when the result of a <code>ListStreams</code>
+     * operation is truncated, the call returns the <code>NextToken</code> in the
+     * response. To get another batch of streams, provide this token in your next
+     * request.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>If you specify this parameter, when the result of a <code>ListStreams</code>
+     * operation is truncated, the call returns the <code>NextToken</code> in the
+     * response. To get another batch of streams, provide this token in your next
+     * request.</p>
+     */
+    inline ListStreamsRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>If you specify this parameter, when the result of a <code>ListStreams</code>
+     * operation is truncated, the call returns the <code>NextToken</code> in the
+     * response. To get another batch of streams, provide this token in your next
+     * request.</p>
+     */
+    inline ListStreamsRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If you specify this parameter, when the result of a <code>ListStreams</code>
+     * operation is truncated, the call returns the <code>NextToken</code> in the
+     * response. To get another batch of streams, provide this token in your next
+     * request.</p>
+     */
+    inline ListStreamsRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>Optional: Returns only streams that satisfy a specific condition. Currently,
+     * you can specify only the prefix of a stream name as a condition. </p>
+     */
+    inline const StreamNameCondition& GetStreamNameCondition() const{ return m_streamNameCondition; }
+
+    /**
+     * <p>Optional: Returns only streams that satisfy a specific condition. Currently,
+     * you can specify only the prefix of a stream name as a condition. </p>
+     */
+    inline bool StreamNameConditionHasBeenSet() const { return m_streamNameConditionHasBeenSet; }
+
+    /**
+     * <p>Optional: Returns only streams that satisfy a specific condition. Currently,
+     * you can specify only the prefix of a stream name as a condition. </p>
+     */
+    inline void SetStreamNameCondition(const StreamNameCondition& value) { m_streamNameConditionHasBeenSet = true; m_streamNameCondition = value; }
+
+    /**
+     * <p>Optional: Returns only streams that satisfy a specific condition. Currently,
+     * you can specify only the prefix of a stream name as a condition. </p>
+     */
+    inline void SetStreamNameCondition(StreamNameCondition&& value) { m_streamNameConditionHasBeenSet = true; m_streamNameCondition = std::move(value); }
+
+    /**
+     * <p>Optional: Returns only streams that satisfy a specific condition. Currently,
+     * you can specify only the prefix of a stream name as a condition. </p>
+     */
+    inline ListStreamsRequest& WithStreamNameCondition(const StreamNameCondition& value) { SetStreamNameCondition(value); return *this;}
+
+    /**
+     * <p>Optional: Returns only streams that satisfy a specific condition. Currently,
+     * you can specify only the prefix of a stream name as a condition. </p>
+     */
+    inline ListStreamsRequest& WithStreamNameCondition(StreamNameCondition&& value) { SetStreamNameCondition(std::move(value)); return *this;}
+
+  private:
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+
+    StreamNameCondition m_streamNameCondition;
+    bool m_streamNameConditionHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/ListStreamsResult.h

@@ -0,0 +1,124 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/kinesisvideo/model/StreamInfo.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace KinesisVideo
+{
+namespace Model
+{
+  class AWS_KINESISVIDEO_API ListStreamsResult
+  {
+  public:
+    ListStreamsResult();
+    ListStreamsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListStreamsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>An array of <code>StreamInfo</code> objects.</p>
+     */
+    inline const Aws::Vector<StreamInfo>& GetStreamInfoList() const{ return m_streamInfoList; }
+
+    /**
+     * <p>An array of <code>StreamInfo</code> objects.</p>
+     */
+    inline void SetStreamInfoList(const Aws::Vector<StreamInfo>& value) { m_streamInfoList = value; }
+
+    /**
+     * <p>An array of <code>StreamInfo</code> objects.</p>
+     */
+    inline void SetStreamInfoList(Aws::Vector<StreamInfo>&& value) { m_streamInfoList = std::move(value); }
+
+    /**
+     * <p>An array of <code>StreamInfo</code> objects.</p>
+     */
+    inline ListStreamsResult& WithStreamInfoList(const Aws::Vector<StreamInfo>& value) { SetStreamInfoList(value); return *this;}
+
+    /**
+     * <p>An array of <code>StreamInfo</code> objects.</p>
+     */
+    inline ListStreamsResult& WithStreamInfoList(Aws::Vector<StreamInfo>&& value) { SetStreamInfoList(std::move(value)); return *this;}
+
+    /**
+     * <p>An array of <code>StreamInfo</code> objects.</p>
+     */
+    inline ListStreamsResult& AddStreamInfoList(const StreamInfo& value) { m_streamInfoList.push_back(value); return *this; }
+
+    /**
+     * <p>An array of <code>StreamInfo</code> objects.</p>
+     */
+    inline ListStreamsResult& AddStreamInfoList(StreamInfo&& value) { m_streamInfoList.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>If the response is truncated, the call returns this element with a token. To
+     * get the next batch of streams, use this token in your next request. </p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>If the response is truncated, the call returns this element with a token. To
+     * get the next batch of streams, use this token in your next request. </p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>If the response is truncated, the call returns this element with a token. To
+     * get the next batch of streams, use this token in your next request. </p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>If the response is truncated, the call returns this element with a token. To
+     * get the next batch of streams, use this token in your next request. </p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>If the response is truncated, the call returns this element with a token. To
+     * get the next batch of streams, use this token in your next request. </p>
+     */
+    inline ListStreamsResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>If the response is truncated, the call returns this element with a token. To
+     * get the next batch of streams, use this token in your next request. </p>
+     */
+    inline ListStreamsResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If the response is truncated, the call returns this element with a token. To
+     * get the next batch of streams, use this token in your next request. </p>
+     */
+    inline ListStreamsResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    Aws::Vector<StreamInfo> m_streamInfoList;
+
+    Aws::String m_nextToken;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

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

@@ -0,0 +1,151 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/KinesisVideoRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_KINESISVIDEO_API ListTagsForResourceRequest : public KinesisVideoRequest
+  {
+  public:
+    ListTagsForResourceRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "ListTagsForResource"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForResource</code> call is truncated, the response includes a
+     * token that you can use in the next request to fetch the next batch of tags. </p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForResource</code> call is truncated, the response includes a
+     * token that you can use in the next request to fetch the next batch of tags. </p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForResource</code> call is truncated, the response includes a
+     * token that you can use in the next request to fetch the next batch of tags. </p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForResource</code> call is truncated, the response includes a
+     * token that you can use in the next request to fetch the next batch of tags. </p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForResource</code> call is truncated, the response includes a
+     * token that you can use in the next request to fetch the next batch of tags. </p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForResource</code> call is truncated, the response includes a
+     * token that you can use in the next request to fetch the next batch of tags. </p>
+     */
+    inline ListTagsForResourceRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForResource</code> call is truncated, the response includes a
+     * token that you can use in the next request to fetch the next batch of tags. </p>
+     */
+    inline ListTagsForResourceRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForResource</code> call is truncated, the response includes a
+     * token that you can use in the next request to fetch the next batch of tags. </p>
+     */
+    inline ListTagsForResourceRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel for which you want to
+     * list tags.</p>
+     */
+    inline const Aws::String& GetResourceARN() const{ return m_resourceARN; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel for which you want to
+     * list tags.</p>
+     */
+    inline bool ResourceARNHasBeenSet() const { return m_resourceARNHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel for which you want to
+     * list tags.</p>
+     */
+    inline void SetResourceARN(const Aws::String& value) { m_resourceARNHasBeenSet = true; m_resourceARN = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel for which you want to
+     * list tags.</p>
+     */
+    inline void SetResourceARN(Aws::String&& value) { m_resourceARNHasBeenSet = true; m_resourceARN = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel for which you want to
+     * list tags.</p>
+     */
+    inline void SetResourceARN(const char* value) { m_resourceARNHasBeenSet = true; m_resourceARN.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel for which you want to
+     * list tags.</p>
+     */
+    inline ListTagsForResourceRequest& WithResourceARN(const Aws::String& value) { SetResourceARN(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel for which you want to
+     * list tags.</p>
+     */
+    inline ListTagsForResourceRequest& WithResourceARN(Aws::String&& value) { SetResourceARN(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel for which you want to
+     * list tags.</p>
+     */
+    inline ListTagsForResourceRequest& WithResourceARN(const char* value) { SetResourceARN(value); return *this;}
+
+  private:
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+
+    Aws::String m_resourceARN;
+    bool m_resourceARNHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

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

@@ -0,0 +1,167 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace KinesisVideo
+{
+namespace Model
+{
+  class AWS_KINESISVIDEO_API ListTagsForResourceResult
+  {
+  public:
+    ListTagsForResourceResult();
+    ListTagsForResourceResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListTagsForResourceResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForResource</code> call is truncated, the response includes a
+     * token that you can use in the next request to fetch the next set of tags. </p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForResource</code> call is truncated, the response includes a
+     * token that you can use in the next request to fetch the next set of tags. </p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForResource</code> call is truncated, the response includes a
+     * token that you can use in the next request to fetch the next set of tags. </p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForResource</code> call is truncated, the response includes a
+     * token that you can use in the next request to fetch the next set of tags. </p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForResource</code> call is truncated, the response includes a
+     * token that you can use in the next request to fetch the next set of tags. </p>
+     */
+    inline ListTagsForResourceResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForResource</code> call is truncated, the response includes a
+     * token that you can use in the next request to fetch the next set of tags. </p>
+     */
+    inline ListTagsForResourceResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForResource</code> call is truncated, the response includes a
+     * token that you can use in the next request to fetch the next set of tags. </p>
+     */
+    inline ListTagsForResourceResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>A map of tag keys and values associated with the specified signaling
+     * channel.</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>A map of tag keys and values associated with the specified signaling
+     * channel.</p>
+     */
+    inline void SetTags(const Aws::Map<Aws::String, Aws::String>& value) { m_tags = value; }
+
+    /**
+     * <p>A map of tag keys and values associated with the specified signaling
+     * channel.</p>
+     */
+    inline void SetTags(Aws::Map<Aws::String, Aws::String>&& value) { m_tags = std::move(value); }
+
+    /**
+     * <p>A map of tag keys and values associated with the specified signaling
+     * channel.</p>
+     */
+    inline ListTagsForResourceResult& WithTags(const Aws::Map<Aws::String, Aws::String>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>A map of tag keys and values associated with the specified signaling
+     * channel.</p>
+     */
+    inline ListTagsForResourceResult& WithTags(Aws::Map<Aws::String, Aws::String>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>A map of tag keys and values associated with the specified signaling
+     * channel.</p>
+     */
+    inline ListTagsForResourceResult& AddTags(const Aws::String& key, const Aws::String& value) { m_tags.emplace(key, value); return *this; }
+
+    /**
+     * <p>A map of tag keys and values associated with the specified signaling
+     * channel.</p>
+     */
+    inline ListTagsForResourceResult& AddTags(Aws::String&& key, const Aws::String& value) { m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>A map of tag keys and values associated with the specified signaling
+     * channel.</p>
+     */
+    inline ListTagsForResourceResult& AddTags(const Aws::String& key, Aws::String&& value) { m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of tag keys and values associated with the specified signaling
+     * channel.</p>
+     */
+    inline ListTagsForResourceResult& AddTags(Aws::String&& key, Aws::String&& value) { m_tags.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>A map of tag keys and values associated with the specified signaling
+     * channel.</p>
+     */
+    inline ListTagsForResourceResult& AddTags(const char* key, Aws::String&& value) { m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of tag keys and values associated with the specified signaling
+     * channel.</p>
+     */
+    inline ListTagsForResourceResult& AddTags(Aws::String&& key, const char* value) { m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>A map of tag keys and values associated with the specified signaling
+     * channel.</p>
+     */
+    inline ListTagsForResourceResult& AddTags(const char* key, const char* value) { m_tags.emplace(key, value); return *this; }
+
+  private:
+
+    Aws::String m_nextToken;
+
+    Aws::Map<Aws::String, Aws::String> m_tags;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/ListTagsForStreamRequest.h

@@ -0,0 +1,195 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/KinesisVideoRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_KINESISVIDEO_API ListTagsForStreamRequest : public KinesisVideoRequest
+  {
+  public:
+    ListTagsForStreamRequest();
+
+    // 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 "ListTagsForStream"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForStream</code> call is truncated, the response includes a token
+     * that you can use in the next request to fetch the next batch of tags.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForStream</code> call is truncated, the response includes a token
+     * that you can use in the next request to fetch the next batch of tags.</p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForStream</code> call is truncated, the response includes a token
+     * that you can use in the next request to fetch the next batch of tags.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForStream</code> call is truncated, the response includes a token
+     * that you can use in the next request to fetch the next batch of tags.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForStream</code> call is truncated, the response includes a token
+     * that you can use in the next request to fetch the next batch of tags.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForStream</code> call is truncated, the response includes a token
+     * that you can use in the next request to fetch the next batch of tags.</p>
+     */
+    inline ListTagsForStreamRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForStream</code> call is truncated, the response includes a token
+     * that you can use in the next request to fetch the next batch of tags.</p>
+     */
+    inline ListTagsForStreamRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If you specify this parameter and the result of a
+     * <code>ListTagsForStream</code> call is truncated, the response includes a token
+     * that you can use in the next request to fetch the next batch of tags.</p>
+     */
+    inline ListTagsForStreamRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to list tags
+     * for.</p>
+     */
+    inline const Aws::String& GetStreamARN() const{ return m_streamARN; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to list tags
+     * for.</p>
+     */
+    inline bool StreamARNHasBeenSet() const { return m_streamARNHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to list tags
+     * for.</p>
+     */
+    inline void SetStreamARN(const Aws::String& value) { m_streamARNHasBeenSet = true; m_streamARN = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to list tags
+     * for.</p>
+     */
+    inline void SetStreamARN(Aws::String&& value) { m_streamARNHasBeenSet = true; m_streamARN = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to list tags
+     * for.</p>
+     */
+    inline void SetStreamARN(const char* value) { m_streamARNHasBeenSet = true; m_streamARN.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to list tags
+     * for.</p>
+     */
+    inline ListTagsForStreamRequest& WithStreamARN(const Aws::String& value) { SetStreamARN(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to list tags
+     * for.</p>
+     */
+    inline ListTagsForStreamRequest& WithStreamARN(Aws::String&& value) { SetStreamARN(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to list tags
+     * for.</p>
+     */
+    inline ListTagsForStreamRequest& WithStreamARN(const char* value) { SetStreamARN(value); return *this;}
+
+
+    /**
+     * <p>The name of the stream that you want to list tags for.</p>
+     */
+    inline const Aws::String& GetStreamName() const{ return m_streamName; }
+
+    /**
+     * <p>The name of the stream that you want to list tags for.</p>
+     */
+    inline bool StreamNameHasBeenSet() const { return m_streamNameHasBeenSet; }
+
+    /**
+     * <p>The name of the stream that you want to list tags for.</p>
+     */
+    inline void SetStreamName(const Aws::String& value) { m_streamNameHasBeenSet = true; m_streamName = value; }
+
+    /**
+     * <p>The name of the stream that you want to list tags for.</p>
+     */
+    inline void SetStreamName(Aws::String&& value) { m_streamNameHasBeenSet = true; m_streamName = std::move(value); }
+
+    /**
+     * <p>The name of the stream that you want to list tags for.</p>
+     */
+    inline void SetStreamName(const char* value) { m_streamNameHasBeenSet = true; m_streamName.assign(value); }
+
+    /**
+     * <p>The name of the stream that you want to list tags for.</p>
+     */
+    inline ListTagsForStreamRequest& WithStreamName(const Aws::String& value) { SetStreamName(value); return *this;}
+
+    /**
+     * <p>The name of the stream that you want to list tags for.</p>
+     */
+    inline ListTagsForStreamRequest& WithStreamName(Aws::String&& value) { SetStreamName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the stream that you want to list tags for.</p>
+     */
+    inline ListTagsForStreamRequest& WithStreamName(const char* value) { SetStreamName(value); return *this;}
+
+  private:
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+
+    Aws::String m_streamARN;
+    bool m_streamARNHasBeenSet;
+
+    Aws::String m_streamName;
+    bool m_streamNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/ListTagsForStreamResult.h

@@ -0,0 +1,155 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace KinesisVideo
+{
+namespace Model
+{
+  class AWS_KINESISVIDEO_API ListTagsForStreamResult
+  {
+  public:
+    ListTagsForStreamResult();
+    ListTagsForStreamResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListTagsForStreamResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>If you specify this parameter and the result of a <code>ListTags</code> call
+     * is truncated, the response includes a token that you can use in the next request
+     * to fetch the next set of tags.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>If you specify this parameter and the result of a <code>ListTags</code> call
+     * is truncated, the response includes a token that you can use in the next request
+     * to fetch the next set of tags.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>If you specify this parameter and the result of a <code>ListTags</code> call
+     * is truncated, the response includes a token that you can use in the next request
+     * to fetch the next set of tags.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>If you specify this parameter and the result of a <code>ListTags</code> call
+     * is truncated, the response includes a token that you can use in the next request
+     * to fetch the next set of tags.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>If you specify this parameter and the result of a <code>ListTags</code> call
+     * is truncated, the response includes a token that you can use in the next request
+     * to fetch the next set of tags.</p>
+     */
+    inline ListTagsForStreamResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>If you specify this parameter and the result of a <code>ListTags</code> call
+     * is truncated, the response includes a token that you can use in the next request
+     * to fetch the next set of tags.</p>
+     */
+    inline ListTagsForStreamResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If you specify this parameter and the result of a <code>ListTags</code> call
+     * is truncated, the response includes a token that you can use in the next request
+     * to fetch the next set of tags.</p>
+     */
+    inline ListTagsForStreamResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>A map of tag keys and values associated with the specified stream.</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>A map of tag keys and values associated with the specified stream.</p>
+     */
+    inline void SetTags(const Aws::Map<Aws::String, Aws::String>& value) { m_tags = value; }
+
+    /**
+     * <p>A map of tag keys and values associated with the specified stream.</p>
+     */
+    inline void SetTags(Aws::Map<Aws::String, Aws::String>&& value) { m_tags = std::move(value); }
+
+    /**
+     * <p>A map of tag keys and values associated with the specified stream.</p>
+     */
+    inline ListTagsForStreamResult& WithTags(const Aws::Map<Aws::String, Aws::String>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>A map of tag keys and values associated with the specified stream.</p>
+     */
+    inline ListTagsForStreamResult& WithTags(Aws::Map<Aws::String, Aws::String>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>A map of tag keys and values associated with the specified stream.</p>
+     */
+    inline ListTagsForStreamResult& AddTags(const Aws::String& key, const Aws::String& value) { m_tags.emplace(key, value); return *this; }
+
+    /**
+     * <p>A map of tag keys and values associated with the specified stream.</p>
+     */
+    inline ListTagsForStreamResult& AddTags(Aws::String&& key, const Aws::String& value) { m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>A map of tag keys and values associated with the specified stream.</p>
+     */
+    inline ListTagsForStreamResult& AddTags(const Aws::String& key, Aws::String&& value) { m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of tag keys and values associated with the specified stream.</p>
+     */
+    inline ListTagsForStreamResult& AddTags(Aws::String&& key, Aws::String&& value) { m_tags.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>A map of tag keys and values associated with the specified stream.</p>
+     */
+    inline ListTagsForStreamResult& AddTags(const char* key, Aws::String&& value) { m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A map of tag keys and values associated with the specified stream.</p>
+     */
+    inline ListTagsForStreamResult& AddTags(Aws::String&& key, const char* value) { m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>A map of tag keys and values associated with the specified stream.</p>
+     */
+    inline ListTagsForStreamResult& AddTags(const char* key, const char* value) { m_tags.emplace(key, value); return *this; }
+
+  private:
+
+    Aws::String m_nextToken;
+
+    Aws::Map<Aws::String, Aws::String> m_tags;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/ResourceEndpointListItem.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/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/model/ChannelProtocol.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 KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   * <p>An object that describes the endpoint of the signaling channel returned by
+   * the <code>GetSignalingChannelEndpoint</code> API.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/ResourceEndpointListItem">AWS
+   * API Reference</a></p>
+   */
+  class AWS_KINESISVIDEO_API ResourceEndpointListItem
+  {
+  public:
+    ResourceEndpointListItem();
+    ResourceEndpointListItem(Aws::Utils::Json::JsonView jsonValue);
+    ResourceEndpointListItem& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The protocol of the signaling channel returned by the
+     * <code>GetSignalingChannelEndpoint</code> API.</p>
+     */
+    inline const ChannelProtocol& GetProtocol() const{ return m_protocol; }
+
+    /**
+     * <p>The protocol of the signaling channel returned by the
+     * <code>GetSignalingChannelEndpoint</code> API.</p>
+     */
+    inline bool ProtocolHasBeenSet() const { return m_protocolHasBeenSet; }
+
+    /**
+     * <p>The protocol of the signaling channel returned by the
+     * <code>GetSignalingChannelEndpoint</code> API.</p>
+     */
+    inline void SetProtocol(const ChannelProtocol& value) { m_protocolHasBeenSet = true; m_protocol = value; }
+
+    /**
+     * <p>The protocol of the signaling channel returned by the
+     * <code>GetSignalingChannelEndpoint</code> API.</p>
+     */
+    inline void SetProtocol(ChannelProtocol&& value) { m_protocolHasBeenSet = true; m_protocol = std::move(value); }
+
+    /**
+     * <p>The protocol of the signaling channel returned by the
+     * <code>GetSignalingChannelEndpoint</code> API.</p>
+     */
+    inline ResourceEndpointListItem& WithProtocol(const ChannelProtocol& value) { SetProtocol(value); return *this;}
+
+    /**
+     * <p>The protocol of the signaling channel returned by the
+     * <code>GetSignalingChannelEndpoint</code> API.</p>
+     */
+    inline ResourceEndpointListItem& WithProtocol(ChannelProtocol&& value) { SetProtocol(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The endpoint of the signaling channel returned by the
+     * <code>GetSignalingChannelEndpoint</code> API.</p>
+     */
+    inline const Aws::String& GetResourceEndpoint() const{ return m_resourceEndpoint; }
+
+    /**
+     * <p>The endpoint of the signaling channel returned by the
+     * <code>GetSignalingChannelEndpoint</code> API.</p>
+     */
+    inline bool ResourceEndpointHasBeenSet() const { return m_resourceEndpointHasBeenSet; }
+
+    /**
+     * <p>The endpoint of the signaling channel returned by the
+     * <code>GetSignalingChannelEndpoint</code> API.</p>
+     */
+    inline void SetResourceEndpoint(const Aws::String& value) { m_resourceEndpointHasBeenSet = true; m_resourceEndpoint = value; }
+
+    /**
+     * <p>The endpoint of the signaling channel returned by the
+     * <code>GetSignalingChannelEndpoint</code> API.</p>
+     */
+    inline void SetResourceEndpoint(Aws::String&& value) { m_resourceEndpointHasBeenSet = true; m_resourceEndpoint = std::move(value); }
+
+    /**
+     * <p>The endpoint of the signaling channel returned by the
+     * <code>GetSignalingChannelEndpoint</code> API.</p>
+     */
+    inline void SetResourceEndpoint(const char* value) { m_resourceEndpointHasBeenSet = true; m_resourceEndpoint.assign(value); }
+
+    /**
+     * <p>The endpoint of the signaling channel returned by the
+     * <code>GetSignalingChannelEndpoint</code> API.</p>
+     */
+    inline ResourceEndpointListItem& WithResourceEndpoint(const Aws::String& value) { SetResourceEndpoint(value); return *this;}
+
+    /**
+     * <p>The endpoint of the signaling channel returned by the
+     * <code>GetSignalingChannelEndpoint</code> API.</p>
+     */
+    inline ResourceEndpointListItem& WithResourceEndpoint(Aws::String&& value) { SetResourceEndpoint(std::move(value)); return *this;}
+
+    /**
+     * <p>The endpoint of the signaling channel returned by the
+     * <code>GetSignalingChannelEndpoint</code> API.</p>
+     */
+    inline ResourceEndpointListItem& WithResourceEndpoint(const char* value) { SetResourceEndpoint(value); return *this;}
+
+  private:
+
+    ChannelProtocol m_protocol;
+    bool m_protocolHasBeenSet;
+
+    Aws::String m_resourceEndpoint;
+    bool m_resourceEndpointHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/SingleMasterChannelEndpointConfiguration.h

@@ -0,0 +1,185 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/kinesisvideo/model/ChannelRole.h>
+#include <aws/kinesisvideo/model/ChannelProtocol.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   * <p>An object that contains the endpoint configuration for the
+   * <code>SINGLE_MASTER</code> channel type. </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/SingleMasterChannelEndpointConfiguration">AWS
+   * API Reference</a></p>
+   */
+  class AWS_KINESISVIDEO_API SingleMasterChannelEndpointConfiguration
+  {
+  public:
+    SingleMasterChannelEndpointConfiguration();
+    SingleMasterChannelEndpointConfiguration(Aws::Utils::Json::JsonView jsonValue);
+    SingleMasterChannelEndpointConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>This property is used to determine the nature of communication over this
+     * <code>SINGLE_MASTER</code> signaling channel. If <code>WSS</code> is specified,
+     * this API returns a websocket endpoint. If <code>HTTPS</code> is specified, this
+     * API returns an <code>HTTPS</code> endpoint.</p>
+     */
+    inline const Aws::Vector<ChannelProtocol>& GetProtocols() const{ return m_protocols; }
+
+    /**
+     * <p>This property is used to determine the nature of communication over this
+     * <code>SINGLE_MASTER</code> signaling channel. If <code>WSS</code> is specified,
+     * this API returns a websocket endpoint. If <code>HTTPS</code> is specified, this
+     * API returns an <code>HTTPS</code> endpoint.</p>
+     */
+    inline bool ProtocolsHasBeenSet() const { return m_protocolsHasBeenSet; }
+
+    /**
+     * <p>This property is used to determine the nature of communication over this
+     * <code>SINGLE_MASTER</code> signaling channel. If <code>WSS</code> is specified,
+     * this API returns a websocket endpoint. If <code>HTTPS</code> is specified, this
+     * API returns an <code>HTTPS</code> endpoint.</p>
+     */
+    inline void SetProtocols(const Aws::Vector<ChannelProtocol>& value) { m_protocolsHasBeenSet = true; m_protocols = value; }
+
+    /**
+     * <p>This property is used to determine the nature of communication over this
+     * <code>SINGLE_MASTER</code> signaling channel. If <code>WSS</code> is specified,
+     * this API returns a websocket endpoint. If <code>HTTPS</code> is specified, this
+     * API returns an <code>HTTPS</code> endpoint.</p>
+     */
+    inline void SetProtocols(Aws::Vector<ChannelProtocol>&& value) { m_protocolsHasBeenSet = true; m_protocols = std::move(value); }
+
+    /**
+     * <p>This property is used to determine the nature of communication over this
+     * <code>SINGLE_MASTER</code> signaling channel. If <code>WSS</code> is specified,
+     * this API returns a websocket endpoint. If <code>HTTPS</code> is specified, this
+     * API returns an <code>HTTPS</code> endpoint.</p>
+     */
+    inline SingleMasterChannelEndpointConfiguration& WithProtocols(const Aws::Vector<ChannelProtocol>& value) { SetProtocols(value); return *this;}
+
+    /**
+     * <p>This property is used to determine the nature of communication over this
+     * <code>SINGLE_MASTER</code> signaling channel. If <code>WSS</code> is specified,
+     * this API returns a websocket endpoint. If <code>HTTPS</code> is specified, this
+     * API returns an <code>HTTPS</code> endpoint.</p>
+     */
+    inline SingleMasterChannelEndpointConfiguration& WithProtocols(Aws::Vector<ChannelProtocol>&& value) { SetProtocols(std::move(value)); return *this;}
+
+    /**
+     * <p>This property is used to determine the nature of communication over this
+     * <code>SINGLE_MASTER</code> signaling channel. If <code>WSS</code> is specified,
+     * this API returns a websocket endpoint. If <code>HTTPS</code> is specified, this
+     * API returns an <code>HTTPS</code> endpoint.</p>
+     */
+    inline SingleMasterChannelEndpointConfiguration& AddProtocols(const ChannelProtocol& value) { m_protocolsHasBeenSet = true; m_protocols.push_back(value); return *this; }
+
+    /**
+     * <p>This property is used to determine the nature of communication over this
+     * <code>SINGLE_MASTER</code> signaling channel. If <code>WSS</code> is specified,
+     * this API returns a websocket endpoint. If <code>HTTPS</code> is specified, this
+     * API returns an <code>HTTPS</code> endpoint.</p>
+     */
+    inline SingleMasterChannelEndpointConfiguration& AddProtocols(ChannelProtocol&& value) { m_protocolsHasBeenSet = true; m_protocols.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>This property is used to determine messaging permissions in this
+     * <code>SINGLE_MASTER</code> signaling channel. If <code>MASTER</code> is
+     * specified, this API returns an endpoint that a client can use to receive offers
+     * from and send answers to any of the viewers on this signaling channel. If
+     * <code>VIEWER</code> is specified, this API returns an endpoint that a client can
+     * use only to send offers to another <code>MASTER</code> client on this signaling
+     * channel. </p>
+     */
+    inline const ChannelRole& GetRole() const{ return m_role; }
+
+    /**
+     * <p>This property is used to determine messaging permissions in this
+     * <code>SINGLE_MASTER</code> signaling channel. If <code>MASTER</code> is
+     * specified, this API returns an endpoint that a client can use to receive offers
+     * from and send answers to any of the viewers on this signaling channel. If
+     * <code>VIEWER</code> is specified, this API returns an endpoint that a client can
+     * use only to send offers to another <code>MASTER</code> client on this signaling
+     * channel. </p>
+     */
+    inline bool RoleHasBeenSet() const { return m_roleHasBeenSet; }
+
+    /**
+     * <p>This property is used to determine messaging permissions in this
+     * <code>SINGLE_MASTER</code> signaling channel. If <code>MASTER</code> is
+     * specified, this API returns an endpoint that a client can use to receive offers
+     * from and send answers to any of the viewers on this signaling channel. If
+     * <code>VIEWER</code> is specified, this API returns an endpoint that a client can
+     * use only to send offers to another <code>MASTER</code> client on this signaling
+     * channel. </p>
+     */
+    inline void SetRole(const ChannelRole& value) { m_roleHasBeenSet = true; m_role = value; }
+
+    /**
+     * <p>This property is used to determine messaging permissions in this
+     * <code>SINGLE_MASTER</code> signaling channel. If <code>MASTER</code> is
+     * specified, this API returns an endpoint that a client can use to receive offers
+     * from and send answers to any of the viewers on this signaling channel. If
+     * <code>VIEWER</code> is specified, this API returns an endpoint that a client can
+     * use only to send offers to another <code>MASTER</code> client on this signaling
+     * channel. </p>
+     */
+    inline void SetRole(ChannelRole&& value) { m_roleHasBeenSet = true; m_role = std::move(value); }
+
+    /**
+     * <p>This property is used to determine messaging permissions in this
+     * <code>SINGLE_MASTER</code> signaling channel. If <code>MASTER</code> is
+     * specified, this API returns an endpoint that a client can use to receive offers
+     * from and send answers to any of the viewers on this signaling channel. If
+     * <code>VIEWER</code> is specified, this API returns an endpoint that a client can
+     * use only to send offers to another <code>MASTER</code> client on this signaling
+     * channel. </p>
+     */
+    inline SingleMasterChannelEndpointConfiguration& WithRole(const ChannelRole& value) { SetRole(value); return *this;}
+
+    /**
+     * <p>This property is used to determine messaging permissions in this
+     * <code>SINGLE_MASTER</code> signaling channel. If <code>MASTER</code> is
+     * specified, this API returns an endpoint that a client can use to receive offers
+     * from and send answers to any of the viewers on this signaling channel. If
+     * <code>VIEWER</code> is specified, this API returns an endpoint that a client can
+     * use only to send offers to another <code>MASTER</code> client on this signaling
+     * channel. </p>
+     */
+    inline SingleMasterChannelEndpointConfiguration& WithRole(ChannelRole&& value) { SetRole(std::move(value)); return *this;}
+
+  private:
+
+    Aws::Vector<ChannelProtocol> m_protocols;
+    bool m_protocolsHasBeenSet;
+
+    ChannelRole m_role;
+    bool m_roleHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/SingleMasterConfiguration.h

@@ -0,0 +1,71 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   * <p>A structure that contains the configuration for the
+   * <code>SINGLE_MASTER</code> channel type.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/SingleMasterConfiguration">AWS
+   * API Reference</a></p>
+   */
+  class AWS_KINESISVIDEO_API SingleMasterConfiguration
+  {
+  public:
+    SingleMasterConfiguration();
+    SingleMasterConfiguration(Aws::Utils::Json::JsonView jsonValue);
+    SingleMasterConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The period of time a signaling channel retains underlivered messages before
+     * they are discarded.</p>
+     */
+    inline int GetMessageTtlSeconds() const{ return m_messageTtlSeconds; }
+
+    /**
+     * <p>The period of time a signaling channel retains underlivered messages before
+     * they are discarded.</p>
+     */
+    inline bool MessageTtlSecondsHasBeenSet() const { return m_messageTtlSecondsHasBeenSet; }
+
+    /**
+     * <p>The period of time a signaling channel retains underlivered messages before
+     * they are discarded.</p>
+     */
+    inline void SetMessageTtlSeconds(int value) { m_messageTtlSecondsHasBeenSet = true; m_messageTtlSeconds = value; }
+
+    /**
+     * <p>The period of time a signaling channel retains underlivered messages before
+     * they are discarded.</p>
+     */
+    inline SingleMasterConfiguration& WithMessageTtlSeconds(int value) { SetMessageTtlSeconds(value); return *this;}
+
+  private:
+
+    int m_messageTtlSeconds;
+    bool m_messageTtlSecondsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/Status.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/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+  enum class Status
+  {
+    NOT_SET,
+    CREATING,
+    ACTIVE,
+    UPDATING,
+    DELETING
+  };
+
+namespace StatusMapper
+{
+AWS_KINESISVIDEO_API Status GetStatusForName(const Aws::String& name);
+
+AWS_KINESISVIDEO_API Aws::String GetNameForStatus(Status value);
+} // namespace StatusMapper
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/StreamInfo.h

@@ -0,0 +1,410 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/kinesisvideo/model/Status.h>
+#include <aws/core/utils/DateTime.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   * <p>An object describing a Kinesis video stream.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/StreamInfo">AWS
+   * API Reference</a></p>
+   */
+  class AWS_KINESISVIDEO_API StreamInfo
+  {
+  public:
+    StreamInfo();
+    StreamInfo(Aws::Utils::Json::JsonView jsonValue);
+    StreamInfo& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name of the device that is associated with the stream.</p>
+     */
+    inline const Aws::String& GetDeviceName() const{ return m_deviceName; }
+
+    /**
+     * <p>The name of the device that is associated with the stream.</p>
+     */
+    inline bool DeviceNameHasBeenSet() const { return m_deviceNameHasBeenSet; }
+
+    /**
+     * <p>The name of the device that is associated with the stream.</p>
+     */
+    inline void SetDeviceName(const Aws::String& value) { m_deviceNameHasBeenSet = true; m_deviceName = value; }
+
+    /**
+     * <p>The name of the device that is associated with the stream.</p>
+     */
+    inline void SetDeviceName(Aws::String&& value) { m_deviceNameHasBeenSet = true; m_deviceName = std::move(value); }
+
+    /**
+     * <p>The name of the device that is associated with the stream.</p>
+     */
+    inline void SetDeviceName(const char* value) { m_deviceNameHasBeenSet = true; m_deviceName.assign(value); }
+
+    /**
+     * <p>The name of the device that is associated with the stream.</p>
+     */
+    inline StreamInfo& WithDeviceName(const Aws::String& value) { SetDeviceName(value); return *this;}
+
+    /**
+     * <p>The name of the device that is associated with the stream.</p>
+     */
+    inline StreamInfo& WithDeviceName(Aws::String&& value) { SetDeviceName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the device that is associated with the stream.</p>
+     */
+    inline StreamInfo& WithDeviceName(const char* value) { SetDeviceName(value); return *this;}
+
+
+    /**
+     * <p>The name of the stream.</p>
+     */
+    inline const Aws::String& GetStreamName() const{ return m_streamName; }
+
+    /**
+     * <p>The name of the stream.</p>
+     */
+    inline bool StreamNameHasBeenSet() const { return m_streamNameHasBeenSet; }
+
+    /**
+     * <p>The name of the stream.</p>
+     */
+    inline void SetStreamName(const Aws::String& value) { m_streamNameHasBeenSet = true; m_streamName = value; }
+
+    /**
+     * <p>The name of the stream.</p>
+     */
+    inline void SetStreamName(Aws::String&& value) { m_streamNameHasBeenSet = true; m_streamName = std::move(value); }
+
+    /**
+     * <p>The name of the stream.</p>
+     */
+    inline void SetStreamName(const char* value) { m_streamNameHasBeenSet = true; m_streamName.assign(value); }
+
+    /**
+     * <p>The name of the stream.</p>
+     */
+    inline StreamInfo& WithStreamName(const Aws::String& value) { SetStreamName(value); return *this;}
+
+    /**
+     * <p>The name of the stream.</p>
+     */
+    inline StreamInfo& WithStreamName(Aws::String&& value) { SetStreamName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the stream.</p>
+     */
+    inline StreamInfo& WithStreamName(const char* value) { SetStreamName(value); return *this;}
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline const Aws::String& GetStreamARN() const{ return m_streamARN; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline bool StreamARNHasBeenSet() const { return m_streamARNHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline void SetStreamARN(const Aws::String& value) { m_streamARNHasBeenSet = true; m_streamARN = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline void SetStreamARN(Aws::String&& value) { m_streamARNHasBeenSet = true; m_streamARN = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline void SetStreamARN(const char* value) { m_streamARNHasBeenSet = true; m_streamARN.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline StreamInfo& WithStreamARN(const Aws::String& value) { SetStreamARN(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline StreamInfo& WithStreamARN(Aws::String&& value) { SetStreamARN(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream.</p>
+     */
+    inline StreamInfo& WithStreamARN(const char* value) { SetStreamARN(value); return *this;}
+
+
+    /**
+     * <p>The <code>MediaType</code> of the stream. </p>
+     */
+    inline const Aws::String& GetMediaType() const{ return m_mediaType; }
+
+    /**
+     * <p>The <code>MediaType</code> of the stream. </p>
+     */
+    inline bool MediaTypeHasBeenSet() const { return m_mediaTypeHasBeenSet; }
+
+    /**
+     * <p>The <code>MediaType</code> of the stream. </p>
+     */
+    inline void SetMediaType(const Aws::String& value) { m_mediaTypeHasBeenSet = true; m_mediaType = value; }
+
+    /**
+     * <p>The <code>MediaType</code> of the stream. </p>
+     */
+    inline void SetMediaType(Aws::String&& value) { m_mediaTypeHasBeenSet = true; m_mediaType = std::move(value); }
+
+    /**
+     * <p>The <code>MediaType</code> of the stream. </p>
+     */
+    inline void SetMediaType(const char* value) { m_mediaTypeHasBeenSet = true; m_mediaType.assign(value); }
+
+    /**
+     * <p>The <code>MediaType</code> of the stream. </p>
+     */
+    inline StreamInfo& WithMediaType(const Aws::String& value) { SetMediaType(value); return *this;}
+
+    /**
+     * <p>The <code>MediaType</code> of the stream. </p>
+     */
+    inline StreamInfo& WithMediaType(Aws::String&& value) { SetMediaType(std::move(value)); return *this;}
+
+    /**
+     * <p>The <code>MediaType</code> of the stream. </p>
+     */
+    inline StreamInfo& WithMediaType(const char* value) { SetMediaType(value); return *this;}
+
+
+    /**
+     * <p>The ID of the AWS Key Management Service (AWS KMS) key that Kinesis Video
+     * Streams uses to encrypt data on the stream.</p>
+     */
+    inline const Aws::String& GetKmsKeyId() const{ return m_kmsKeyId; }
+
+    /**
+     * <p>The ID of the AWS Key Management Service (AWS KMS) key that Kinesis Video
+     * Streams uses to encrypt data on the stream.</p>
+     */
+    inline bool KmsKeyIdHasBeenSet() const { return m_kmsKeyIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the AWS Key Management Service (AWS KMS) key that Kinesis Video
+     * Streams uses to encrypt data on the stream.</p>
+     */
+    inline void SetKmsKeyId(const Aws::String& value) { m_kmsKeyIdHasBeenSet = true; m_kmsKeyId = value; }
+
+    /**
+     * <p>The ID of the AWS Key Management Service (AWS KMS) key that Kinesis Video
+     * Streams uses to encrypt data on the stream.</p>
+     */
+    inline void SetKmsKeyId(Aws::String&& value) { m_kmsKeyIdHasBeenSet = true; m_kmsKeyId = std::move(value); }
+
+    /**
+     * <p>The ID of the AWS Key Management Service (AWS KMS) key that Kinesis Video
+     * Streams uses to encrypt data on the stream.</p>
+     */
+    inline void SetKmsKeyId(const char* value) { m_kmsKeyIdHasBeenSet = true; m_kmsKeyId.assign(value); }
+
+    /**
+     * <p>The ID of the AWS Key Management Service (AWS KMS) key that Kinesis Video
+     * Streams uses to encrypt data on the stream.</p>
+     */
+    inline StreamInfo& WithKmsKeyId(const Aws::String& value) { SetKmsKeyId(value); return *this;}
+
+    /**
+     * <p>The ID of the AWS Key Management Service (AWS KMS) key that Kinesis Video
+     * Streams uses to encrypt data on the stream.</p>
+     */
+    inline StreamInfo& WithKmsKeyId(Aws::String&& value) { SetKmsKeyId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the AWS Key Management Service (AWS KMS) key that Kinesis Video
+     * Streams uses to encrypt data on the stream.</p>
+     */
+    inline StreamInfo& WithKmsKeyId(const char* value) { SetKmsKeyId(value); return *this;}
+
+
+    /**
+     * <p>The version of the stream.</p>
+     */
+    inline const Aws::String& GetVersion() const{ return m_version; }
+
+    /**
+     * <p>The version of the stream.</p>
+     */
+    inline bool VersionHasBeenSet() const { return m_versionHasBeenSet; }
+
+    /**
+     * <p>The version of the stream.</p>
+     */
+    inline void SetVersion(const Aws::String& value) { m_versionHasBeenSet = true; m_version = value; }
+
+    /**
+     * <p>The version of the stream.</p>
+     */
+    inline void SetVersion(Aws::String&& value) { m_versionHasBeenSet = true; m_version = std::move(value); }
+
+    /**
+     * <p>The version of the stream.</p>
+     */
+    inline void SetVersion(const char* value) { m_versionHasBeenSet = true; m_version.assign(value); }
+
+    /**
+     * <p>The version of the stream.</p>
+     */
+    inline StreamInfo& WithVersion(const Aws::String& value) { SetVersion(value); return *this;}
+
+    /**
+     * <p>The version of the stream.</p>
+     */
+    inline StreamInfo& WithVersion(Aws::String&& value) { SetVersion(std::move(value)); return *this;}
+
+    /**
+     * <p>The version of the stream.</p>
+     */
+    inline StreamInfo& WithVersion(const char* value) { SetVersion(value); return *this;}
+
+
+    /**
+     * <p>The status of the stream.</p>
+     */
+    inline const Status& GetStatus() const{ return m_status; }
+
+    /**
+     * <p>The status of the stream.</p>
+     */
+    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
+
+    /**
+     * <p>The status of the stream.</p>
+     */
+    inline void SetStatus(const Status& value) { m_statusHasBeenSet = true; m_status = value; }
+
+    /**
+     * <p>The status of the stream.</p>
+     */
+    inline void SetStatus(Status&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
+
+    /**
+     * <p>The status of the stream.</p>
+     */
+    inline StreamInfo& WithStatus(const Status& value) { SetStatus(value); return *this;}
+
+    /**
+     * <p>The status of the stream.</p>
+     */
+    inline StreamInfo& WithStatus(Status&& value) { SetStatus(std::move(value)); return *this;}
+
+
+    /**
+     * <p>A time stamp that indicates when the stream was created.</p>
+     */
+    inline const Aws::Utils::DateTime& GetCreationTime() const{ return m_creationTime; }
+
+    /**
+     * <p>A time stamp that indicates when the stream was created.</p>
+     */
+    inline bool CreationTimeHasBeenSet() const { return m_creationTimeHasBeenSet; }
+
+    /**
+     * <p>A time stamp that indicates when the stream was created.</p>
+     */
+    inline void SetCreationTime(const Aws::Utils::DateTime& value) { m_creationTimeHasBeenSet = true; m_creationTime = value; }
+
+    /**
+     * <p>A time stamp that indicates when the stream was created.</p>
+     */
+    inline void SetCreationTime(Aws::Utils::DateTime&& value) { m_creationTimeHasBeenSet = true; m_creationTime = std::move(value); }
+
+    /**
+     * <p>A time stamp that indicates when the stream was created.</p>
+     */
+    inline StreamInfo& WithCreationTime(const Aws::Utils::DateTime& value) { SetCreationTime(value); return *this;}
+
+    /**
+     * <p>A time stamp that indicates when the stream was created.</p>
+     */
+    inline StreamInfo& WithCreationTime(Aws::Utils::DateTime&& value) { SetCreationTime(std::move(value)); return *this;}
+
+
+    /**
+     * <p>How long the stream retains data, in hours.</p>
+     */
+    inline int GetDataRetentionInHours() const{ return m_dataRetentionInHours; }
+
+    /**
+     * <p>How long the stream retains data, in hours.</p>
+     */
+    inline bool DataRetentionInHoursHasBeenSet() const { return m_dataRetentionInHoursHasBeenSet; }
+
+    /**
+     * <p>How long the stream retains data, in hours.</p>
+     */
+    inline void SetDataRetentionInHours(int value) { m_dataRetentionInHoursHasBeenSet = true; m_dataRetentionInHours = value; }
+
+    /**
+     * <p>How long the stream retains data, in hours.</p>
+     */
+    inline StreamInfo& WithDataRetentionInHours(int value) { SetDataRetentionInHours(value); return *this;}
+
+  private:
+
+    Aws::String m_deviceName;
+    bool m_deviceNameHasBeenSet;
+
+    Aws::String m_streamName;
+    bool m_streamNameHasBeenSet;
+
+    Aws::String m_streamARN;
+    bool m_streamARNHasBeenSet;
+
+    Aws::String m_mediaType;
+    bool m_mediaTypeHasBeenSet;
+
+    Aws::String m_kmsKeyId;
+    bool m_kmsKeyIdHasBeenSet;
+
+    Aws::String m_version;
+    bool m_versionHasBeenSet;
+
+    Status m_status;
+    bool m_statusHasBeenSet;
+
+    Aws::Utils::DateTime m_creationTime;
+    bool m_creationTimeHasBeenSet;
+
+    int m_dataRetentionInHours;
+    bool m_dataRetentionInHoursHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/StreamNameCondition.h

@@ -0,0 +1,139 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/model/ComparisonOperator.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 KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   * <p>Specifies the condition that streams must satisfy to be returned when you
+   * list streams (see the <code>ListStreams</code> API). A condition has a
+   * comparison operation and a value. Currently, you can specify only the
+   * <code>BEGINS_WITH</code> operator, which finds streams whose names start with a
+   * given prefix. </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/StreamNameCondition">AWS
+   * API Reference</a></p>
+   */
+  class AWS_KINESISVIDEO_API StreamNameCondition
+  {
+  public:
+    StreamNameCondition();
+    StreamNameCondition(Aws::Utils::Json::JsonView jsonValue);
+    StreamNameCondition& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>A comparison operator. Currently, you can specify only the
+     * <code>BEGINS_WITH</code> operator, which finds streams whose names start with a
+     * given prefix.</p>
+     */
+    inline const ComparisonOperator& GetComparisonOperator() const{ return m_comparisonOperator; }
+
+    /**
+     * <p>A comparison operator. Currently, you can specify only the
+     * <code>BEGINS_WITH</code> operator, which finds streams whose names start with a
+     * given prefix.</p>
+     */
+    inline bool ComparisonOperatorHasBeenSet() const { return m_comparisonOperatorHasBeenSet; }
+
+    /**
+     * <p>A comparison operator. Currently, you can specify only the
+     * <code>BEGINS_WITH</code> operator, which finds streams whose names start with a
+     * given prefix.</p>
+     */
+    inline void SetComparisonOperator(const ComparisonOperator& value) { m_comparisonOperatorHasBeenSet = true; m_comparisonOperator = value; }
+
+    /**
+     * <p>A comparison operator. Currently, you can specify only the
+     * <code>BEGINS_WITH</code> operator, which finds streams whose names start with a
+     * given prefix.</p>
+     */
+    inline void SetComparisonOperator(ComparisonOperator&& value) { m_comparisonOperatorHasBeenSet = true; m_comparisonOperator = std::move(value); }
+
+    /**
+     * <p>A comparison operator. Currently, you can specify only the
+     * <code>BEGINS_WITH</code> operator, which finds streams whose names start with a
+     * given prefix.</p>
+     */
+    inline StreamNameCondition& WithComparisonOperator(const ComparisonOperator& value) { SetComparisonOperator(value); return *this;}
+
+    /**
+     * <p>A comparison operator. Currently, you can specify only the
+     * <code>BEGINS_WITH</code> operator, which finds streams whose names start with a
+     * given prefix.</p>
+     */
+    inline StreamNameCondition& WithComparisonOperator(ComparisonOperator&& value) { SetComparisonOperator(std::move(value)); return *this;}
+
+
+    /**
+     * <p>A value to compare.</p>
+     */
+    inline const Aws::String& GetComparisonValue() const{ return m_comparisonValue; }
+
+    /**
+     * <p>A value to compare.</p>
+     */
+    inline bool ComparisonValueHasBeenSet() const { return m_comparisonValueHasBeenSet; }
+
+    /**
+     * <p>A value to compare.</p>
+     */
+    inline void SetComparisonValue(const Aws::String& value) { m_comparisonValueHasBeenSet = true; m_comparisonValue = value; }
+
+    /**
+     * <p>A value to compare.</p>
+     */
+    inline void SetComparisonValue(Aws::String&& value) { m_comparisonValueHasBeenSet = true; m_comparisonValue = std::move(value); }
+
+    /**
+     * <p>A value to compare.</p>
+     */
+    inline void SetComparisonValue(const char* value) { m_comparisonValueHasBeenSet = true; m_comparisonValue.assign(value); }
+
+    /**
+     * <p>A value to compare.</p>
+     */
+    inline StreamNameCondition& WithComparisonValue(const Aws::String& value) { SetComparisonValue(value); return *this;}
+
+    /**
+     * <p>A value to compare.</p>
+     */
+    inline StreamNameCondition& WithComparisonValue(Aws::String&& value) { SetComparisonValue(std::move(value)); return *this;}
+
+    /**
+     * <p>A value to compare.</p>
+     */
+    inline StreamNameCondition& WithComparisonValue(const char* value) { SetComparisonValue(value); return *this;}
+
+  private:
+
+    ComparisonOperator m_comparisonOperator;
+    bool m_comparisonOperatorHasBeenSet;
+
+    Aws::String m_comparisonValue;
+    bool m_comparisonValueHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

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

@@ -0,0 +1,149 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_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 KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   * <p>A key and value pair that is associated with the specified signaling
+   * channel.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/Tag">AWS
+   * API Reference</a></p>
+   */
+  class AWS_KINESISVIDEO_API Tag
+  {
+  public:
+    Tag();
+    Tag(Aws::Utils::Json::JsonView jsonValue);
+    Tag& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The key of the tag that is associated with the specified signaling
+     * channel.</p>
+     */
+    inline const Aws::String& GetKey() const{ return m_key; }
+
+    /**
+     * <p>The key of the tag that is associated with the specified signaling
+     * channel.</p>
+     */
+    inline bool KeyHasBeenSet() const { return m_keyHasBeenSet; }
+
+    /**
+     * <p>The key of the tag that is associated with the specified signaling
+     * channel.</p>
+     */
+    inline void SetKey(const Aws::String& value) { m_keyHasBeenSet = true; m_key = value; }
+
+    /**
+     * <p>The key of the tag that is associated with the specified signaling
+     * channel.</p>
+     */
+    inline void SetKey(Aws::String&& value) { m_keyHasBeenSet = true; m_key = std::move(value); }
+
+    /**
+     * <p>The key of the tag that is associated with the specified signaling
+     * channel.</p>
+     */
+    inline void SetKey(const char* value) { m_keyHasBeenSet = true; m_key.assign(value); }
+
+    /**
+     * <p>The key of the tag that is associated with the specified signaling
+     * channel.</p>
+     */
+    inline Tag& WithKey(const Aws::String& value) { SetKey(value); return *this;}
+
+    /**
+     * <p>The key of the tag that is associated with the specified signaling
+     * channel.</p>
+     */
+    inline Tag& WithKey(Aws::String&& value) { SetKey(std::move(value)); return *this;}
+
+    /**
+     * <p>The key of the tag that is associated with the specified signaling
+     * channel.</p>
+     */
+    inline Tag& WithKey(const char* value) { SetKey(value); return *this;}
+
+
+    /**
+     * <p>The value of the tag that is associated with the specified signaling
+     * channel.</p>
+     */
+    inline const Aws::String& GetValue() const{ return m_value; }
+
+    /**
+     * <p>The value of the tag that is associated with the specified signaling
+     * channel.</p>
+     */
+    inline bool ValueHasBeenSet() const { return m_valueHasBeenSet; }
+
+    /**
+     * <p>The value of the tag that is associated with the specified signaling
+     * channel.</p>
+     */
+    inline void SetValue(const Aws::String& value) { m_valueHasBeenSet = true; m_value = value; }
+
+    /**
+     * <p>The value of the tag that is associated with the specified signaling
+     * channel.</p>
+     */
+    inline void SetValue(Aws::String&& value) { m_valueHasBeenSet = true; m_value = std::move(value); }
+
+    /**
+     * <p>The value of the tag that is associated with the specified signaling
+     * channel.</p>
+     */
+    inline void SetValue(const char* value) { m_valueHasBeenSet = true; m_value.assign(value); }
+
+    /**
+     * <p>The value of the tag that is associated with the specified signaling
+     * channel.</p>
+     */
+    inline Tag& WithValue(const Aws::String& value) { SetValue(value); return *this;}
+
+    /**
+     * <p>The value of the tag that is associated with the specified signaling
+     * channel.</p>
+     */
+    inline Tag& WithValue(Aws::String&& value) { SetValue(std::move(value)); return *this;}
+
+    /**
+     * <p>The value of the tag that is associated with the specified signaling
+     * channel.</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 KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/TagResourceRequest.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/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/KinesisVideoRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/kinesisvideo/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_KINESISVIDEO_API TagResourceRequest : public KinesisVideoRequest
+  {
+  public:
+    TagResourceRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "TagResource"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel to which you want to
+     * add tags.</p>
+     */
+    inline const Aws::String& GetResourceARN() const{ return m_resourceARN; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel to which you want to
+     * add tags.</p>
+     */
+    inline bool ResourceARNHasBeenSet() const { return m_resourceARNHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel to which you want to
+     * add tags.</p>
+     */
+    inline void SetResourceARN(const Aws::String& value) { m_resourceARNHasBeenSet = true; m_resourceARN = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel to which you want to
+     * add tags.</p>
+     */
+    inline void SetResourceARN(Aws::String&& value) { m_resourceARNHasBeenSet = true; m_resourceARN = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel to which you want to
+     * add tags.</p>
+     */
+    inline void SetResourceARN(const char* value) { m_resourceARNHasBeenSet = true; m_resourceARN.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel to which you want to
+     * add tags.</p>
+     */
+    inline TagResourceRequest& WithResourceARN(const Aws::String& value) { SetResourceARN(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel to which you want to
+     * add tags.</p>
+     */
+    inline TagResourceRequest& WithResourceARN(Aws::String&& value) { SetResourceARN(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel to which you want to
+     * add tags.</p>
+     */
+    inline TagResourceRequest& WithResourceARN(const char* value) { SetResourceARN(value); return *this;}
+
+
+    /**
+     * <p>A list of tags to associate with the specified signaling channel. Each tag is
+     * a key-value pair.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>A list of tags to associate with the specified signaling channel. Each tag is
+     * a key-value pair.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>A list of tags to associate with the specified signaling channel. Each tag is
+     * a key-value pair.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>A list of tags to associate with the specified signaling channel. Each tag is
+     * a key-value pair.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>A list of tags to associate with the specified signaling channel. Each tag is
+     * a key-value pair.</p>
+     */
+    inline TagResourceRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>A list of tags to associate with the specified signaling channel. Each tag is
+     * a key-value pair.</p>
+     */
+    inline TagResourceRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of tags to associate with the specified signaling channel. Each tag is
+     * a key-value pair.</p>
+     */
+    inline TagResourceRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>A list of tags to associate with the specified signaling channel. Each tag is
+     * a key-value pair.</p>
+     */
+    inline TagResourceRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_resourceARN;
+    bool m_resourceARNHasBeenSet;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

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

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/TagStreamRequest.h

@@ -0,0 +1,218 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/KinesisVideoRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_KINESISVIDEO_API TagStreamRequest : public KinesisVideoRequest
+  {
+  public:
+    TagStreamRequest();
+
+    // 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 "TagStream"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource that you want to add the tag
+     * or tags to.</p>
+     */
+    inline const Aws::String& GetStreamARN() const{ return m_streamARN; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource that you want to add the tag
+     * or tags to.</p>
+     */
+    inline bool StreamARNHasBeenSet() const { return m_streamARNHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource that you want to add the tag
+     * or tags to.</p>
+     */
+    inline void SetStreamARN(const Aws::String& value) { m_streamARNHasBeenSet = true; m_streamARN = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource that you want to add the tag
+     * or tags to.</p>
+     */
+    inline void SetStreamARN(Aws::String&& value) { m_streamARNHasBeenSet = true; m_streamARN = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource that you want to add the tag
+     * or tags to.</p>
+     */
+    inline void SetStreamARN(const char* value) { m_streamARNHasBeenSet = true; m_streamARN.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource that you want to add the tag
+     * or tags to.</p>
+     */
+    inline TagStreamRequest& WithStreamARN(const Aws::String& value) { SetStreamARN(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource that you want to add the tag
+     * or tags to.</p>
+     */
+    inline TagStreamRequest& WithStreamARN(Aws::String&& value) { SetStreamARN(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource that you want to add the tag
+     * or tags to.</p>
+     */
+    inline TagStreamRequest& WithStreamARN(const char* value) { SetStreamARN(value); return *this;}
+
+
+    /**
+     * <p>The name of the stream that you want to add the tag or tags to.</p>
+     */
+    inline const Aws::String& GetStreamName() const{ return m_streamName; }
+
+    /**
+     * <p>The name of the stream that you want to add the tag or tags to.</p>
+     */
+    inline bool StreamNameHasBeenSet() const { return m_streamNameHasBeenSet; }
+
+    /**
+     * <p>The name of the stream that you want to add the tag or tags to.</p>
+     */
+    inline void SetStreamName(const Aws::String& value) { m_streamNameHasBeenSet = true; m_streamName = value; }
+
+    /**
+     * <p>The name of the stream that you want to add the tag or tags to.</p>
+     */
+    inline void SetStreamName(Aws::String&& value) { m_streamNameHasBeenSet = true; m_streamName = std::move(value); }
+
+    /**
+     * <p>The name of the stream that you want to add the tag or tags to.</p>
+     */
+    inline void SetStreamName(const char* value) { m_streamNameHasBeenSet = true; m_streamName.assign(value); }
+
+    /**
+     * <p>The name of the stream that you want to add the tag or tags to.</p>
+     */
+    inline TagStreamRequest& WithStreamName(const Aws::String& value) { SetStreamName(value); return *this;}
+
+    /**
+     * <p>The name of the stream that you want to add the tag or tags to.</p>
+     */
+    inline TagStreamRequest& WithStreamName(Aws::String&& value) { SetStreamName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the stream that you want to add the tag or tags to.</p>
+     */
+    inline TagStreamRequest& WithStreamName(const char* value) { SetStreamName(value); return *this;}
+
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline void SetTags(const Aws::Map<Aws::String, Aws::String>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline void SetTags(Aws::Map<Aws::String, Aws::String>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline TagStreamRequest& WithTags(const Aws::Map<Aws::String, Aws::String>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline TagStreamRequest& WithTags(Aws::Map<Aws::String, Aws::String>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline TagStreamRequest& AddTags(const Aws::String& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline TagStreamRequest& AddTags(Aws::String&& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline TagStreamRequest& AddTags(const Aws::String& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline TagStreamRequest& AddTags(Aws::String&& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline TagStreamRequest& AddTags(const char* key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline TagStreamRequest& AddTags(Aws::String&& key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>A list of tags to associate with the specified stream. Each tag is a
+     * key-value pair (the value is optional).</p>
+     */
+    inline TagStreamRequest& AddTags(const char* key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+  private:
+
+    Aws::String m_streamARN;
+    bool m_streamARNHasBeenSet;
+
+    Aws::String m_streamName;
+    bool m_streamNameHasBeenSet;
+
+    Aws::Map<Aws::String, Aws::String> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

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

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

@@ -0,0 +1,141 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/KinesisVideoRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <utility>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_KINESISVIDEO_API UntagResourceRequest : public KinesisVideoRequest
+  {
+  public:
+    UntagResourceRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "UntagResource"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel from which you want
+     * to remove tags.</p>
+     */
+    inline const Aws::String& GetResourceARN() const{ return m_resourceARN; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel from which you want
+     * to remove tags.</p>
+     */
+    inline bool ResourceARNHasBeenSet() const { return m_resourceARNHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel from which you want
+     * to remove tags.</p>
+     */
+    inline void SetResourceARN(const Aws::String& value) { m_resourceARNHasBeenSet = true; m_resourceARN = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel from which you want
+     * to remove tags.</p>
+     */
+    inline void SetResourceARN(Aws::String&& value) { m_resourceARNHasBeenSet = true; m_resourceARN = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel from which you want
+     * to remove tags.</p>
+     */
+    inline void SetResourceARN(const char* value) { m_resourceARNHasBeenSet = true; m_resourceARN.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel from which you want
+     * to remove tags.</p>
+     */
+    inline UntagResourceRequest& WithResourceARN(const Aws::String& value) { SetResourceARN(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel from which you want
+     * to remove tags.</p>
+     */
+    inline UntagResourceRequest& WithResourceARN(Aws::String&& value) { SetResourceARN(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel from which you want
+     * to remove tags.</p>
+     */
+    inline UntagResourceRequest& WithResourceARN(const char* value) { SetResourceARN(value); return *this;}
+
+
+    /**
+     * <p>A list of the keys of the tags that you want to remove.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetTagKeyList() const{ return m_tagKeyList; }
+
+    /**
+     * <p>A list of the keys of the tags that you want to remove.</p>
+     */
+    inline bool TagKeyListHasBeenSet() const { return m_tagKeyListHasBeenSet; }
+
+    /**
+     * <p>A list of the keys of the tags that you want to remove.</p>
+     */
+    inline void SetTagKeyList(const Aws::Vector<Aws::String>& value) { m_tagKeyListHasBeenSet = true; m_tagKeyList = value; }
+
+    /**
+     * <p>A list of the keys of the tags that you want to remove.</p>
+     */
+    inline void SetTagKeyList(Aws::Vector<Aws::String>&& value) { m_tagKeyListHasBeenSet = true; m_tagKeyList = std::move(value); }
+
+    /**
+     * <p>A list of the keys of the tags that you want to remove.</p>
+     */
+    inline UntagResourceRequest& WithTagKeyList(const Aws::Vector<Aws::String>& value) { SetTagKeyList(value); return *this;}
+
+    /**
+     * <p>A list of the keys of the tags that you want to remove.</p>
+     */
+    inline UntagResourceRequest& WithTagKeyList(Aws::Vector<Aws::String>&& value) { SetTagKeyList(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of the keys of the tags that you want to remove.</p>
+     */
+    inline UntagResourceRequest& AddTagKeyList(const Aws::String& value) { m_tagKeyListHasBeenSet = true; m_tagKeyList.push_back(value); return *this; }
+
+    /**
+     * <p>A list of the keys of the tags that you want to remove.</p>
+     */
+    inline UntagResourceRequest& AddTagKeyList(Aws::String&& value) { m_tagKeyListHasBeenSet = true; m_tagKeyList.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A list of the keys of the tags that you want to remove.</p>
+     */
+    inline UntagResourceRequest& AddTagKeyList(const char* value) { m_tagKeyListHasBeenSet = true; m_tagKeyList.push_back(value); return *this; }
+
+  private:
+
+    Aws::String m_resourceARN;
+    bool m_resourceARNHasBeenSet;
+
+    Aws::Vector<Aws::String> m_tagKeyList;
+    bool m_tagKeyListHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

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

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/UntagStreamRequest.h

@@ -0,0 +1,185 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/KinesisVideoRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <utility>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_KINESISVIDEO_API UntagStreamRequest : public KinesisVideoRequest
+  {
+  public:
+    UntagStreamRequest();
+
+    // 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 "UntagStream"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to remove tags
+     * from.</p>
+     */
+    inline const Aws::String& GetStreamARN() const{ return m_streamARN; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to remove tags
+     * from.</p>
+     */
+    inline bool StreamARNHasBeenSet() const { return m_streamARNHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to remove tags
+     * from.</p>
+     */
+    inline void SetStreamARN(const Aws::String& value) { m_streamARNHasBeenSet = true; m_streamARN = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to remove tags
+     * from.</p>
+     */
+    inline void SetStreamARN(Aws::String&& value) { m_streamARNHasBeenSet = true; m_streamARN = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to remove tags
+     * from.</p>
+     */
+    inline void SetStreamARN(const char* value) { m_streamARNHasBeenSet = true; m_streamARN.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to remove tags
+     * from.</p>
+     */
+    inline UntagStreamRequest& WithStreamARN(const Aws::String& value) { SetStreamARN(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to remove tags
+     * from.</p>
+     */
+    inline UntagStreamRequest& WithStreamARN(Aws::String&& value) { SetStreamARN(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream that you want to remove tags
+     * from.</p>
+     */
+    inline UntagStreamRequest& WithStreamARN(const char* value) { SetStreamARN(value); return *this;}
+
+
+    /**
+     * <p>The name of the stream that you want to remove tags from.</p>
+     */
+    inline const Aws::String& GetStreamName() const{ return m_streamName; }
+
+    /**
+     * <p>The name of the stream that you want to remove tags from.</p>
+     */
+    inline bool StreamNameHasBeenSet() const { return m_streamNameHasBeenSet; }
+
+    /**
+     * <p>The name of the stream that you want to remove tags from.</p>
+     */
+    inline void SetStreamName(const Aws::String& value) { m_streamNameHasBeenSet = true; m_streamName = value; }
+
+    /**
+     * <p>The name of the stream that you want to remove tags from.</p>
+     */
+    inline void SetStreamName(Aws::String&& value) { m_streamNameHasBeenSet = true; m_streamName = std::move(value); }
+
+    /**
+     * <p>The name of the stream that you want to remove tags from.</p>
+     */
+    inline void SetStreamName(const char* value) { m_streamNameHasBeenSet = true; m_streamName.assign(value); }
+
+    /**
+     * <p>The name of the stream that you want to remove tags from.</p>
+     */
+    inline UntagStreamRequest& WithStreamName(const Aws::String& value) { SetStreamName(value); return *this;}
+
+    /**
+     * <p>The name of the stream that you want to remove tags from.</p>
+     */
+    inline UntagStreamRequest& WithStreamName(Aws::String&& value) { SetStreamName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the stream that you want to remove tags from.</p>
+     */
+    inline UntagStreamRequest& WithStreamName(const char* value) { SetStreamName(value); return *this;}
+
+
+    /**
+     * <p>A list of the keys of the tags that you want to remove.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetTagKeyList() const{ return m_tagKeyList; }
+
+    /**
+     * <p>A list of the keys of the tags that you want to remove.</p>
+     */
+    inline bool TagKeyListHasBeenSet() const { return m_tagKeyListHasBeenSet; }
+
+    /**
+     * <p>A list of the keys of the tags that you want to remove.</p>
+     */
+    inline void SetTagKeyList(const Aws::Vector<Aws::String>& value) { m_tagKeyListHasBeenSet = true; m_tagKeyList = value; }
+
+    /**
+     * <p>A list of the keys of the tags that you want to remove.</p>
+     */
+    inline void SetTagKeyList(Aws::Vector<Aws::String>&& value) { m_tagKeyListHasBeenSet = true; m_tagKeyList = std::move(value); }
+
+    /**
+     * <p>A list of the keys of the tags that you want to remove.</p>
+     */
+    inline UntagStreamRequest& WithTagKeyList(const Aws::Vector<Aws::String>& value) { SetTagKeyList(value); return *this;}
+
+    /**
+     * <p>A list of the keys of the tags that you want to remove.</p>
+     */
+    inline UntagStreamRequest& WithTagKeyList(Aws::Vector<Aws::String>&& value) { SetTagKeyList(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of the keys of the tags that you want to remove.</p>
+     */
+    inline UntagStreamRequest& AddTagKeyList(const Aws::String& value) { m_tagKeyListHasBeenSet = true; m_tagKeyList.push_back(value); return *this; }
+
+    /**
+     * <p>A list of the keys of the tags that you want to remove.</p>
+     */
+    inline UntagStreamRequest& AddTagKeyList(Aws::String&& value) { m_tagKeyListHasBeenSet = true; m_tagKeyList.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>A list of the keys of the tags that you want to remove.</p>
+     */
+    inline UntagStreamRequest& AddTagKeyList(const char* value) { m_tagKeyListHasBeenSet = true; m_tagKeyList.push_back(value); return *this; }
+
+  private:
+
+    Aws::String m_streamARN;
+    bool m_streamARNHasBeenSet;
+
+    Aws::String m_streamName;
+    bool m_streamNameHasBeenSet;
+
+    Aws::Vector<Aws::String> m_tagKeyList;
+    bool m_tagKeyListHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

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

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/UpdateDataRetentionOperation.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/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+  enum class UpdateDataRetentionOperation
+  {
+    NOT_SET,
+    INCREASE_DATA_RETENTION,
+    DECREASE_DATA_RETENTION
+  };
+
+namespace UpdateDataRetentionOperationMapper
+{
+AWS_KINESISVIDEO_API UpdateDataRetentionOperation GetUpdateDataRetentionOperationForName(const Aws::String& name);
+
+AWS_KINESISVIDEO_API Aws::String GetNameForUpdateDataRetentionOperation(UpdateDataRetentionOperation value);
+} // namespace UpdateDataRetentionOperationMapper
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/UpdateDataRetentionRequest.h

@@ -0,0 +1,258 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/KinesisVideoRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/kinesisvideo/model/UpdateDataRetentionOperation.h>
+#include <utility>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_KINESISVIDEO_API UpdateDataRetentionRequest : public KinesisVideoRequest
+  {
+  public:
+    UpdateDataRetentionRequest();
+
+    // 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 "UpdateDataRetention"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The name of the stream whose retention period you want to change.</p>
+     */
+    inline const Aws::String& GetStreamName() const{ return m_streamName; }
+
+    /**
+     * <p>The name of the stream whose retention period you want to change.</p>
+     */
+    inline bool StreamNameHasBeenSet() const { return m_streamNameHasBeenSet; }
+
+    /**
+     * <p>The name of the stream whose retention period you want to change.</p>
+     */
+    inline void SetStreamName(const Aws::String& value) { m_streamNameHasBeenSet = true; m_streamName = value; }
+
+    /**
+     * <p>The name of the stream whose retention period you want to change.</p>
+     */
+    inline void SetStreamName(Aws::String&& value) { m_streamNameHasBeenSet = true; m_streamName = std::move(value); }
+
+    /**
+     * <p>The name of the stream whose retention period you want to change.</p>
+     */
+    inline void SetStreamName(const char* value) { m_streamNameHasBeenSet = true; m_streamName.assign(value); }
+
+    /**
+     * <p>The name of the stream whose retention period you want to change.</p>
+     */
+    inline UpdateDataRetentionRequest& WithStreamName(const Aws::String& value) { SetStreamName(value); return *this;}
+
+    /**
+     * <p>The name of the stream whose retention period you want to change.</p>
+     */
+    inline UpdateDataRetentionRequest& WithStreamName(Aws::String&& value) { SetStreamName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the stream whose retention period you want to change.</p>
+     */
+    inline UpdateDataRetentionRequest& WithStreamName(const char* value) { SetStreamName(value); return *this;}
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream whose retention period you want
+     * to change.</p>
+     */
+    inline const Aws::String& GetStreamARN() const{ return m_streamARN; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream whose retention period you want
+     * to change.</p>
+     */
+    inline bool StreamARNHasBeenSet() const { return m_streamARNHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream whose retention period you want
+     * to change.</p>
+     */
+    inline void SetStreamARN(const Aws::String& value) { m_streamARNHasBeenSet = true; m_streamARN = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream whose retention period you want
+     * to change.</p>
+     */
+    inline void SetStreamARN(Aws::String&& value) { m_streamARNHasBeenSet = true; m_streamARN = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream whose retention period you want
+     * to change.</p>
+     */
+    inline void SetStreamARN(const char* value) { m_streamARNHasBeenSet = true; m_streamARN.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream whose retention period you want
+     * to change.</p>
+     */
+    inline UpdateDataRetentionRequest& WithStreamARN(const Aws::String& value) { SetStreamARN(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream whose retention period you want
+     * to change.</p>
+     */
+    inline UpdateDataRetentionRequest& WithStreamARN(Aws::String&& value) { SetStreamARN(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the stream whose retention period you want
+     * to change.</p>
+     */
+    inline UpdateDataRetentionRequest& WithStreamARN(const char* value) { SetStreamARN(value); return *this;}
+
+
+    /**
+     * <p>The version of the stream whose retention period you want to change. To get
+     * the version, call either the <code>DescribeStream</code> or the
+     * <code>ListStreams</code> API.</p>
+     */
+    inline const Aws::String& GetCurrentVersion() const{ return m_currentVersion; }
+
+    /**
+     * <p>The version of the stream whose retention period you want to change. To get
+     * the version, call either the <code>DescribeStream</code> or the
+     * <code>ListStreams</code> API.</p>
+     */
+    inline bool CurrentVersionHasBeenSet() const { return m_currentVersionHasBeenSet; }
+
+    /**
+     * <p>The version of the stream whose retention period you want to change. To get
+     * the version, call either the <code>DescribeStream</code> or the
+     * <code>ListStreams</code> API.</p>
+     */
+    inline void SetCurrentVersion(const Aws::String& value) { m_currentVersionHasBeenSet = true; m_currentVersion = value; }
+
+    /**
+     * <p>The version of the stream whose retention period you want to change. To get
+     * the version, call either the <code>DescribeStream</code> or the
+     * <code>ListStreams</code> API.</p>
+     */
+    inline void SetCurrentVersion(Aws::String&& value) { m_currentVersionHasBeenSet = true; m_currentVersion = std::move(value); }
+
+    /**
+     * <p>The version of the stream whose retention period you want to change. To get
+     * the version, call either the <code>DescribeStream</code> or the
+     * <code>ListStreams</code> API.</p>
+     */
+    inline void SetCurrentVersion(const char* value) { m_currentVersionHasBeenSet = true; m_currentVersion.assign(value); }
+
+    /**
+     * <p>The version of the stream whose retention period you want to change. To get
+     * the version, call either the <code>DescribeStream</code> or the
+     * <code>ListStreams</code> API.</p>
+     */
+    inline UpdateDataRetentionRequest& WithCurrentVersion(const Aws::String& value) { SetCurrentVersion(value); return *this;}
+
+    /**
+     * <p>The version of the stream whose retention period you want to change. To get
+     * the version, call either the <code>DescribeStream</code> or the
+     * <code>ListStreams</code> API.</p>
+     */
+    inline UpdateDataRetentionRequest& WithCurrentVersion(Aws::String&& value) { SetCurrentVersion(std::move(value)); return *this;}
+
+    /**
+     * <p>The version of the stream whose retention period you want to change. To get
+     * the version, call either the <code>DescribeStream</code> or the
+     * <code>ListStreams</code> API.</p>
+     */
+    inline UpdateDataRetentionRequest& WithCurrentVersion(const char* value) { SetCurrentVersion(value); return *this;}
+
+
+    /**
+     * <p>Indicates whether you want to increase or decrease the retention period.</p>
+     */
+    inline const UpdateDataRetentionOperation& GetOperation() const{ return m_operation; }
+
+    /**
+     * <p>Indicates whether you want to increase or decrease the retention period.</p>
+     */
+    inline bool OperationHasBeenSet() const { return m_operationHasBeenSet; }
+
+    /**
+     * <p>Indicates whether you want to increase or decrease the retention period.</p>
+     */
+    inline void SetOperation(const UpdateDataRetentionOperation& value) { m_operationHasBeenSet = true; m_operation = value; }
+
+    /**
+     * <p>Indicates whether you want to increase or decrease the retention period.</p>
+     */
+    inline void SetOperation(UpdateDataRetentionOperation&& value) { m_operationHasBeenSet = true; m_operation = std::move(value); }
+
+    /**
+     * <p>Indicates whether you want to increase or decrease the retention period.</p>
+     */
+    inline UpdateDataRetentionRequest& WithOperation(const UpdateDataRetentionOperation& value) { SetOperation(value); return *this;}
+
+    /**
+     * <p>Indicates whether you want to increase or decrease the retention period.</p>
+     */
+    inline UpdateDataRetentionRequest& WithOperation(UpdateDataRetentionOperation&& value) { SetOperation(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The retention period, in hours. The value you specify replaces the current
+     * value. The maximum value for this parameter is 87600 (ten years).</p>
+     */
+    inline int GetDataRetentionChangeInHours() const{ return m_dataRetentionChangeInHours; }
+
+    /**
+     * <p>The retention period, in hours. The value you specify replaces the current
+     * value. The maximum value for this parameter is 87600 (ten years).</p>
+     */
+    inline bool DataRetentionChangeInHoursHasBeenSet() const { return m_dataRetentionChangeInHoursHasBeenSet; }
+
+    /**
+     * <p>The retention period, in hours. The value you specify replaces the current
+     * value. The maximum value for this parameter is 87600 (ten years).</p>
+     */
+    inline void SetDataRetentionChangeInHours(int value) { m_dataRetentionChangeInHoursHasBeenSet = true; m_dataRetentionChangeInHours = value; }
+
+    /**
+     * <p>The retention period, in hours. The value you specify replaces the current
+     * value. The maximum value for this parameter is 87600 (ten years).</p>
+     */
+    inline UpdateDataRetentionRequest& WithDataRetentionChangeInHours(int value) { SetDataRetentionChangeInHours(value); return *this;}
+
+  private:
+
+    Aws::String m_streamName;
+    bool m_streamNameHasBeenSet;
+
+    Aws::String m_streamARN;
+    bool m_streamARNHasBeenSet;
+
+    Aws::String m_currentVersion;
+    bool m_currentVersionHasBeenSet;
+
+    UpdateDataRetentionOperation m_operation;
+    bool m_operationHasBeenSet;
+
+    int m_dataRetentionChangeInHours;
+    bool m_dataRetentionChangeInHoursHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

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

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/UpdateSignalingChannelRequest.h

@@ -0,0 +1,176 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/KinesisVideoRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/kinesisvideo/model/SingleMasterConfiguration.h>
+#include <utility>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_KINESISVIDEO_API UpdateSignalingChannelRequest : public KinesisVideoRequest
+  {
+  public:
+    UpdateSignalingChannelRequest();
+
+    // 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 "UpdateSignalingChannel"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel that you want to
+     * update.</p>
+     */
+    inline const Aws::String& GetChannelARN() const{ return m_channelARN; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel that you want to
+     * update.</p>
+     */
+    inline bool ChannelARNHasBeenSet() const { return m_channelARNHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel that you want to
+     * update.</p>
+     */
+    inline void SetChannelARN(const Aws::String& value) { m_channelARNHasBeenSet = true; m_channelARN = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel that you want to
+     * update.</p>
+     */
+    inline void SetChannelARN(Aws::String&& value) { m_channelARNHasBeenSet = true; m_channelARN = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel that you want to
+     * update.</p>
+     */
+    inline void SetChannelARN(const char* value) { m_channelARNHasBeenSet = true; m_channelARN.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel that you want to
+     * update.</p>
+     */
+    inline UpdateSignalingChannelRequest& WithChannelARN(const Aws::String& value) { SetChannelARN(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel that you want to
+     * update.</p>
+     */
+    inline UpdateSignalingChannelRequest& WithChannelARN(Aws::String&& value) { SetChannelARN(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the signaling channel that you want to
+     * update.</p>
+     */
+    inline UpdateSignalingChannelRequest& WithChannelARN(const char* value) { SetChannelARN(value); return *this;}
+
+
+    /**
+     * <p>The current version of the signaling channel that you want to update.</p>
+     */
+    inline const Aws::String& GetCurrentVersion() const{ return m_currentVersion; }
+
+    /**
+     * <p>The current version of the signaling channel that you want to update.</p>
+     */
+    inline bool CurrentVersionHasBeenSet() const { return m_currentVersionHasBeenSet; }
+
+    /**
+     * <p>The current version of the signaling channel that you want to update.</p>
+     */
+    inline void SetCurrentVersion(const Aws::String& value) { m_currentVersionHasBeenSet = true; m_currentVersion = value; }
+
+    /**
+     * <p>The current version of the signaling channel that you want to update.</p>
+     */
+    inline void SetCurrentVersion(Aws::String&& value) { m_currentVersionHasBeenSet = true; m_currentVersion = std::move(value); }
+
+    /**
+     * <p>The current version of the signaling channel that you want to update.</p>
+     */
+    inline void SetCurrentVersion(const char* value) { m_currentVersionHasBeenSet = true; m_currentVersion.assign(value); }
+
+    /**
+     * <p>The current version of the signaling channel that you want to update.</p>
+     */
+    inline UpdateSignalingChannelRequest& WithCurrentVersion(const Aws::String& value) { SetCurrentVersion(value); return *this;}
+
+    /**
+     * <p>The current version of the signaling channel that you want to update.</p>
+     */
+    inline UpdateSignalingChannelRequest& WithCurrentVersion(Aws::String&& value) { SetCurrentVersion(std::move(value)); return *this;}
+
+    /**
+     * <p>The current version of the signaling channel that you want to update.</p>
+     */
+    inline UpdateSignalingChannelRequest& WithCurrentVersion(const char* value) { SetCurrentVersion(value); return *this;}
+
+
+    /**
+     * <p>The structure containing the configuration for the <code>SINGLE_MASTER</code>
+     * type of the signaling channel that you want to update. </p>
+     */
+    inline const SingleMasterConfiguration& GetSingleMasterConfiguration() const{ return m_singleMasterConfiguration; }
+
+    /**
+     * <p>The structure containing the configuration for the <code>SINGLE_MASTER</code>
+     * type of the signaling channel that you want to update. </p>
+     */
+    inline bool SingleMasterConfigurationHasBeenSet() const { return m_singleMasterConfigurationHasBeenSet; }
+
+    /**
+     * <p>The structure containing the configuration for the <code>SINGLE_MASTER</code>
+     * type of the signaling channel that you want to update. </p>
+     */
+    inline void SetSingleMasterConfiguration(const SingleMasterConfiguration& value) { m_singleMasterConfigurationHasBeenSet = true; m_singleMasterConfiguration = value; }
+
+    /**
+     * <p>The structure containing the configuration for the <code>SINGLE_MASTER</code>
+     * type of the signaling channel that you want to update. </p>
+     */
+    inline void SetSingleMasterConfiguration(SingleMasterConfiguration&& value) { m_singleMasterConfigurationHasBeenSet = true; m_singleMasterConfiguration = std::move(value); }
+
+    /**
+     * <p>The structure containing the configuration for the <code>SINGLE_MASTER</code>
+     * type of the signaling channel that you want to update. </p>
+     */
+    inline UpdateSignalingChannelRequest& WithSingleMasterConfiguration(const SingleMasterConfiguration& value) { SetSingleMasterConfiguration(value); return *this;}
+
+    /**
+     * <p>The structure containing the configuration for the <code>SINGLE_MASTER</code>
+     * type of the signaling channel that you want to update. </p>
+     */
+    inline UpdateSignalingChannelRequest& WithSingleMasterConfiguration(SingleMasterConfiguration&& value) { SetSingleMasterConfiguration(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_channelARN;
+    bool m_channelARNHasBeenSet;
+
+    Aws::String m_currentVersion;
+    bool m_currentVersionHasBeenSet;
+
+    SingleMasterConfiguration m_singleMasterConfiguration;
+    bool m_singleMasterConfigurationHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

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

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/model/UpdateStreamRequest.h

@@ -0,0 +1,355 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/kinesisvideo/KinesisVideo_EXPORTS.h>
+#include <aws/kinesisvideo/KinesisVideoRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace KinesisVideo
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_KINESISVIDEO_API UpdateStreamRequest : public KinesisVideoRequest
+  {
+  public:
+    UpdateStreamRequest();
+
+    // 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 "UpdateStream"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The name of the stream whose metadata you want to update.</p> <p>The stream
+     * name is an identifier for the stream, and must be unique for each account and
+     * region.</p>
+     */
+    inline const Aws::String& GetStreamName() const{ return m_streamName; }
+
+    /**
+     * <p>The name of the stream whose metadata you want to update.</p> <p>The stream
+     * name is an identifier for the stream, and must be unique for each account and
+     * region.</p>
+     */
+    inline bool StreamNameHasBeenSet() const { return m_streamNameHasBeenSet; }
+
+    /**
+     * <p>The name of the stream whose metadata you want to update.</p> <p>The stream
+     * name is an identifier for the stream, and must be unique for each account and
+     * region.</p>
+     */
+    inline void SetStreamName(const Aws::String& value) { m_streamNameHasBeenSet = true; m_streamName = value; }
+
+    /**
+     * <p>The name of the stream whose metadata you want to update.</p> <p>The stream
+     * name is an identifier for the stream, and must be unique for each account and
+     * region.</p>
+     */
+    inline void SetStreamName(Aws::String&& value) { m_streamNameHasBeenSet = true; m_streamName = std::move(value); }
+
+    /**
+     * <p>The name of the stream whose metadata you want to update.</p> <p>The stream
+     * name is an identifier for the stream, and must be unique for each account and
+     * region.</p>
+     */
+    inline void SetStreamName(const char* value) { m_streamNameHasBeenSet = true; m_streamName.assign(value); }
+
+    /**
+     * <p>The name of the stream whose metadata you want to update.</p> <p>The stream
+     * name is an identifier for the stream, and must be unique for each account and
+     * region.</p>
+     */
+    inline UpdateStreamRequest& WithStreamName(const Aws::String& value) { SetStreamName(value); return *this;}
+
+    /**
+     * <p>The name of the stream whose metadata you want to update.</p> <p>The stream
+     * name is an identifier for the stream, and must be unique for each account and
+     * region.</p>
+     */
+    inline UpdateStreamRequest& WithStreamName(Aws::String&& value) { SetStreamName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the stream whose metadata you want to update.</p> <p>The stream
+     * name is an identifier for the stream, and must be unique for each account and
+     * region.</p>
+     */
+    inline UpdateStreamRequest& WithStreamName(const char* value) { SetStreamName(value); return *this;}
+
+
+    /**
+     * <p>The ARN of the stream whose metadata you want to update.</p>
+     */
+    inline const Aws::String& GetStreamARN() const{ return m_streamARN; }
+
+    /**
+     * <p>The ARN of the stream whose metadata you want to update.</p>
+     */
+    inline bool StreamARNHasBeenSet() const { return m_streamARNHasBeenSet; }
+
+    /**
+     * <p>The ARN of the stream whose metadata you want to update.</p>
+     */
+    inline void SetStreamARN(const Aws::String& value) { m_streamARNHasBeenSet = true; m_streamARN = value; }
+
+    /**
+     * <p>The ARN of the stream whose metadata you want to update.</p>
+     */
+    inline void SetStreamARN(Aws::String&& value) { m_streamARNHasBeenSet = true; m_streamARN = std::move(value); }
+
+    /**
+     * <p>The ARN of the stream whose metadata you want to update.</p>
+     */
+    inline void SetStreamARN(const char* value) { m_streamARNHasBeenSet = true; m_streamARN.assign(value); }
+
+    /**
+     * <p>The ARN of the stream whose metadata you want to update.</p>
+     */
+    inline UpdateStreamRequest& WithStreamARN(const Aws::String& value) { SetStreamARN(value); return *this;}
+
+    /**
+     * <p>The ARN of the stream whose metadata you want to update.</p>
+     */
+    inline UpdateStreamRequest& WithStreamARN(Aws::String&& value) { SetStreamARN(std::move(value)); return *this;}
+
+    /**
+     * <p>The ARN of the stream whose metadata you want to update.</p>
+     */
+    inline UpdateStreamRequest& WithStreamARN(const char* value) { SetStreamARN(value); return *this;}
+
+
+    /**
+     * <p>The version of the stream whose metadata you want to update.</p>
+     */
+    inline const Aws::String& GetCurrentVersion() const{ return m_currentVersion; }
+
+    /**
+     * <p>The version of the stream whose metadata you want to update.</p>
+     */
+    inline bool CurrentVersionHasBeenSet() const { return m_currentVersionHasBeenSet; }
+
+    /**
+     * <p>The version of the stream whose metadata you want to update.</p>
+     */
+    inline void SetCurrentVersion(const Aws::String& value) { m_currentVersionHasBeenSet = true; m_currentVersion = value; }
+
+    /**
+     * <p>The version of the stream whose metadata you want to update.</p>
+     */
+    inline void SetCurrentVersion(Aws::String&& value) { m_currentVersionHasBeenSet = true; m_currentVersion = std::move(value); }
+
+    /**
+     * <p>The version of the stream whose metadata you want to update.</p>
+     */
+    inline void SetCurrentVersion(const char* value) { m_currentVersionHasBeenSet = true; m_currentVersion.assign(value); }
+
+    /**
+     * <p>The version of the stream whose metadata you want to update.</p>
+     */
+    inline UpdateStreamRequest& WithCurrentVersion(const Aws::String& value) { SetCurrentVersion(value); return *this;}
+
+    /**
+     * <p>The version of the stream whose metadata you want to update.</p>
+     */
+    inline UpdateStreamRequest& WithCurrentVersion(Aws::String&& value) { SetCurrentVersion(std::move(value)); return *this;}
+
+    /**
+     * <p>The version of the stream whose metadata you want to update.</p>
+     */
+    inline UpdateStreamRequest& WithCurrentVersion(const char* value) { SetCurrentVersion(value); return *this;}
+
+
+    /**
+     * <p>The name of the device that is writing to the stream. </p>  <p> In the
+     * current implementation, Kinesis Video Streams does not use this name. </p>
+     * 
+     */
+    inline const Aws::String& GetDeviceName() const{ return m_deviceName; }
+
+    /**
+     * <p>The name of the device that is writing to the stream. </p>  <p> In the
+     * current implementation, Kinesis Video Streams does not use this name. </p>
+     * 
+     */
+    inline bool DeviceNameHasBeenSet() const { return m_deviceNameHasBeenSet; }
+
+    /**
+     * <p>The name of the device that is writing to the stream. </p>  <p> In the
+     * current implementation, Kinesis Video Streams does not use this name. </p>
+     * 
+     */
+    inline void SetDeviceName(const Aws::String& value) { m_deviceNameHasBeenSet = true; m_deviceName = value; }
+
+    /**
+     * <p>The name of the device that is writing to the stream. </p>  <p> In the
+     * current implementation, Kinesis Video Streams does not use this name. </p>
+     * 
+     */
+    inline void SetDeviceName(Aws::String&& value) { m_deviceNameHasBeenSet = true; m_deviceName = std::move(value); }
+
+    /**
+     * <p>The name of the device that is writing to the stream. </p>  <p> In the
+     * current implementation, Kinesis Video Streams does not use this name. </p>
+     * 
+     */
+    inline void SetDeviceName(const char* value) { m_deviceNameHasBeenSet = true; m_deviceName.assign(value); }
+
+    /**
+     * <p>The name of the device that is writing to the stream. </p>  <p> In the
+     * current implementation, Kinesis Video Streams does not use this name. </p>
+     * 
+     */
+    inline UpdateStreamRequest& WithDeviceName(const Aws::String& value) { SetDeviceName(value); return *this;}
+
+    /**
+     * <p>The name of the device that is writing to the stream. </p>  <p> In the
+     * current implementation, Kinesis Video Streams does not use this name. </p>
+     * 
+     */
+    inline UpdateStreamRequest& WithDeviceName(Aws::String&& value) { SetDeviceName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the device that is writing to the stream. </p>  <p> In the
+     * current implementation, Kinesis Video Streams does not use this name. </p>
+     * 
+     */
+    inline UpdateStreamRequest& WithDeviceName(const char* value) { SetDeviceName(value); return *this;}
+
+
+    /**
+     * <p>The stream's media type. Use <code>MediaType</code> to specify the type of
+     * content that the stream contains to the consumers of the stream. For more
+     * information about media types, see <a
+     * href="http://www.iana.org/assignments/media-types/media-types.xhtml">Media
+     * Types</a>. If you choose to specify the <code>MediaType</code>, see <a
+     * href="https://tools.ietf.org/html/rfc6838#section-4.2">Naming
+     * Requirements</a>.</p> <p>To play video on the console, you must specify the
+     * correct video type. For example, if the video in the stream is H.264, specify
+     * <code>video/h264</code> as the <code>MediaType</code>.</p>
+     */
+    inline const Aws::String& GetMediaType() const{ return m_mediaType; }
+
+    /**
+     * <p>The stream's media type. Use <code>MediaType</code> to specify the type of
+     * content that the stream contains to the consumers of the stream. For more
+     * information about media types, see <a
+     * href="http://www.iana.org/assignments/media-types/media-types.xhtml">Media
+     * Types</a>. If you choose to specify the <code>MediaType</code>, see <a
+     * href="https://tools.ietf.org/html/rfc6838#section-4.2">Naming
+     * Requirements</a>.</p> <p>To play video on the console, you must specify the
+     * correct video type. For example, if the video in the stream is H.264, specify
+     * <code>video/h264</code> as the <code>MediaType</code>.</p>
+     */
+    inline bool MediaTypeHasBeenSet() const { return m_mediaTypeHasBeenSet; }
+
+    /**
+     * <p>The stream's media type. Use <code>MediaType</code> to specify the type of
+     * content that the stream contains to the consumers of the stream. For more
+     * information about media types, see <a
+     * href="http://www.iana.org/assignments/media-types/media-types.xhtml">Media
+     * Types</a>. If you choose to specify the <code>MediaType</code>, see <a
+     * href="https://tools.ietf.org/html/rfc6838#section-4.2">Naming
+     * Requirements</a>.</p> <p>To play video on the console, you must specify the
+     * correct video type. For example, if the video in the stream is H.264, specify
+     * <code>video/h264</code> as the <code>MediaType</code>.</p>
+     */
+    inline void SetMediaType(const Aws::String& value) { m_mediaTypeHasBeenSet = true; m_mediaType = value; }
+
+    /**
+     * <p>The stream's media type. Use <code>MediaType</code> to specify the type of
+     * content that the stream contains to the consumers of the stream. For more
+     * information about media types, see <a
+     * href="http://www.iana.org/assignments/media-types/media-types.xhtml">Media
+     * Types</a>. If you choose to specify the <code>MediaType</code>, see <a
+     * href="https://tools.ietf.org/html/rfc6838#section-4.2">Naming
+     * Requirements</a>.</p> <p>To play video on the console, you must specify the
+     * correct video type. For example, if the video in the stream is H.264, specify
+     * <code>video/h264</code> as the <code>MediaType</code>.</p>
+     */
+    inline void SetMediaType(Aws::String&& value) { m_mediaTypeHasBeenSet = true; m_mediaType = std::move(value); }
+
+    /**
+     * <p>The stream's media type. Use <code>MediaType</code> to specify the type of
+     * content that the stream contains to the consumers of the stream. For more
+     * information about media types, see <a
+     * href="http://www.iana.org/assignments/media-types/media-types.xhtml">Media
+     * Types</a>. If you choose to specify the <code>MediaType</code>, see <a
+     * href="https://tools.ietf.org/html/rfc6838#section-4.2">Naming
+     * Requirements</a>.</p> <p>To play video on the console, you must specify the
+     * correct video type. For example, if the video in the stream is H.264, specify
+     * <code>video/h264</code> as the <code>MediaType</code>.</p>
+     */
+    inline void SetMediaType(const char* value) { m_mediaTypeHasBeenSet = true; m_mediaType.assign(value); }
+
+    /**
+     * <p>The stream's media type. Use <code>MediaType</code> to specify the type of
+     * content that the stream contains to the consumers of the stream. For more
+     * information about media types, see <a
+     * href="http://www.iana.org/assignments/media-types/media-types.xhtml">Media
+     * Types</a>. If you choose to specify the <code>MediaType</code>, see <a
+     * href="https://tools.ietf.org/html/rfc6838#section-4.2">Naming
+     * Requirements</a>.</p> <p>To play video on the console, you must specify the
+     * correct video type. For example, if the video in the stream is H.264, specify
+     * <code>video/h264</code> as the <code>MediaType</code>.</p>
+     */
+    inline UpdateStreamRequest& WithMediaType(const Aws::String& value) { SetMediaType(value); return *this;}
+
+    /**
+     * <p>The stream's media type. Use <code>MediaType</code> to specify the type of
+     * content that the stream contains to the consumers of the stream. For more
+     * information about media types, see <a
+     * href="http://www.iana.org/assignments/media-types/media-types.xhtml">Media
+     * Types</a>. If you choose to specify the <code>MediaType</code>, see <a
+     * href="https://tools.ietf.org/html/rfc6838#section-4.2">Naming
+     * Requirements</a>.</p> <p>To play video on the console, you must specify the
+     * correct video type. For example, if the video in the stream is H.264, specify
+     * <code>video/h264</code> as the <code>MediaType</code>.</p>
+     */
+    inline UpdateStreamRequest& WithMediaType(Aws::String&& value) { SetMediaType(std::move(value)); return *this;}
+
+    /**
+     * <p>The stream's media type. Use <code>MediaType</code> to specify the type of
+     * content that the stream contains to the consumers of the stream. For more
+     * information about media types, see <a
+     * href="http://www.iana.org/assignments/media-types/media-types.xhtml">Media
+     * Types</a>. If you choose to specify the <code>MediaType</code>, see <a
+     * href="https://tools.ietf.org/html/rfc6838#section-4.2">Naming
+     * Requirements</a>.</p> <p>To play video on the console, you must specify the
+     * correct video type. For example, if the video in the stream is H.264, specify
+     * <code>video/h264</code> as the <code>MediaType</code>.</p>
+     */
+    inline UpdateStreamRequest& WithMediaType(const char* value) { SetMediaType(value); return *this;}
+
+  private:
+
+    Aws::String m_streamName;
+    bool m_streamNameHasBeenSet;
+
+    Aws::String m_streamARN;
+    bool m_streamARNHasBeenSet;
+
+    Aws::String m_currentVersion;
+    bool m_currentVersionHasBeenSet;
+
+    Aws::String m_deviceName;
+    bool m_deviceNameHasBeenSet;
+
+    Aws::String m_mediaType;
+    bool m_mediaTypeHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace KinesisVideo
+} // namespace Aws

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