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

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/CMakeLists.txt

@@ -0,0 +1,76 @@
+add_project(aws-cpp-sdk-ivs "C++ SDK for the AWS ivs service" aws-cpp-sdk-core)
+
+file(GLOB AWS_IVS_HEADERS
+    "include/aws/ivs/*.h"
+)
+
+file(GLOB AWS_IVS_MODEL_HEADERS
+    "include/aws/ivs/model/*.h"
+)
+
+file(GLOB AWS_IVS_SOURCE
+    "source/*.cpp"
+)
+
+file(GLOB AWS_IVS_MODEL_SOURCE
+    "source/model/*.cpp"
+)
+
+file(GLOB IVS_UNIFIED_HEADERS
+    ${AWS_IVS_HEADERS}
+    ${AWS_IVS_MODEL_HEADERS}
+)
+
+file(GLOB IVS_UNITY_SRC
+    ${AWS_IVS_SOURCE}
+    ${AWS_IVS_MODEL_SOURCE}
+)
+
+if(ENABLE_UNITY_BUILD)
+    enable_unity_build("IVS" IVS_UNITY_SRC)
+endif()
+
+file(GLOB IVS_SRC
+    ${IVS_UNIFIED_HEADERS}
+    ${IVS_UNITY_SRC}
+)
+
+if(WIN32)
+    #if we are compiling for visual studio, create a sane directory tree.
+    if(MSVC)
+        source_group("Header Files\\aws\\ivs" FILES ${AWS_IVS_HEADERS})
+        source_group("Header Files\\aws\\ivs\\model" FILES ${AWS_IVS_MODEL_HEADERS})
+        source_group("Source Files" FILES ${AWS_IVS_SOURCE})
+        source_group("Source Files\\model" FILES ${AWS_IVS_MODEL_SOURCE})
+    endif(MSVC)
+endif()
+
+set(IVS_INCLUDES
+    "${CMAKE_CURRENT_SOURCE_DIR}/include/"
+)
+
+add_library(${PROJECT_NAME} ${IVS_SRC})
+add_library(AWS::${PROJECT_NAME} ALIAS ${PROJECT_NAME})
+
+set_compiler_flags(${PROJECT_NAME})
+set_compiler_warnings(${PROJECT_NAME})
+
+if(USE_WINDOWS_DLL_SEMANTICS AND BUILD_SHARED_LIBS)
+    target_compile_definitions(${PROJECT_NAME} PRIVATE "AWS_IVS_EXPORTS")
+endif()
+
+target_include_directories(${PROJECT_NAME} PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>)
+
+target_link_libraries(${PROJECT_NAME} PRIVATE ${PLATFORM_DEP_LIBS} ${PROJECT_LIBS})
+
+
+setup_install()
+
+install (FILES ${AWS_IVS_HEADERS} DESTINATION ${INCLUDE_DIRECTORY}/aws/ivs)
+install (FILES ${AWS_IVS_MODEL_HEADERS} DESTINATION ${INCLUDE_DIRECTORY}/aws/ivs/model)
+
+do_packaging()
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/IVSClient.h

@@ -0,0 +1,985 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSErrors.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/ivs/model/BatchGetChannelResult.h>
+#include <aws/ivs/model/BatchGetStreamKeyResult.h>
+#include <aws/ivs/model/CreateChannelResult.h>
+#include <aws/ivs/model/CreateStreamKeyResult.h>
+#include <aws/ivs/model/DeletePlaybackKeyPairResult.h>
+#include <aws/ivs/model/GetChannelResult.h>
+#include <aws/ivs/model/GetPlaybackKeyPairResult.h>
+#include <aws/ivs/model/GetStreamResult.h>
+#include <aws/ivs/model/GetStreamKeyResult.h>
+#include <aws/ivs/model/ImportPlaybackKeyPairResult.h>
+#include <aws/ivs/model/ListChannelsResult.h>
+#include <aws/ivs/model/ListPlaybackKeyPairsResult.h>
+#include <aws/ivs/model/ListStreamKeysResult.h>
+#include <aws/ivs/model/ListStreamsResult.h>
+#include <aws/ivs/model/ListTagsForResourceResult.h>
+#include <aws/ivs/model/StopStreamResult.h>
+#include <aws/ivs/model/TagResourceResult.h>
+#include <aws/ivs/model/UntagResourceResult.h>
+#include <aws/ivs/model/UpdateChannelResult.h>
+#include <aws/core/NoResult.h>
+#include <aws/core/client/AsyncCallerContext.h>
+#include <aws/core/http/HttpTypes.h>
+#include <future>
+#include <functional>
+
+namespace Aws
+{
+
+namespace Http
+{
+  class HttpClient;
+  class HttpClientFactory;
+} // namespace Http
+
+namespace Utils
+{
+  template< typename R, typename E> class Outcome;
+namespace Threading
+{
+  class Executor;
+} // namespace Threading
+} // namespace Utils
+
+namespace Auth
+{
+  class AWSCredentials;
+  class AWSCredentialsProvider;
+} // namespace Auth
+
+namespace Client
+{
+  class RetryStrategy;
+} // namespace Client
+
+namespace IVS
+{
+
+namespace Model
+{
+        class BatchGetChannelRequest;
+        class BatchGetStreamKeyRequest;
+        class CreateChannelRequest;
+        class CreateStreamKeyRequest;
+        class DeleteChannelRequest;
+        class DeletePlaybackKeyPairRequest;
+        class DeleteStreamKeyRequest;
+        class GetChannelRequest;
+        class GetPlaybackKeyPairRequest;
+        class GetStreamRequest;
+        class GetStreamKeyRequest;
+        class ImportPlaybackKeyPairRequest;
+        class ListChannelsRequest;
+        class ListPlaybackKeyPairsRequest;
+        class ListStreamKeysRequest;
+        class ListStreamsRequest;
+        class ListTagsForResourceRequest;
+        class PutMetadataRequest;
+        class StopStreamRequest;
+        class TagResourceRequest;
+        class UntagResourceRequest;
+        class UpdateChannelRequest;
+
+        typedef Aws::Utils::Outcome<BatchGetChannelResult, IVSError> BatchGetChannelOutcome;
+        typedef Aws::Utils::Outcome<BatchGetStreamKeyResult, IVSError> BatchGetStreamKeyOutcome;
+        typedef Aws::Utils::Outcome<CreateChannelResult, IVSError> CreateChannelOutcome;
+        typedef Aws::Utils::Outcome<CreateStreamKeyResult, IVSError> CreateStreamKeyOutcome;
+        typedef Aws::Utils::Outcome<Aws::NoResult, IVSError> DeleteChannelOutcome;
+        typedef Aws::Utils::Outcome<DeletePlaybackKeyPairResult, IVSError> DeletePlaybackKeyPairOutcome;
+        typedef Aws::Utils::Outcome<Aws::NoResult, IVSError> DeleteStreamKeyOutcome;
+        typedef Aws::Utils::Outcome<GetChannelResult, IVSError> GetChannelOutcome;
+        typedef Aws::Utils::Outcome<GetPlaybackKeyPairResult, IVSError> GetPlaybackKeyPairOutcome;
+        typedef Aws::Utils::Outcome<GetStreamResult, IVSError> GetStreamOutcome;
+        typedef Aws::Utils::Outcome<GetStreamKeyResult, IVSError> GetStreamKeyOutcome;
+        typedef Aws::Utils::Outcome<ImportPlaybackKeyPairResult, IVSError> ImportPlaybackKeyPairOutcome;
+        typedef Aws::Utils::Outcome<ListChannelsResult, IVSError> ListChannelsOutcome;
+        typedef Aws::Utils::Outcome<ListPlaybackKeyPairsResult, IVSError> ListPlaybackKeyPairsOutcome;
+        typedef Aws::Utils::Outcome<ListStreamKeysResult, IVSError> ListStreamKeysOutcome;
+        typedef Aws::Utils::Outcome<ListStreamsResult, IVSError> ListStreamsOutcome;
+        typedef Aws::Utils::Outcome<ListTagsForResourceResult, IVSError> ListTagsForResourceOutcome;
+        typedef Aws::Utils::Outcome<Aws::NoResult, IVSError> PutMetadataOutcome;
+        typedef Aws::Utils::Outcome<StopStreamResult, IVSError> StopStreamOutcome;
+        typedef Aws::Utils::Outcome<TagResourceResult, IVSError> TagResourceOutcome;
+        typedef Aws::Utils::Outcome<UntagResourceResult, IVSError> UntagResourceOutcome;
+        typedef Aws::Utils::Outcome<UpdateChannelResult, IVSError> UpdateChannelOutcome;
+
+        typedef std::future<BatchGetChannelOutcome> BatchGetChannelOutcomeCallable;
+        typedef std::future<BatchGetStreamKeyOutcome> BatchGetStreamKeyOutcomeCallable;
+        typedef std::future<CreateChannelOutcome> CreateChannelOutcomeCallable;
+        typedef std::future<CreateStreamKeyOutcome> CreateStreamKeyOutcomeCallable;
+        typedef std::future<DeleteChannelOutcome> DeleteChannelOutcomeCallable;
+        typedef std::future<DeletePlaybackKeyPairOutcome> DeletePlaybackKeyPairOutcomeCallable;
+        typedef std::future<DeleteStreamKeyOutcome> DeleteStreamKeyOutcomeCallable;
+        typedef std::future<GetChannelOutcome> GetChannelOutcomeCallable;
+        typedef std::future<GetPlaybackKeyPairOutcome> GetPlaybackKeyPairOutcomeCallable;
+        typedef std::future<GetStreamOutcome> GetStreamOutcomeCallable;
+        typedef std::future<GetStreamKeyOutcome> GetStreamKeyOutcomeCallable;
+        typedef std::future<ImportPlaybackKeyPairOutcome> ImportPlaybackKeyPairOutcomeCallable;
+        typedef std::future<ListChannelsOutcome> ListChannelsOutcomeCallable;
+        typedef std::future<ListPlaybackKeyPairsOutcome> ListPlaybackKeyPairsOutcomeCallable;
+        typedef std::future<ListStreamKeysOutcome> ListStreamKeysOutcomeCallable;
+        typedef std::future<ListStreamsOutcome> ListStreamsOutcomeCallable;
+        typedef std::future<ListTagsForResourceOutcome> ListTagsForResourceOutcomeCallable;
+        typedef std::future<PutMetadataOutcome> PutMetadataOutcomeCallable;
+        typedef std::future<StopStreamOutcome> StopStreamOutcomeCallable;
+        typedef std::future<TagResourceOutcome> TagResourceOutcomeCallable;
+        typedef std::future<UntagResourceOutcome> UntagResourceOutcomeCallable;
+        typedef std::future<UpdateChannelOutcome> UpdateChannelOutcomeCallable;
+} // namespace Model
+
+  class IVSClient;
+
+    typedef std::function<void(const IVSClient*, const Model::BatchGetChannelRequest&, const Model::BatchGetChannelOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > BatchGetChannelResponseReceivedHandler;
+    typedef std::function<void(const IVSClient*, const Model::BatchGetStreamKeyRequest&, const Model::BatchGetStreamKeyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > BatchGetStreamKeyResponseReceivedHandler;
+    typedef std::function<void(const IVSClient*, const Model::CreateChannelRequest&, const Model::CreateChannelOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateChannelResponseReceivedHandler;
+    typedef std::function<void(const IVSClient*, const Model::CreateStreamKeyRequest&, const Model::CreateStreamKeyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateStreamKeyResponseReceivedHandler;
+    typedef std::function<void(const IVSClient*, const Model::DeleteChannelRequest&, const Model::DeleteChannelOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteChannelResponseReceivedHandler;
+    typedef std::function<void(const IVSClient*, const Model::DeletePlaybackKeyPairRequest&, const Model::DeletePlaybackKeyPairOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeletePlaybackKeyPairResponseReceivedHandler;
+    typedef std::function<void(const IVSClient*, const Model::DeleteStreamKeyRequest&, const Model::DeleteStreamKeyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteStreamKeyResponseReceivedHandler;
+    typedef std::function<void(const IVSClient*, const Model::GetChannelRequest&, const Model::GetChannelOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetChannelResponseReceivedHandler;
+    typedef std::function<void(const IVSClient*, const Model::GetPlaybackKeyPairRequest&, const Model::GetPlaybackKeyPairOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetPlaybackKeyPairResponseReceivedHandler;
+    typedef std::function<void(const IVSClient*, const Model::GetStreamRequest&, const Model::GetStreamOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetStreamResponseReceivedHandler;
+    typedef std::function<void(const IVSClient*, const Model::GetStreamKeyRequest&, const Model::GetStreamKeyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetStreamKeyResponseReceivedHandler;
+    typedef std::function<void(const IVSClient*, const Model::ImportPlaybackKeyPairRequest&, const Model::ImportPlaybackKeyPairOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ImportPlaybackKeyPairResponseReceivedHandler;
+    typedef std::function<void(const IVSClient*, const Model::ListChannelsRequest&, const Model::ListChannelsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListChannelsResponseReceivedHandler;
+    typedef std::function<void(const IVSClient*, const Model::ListPlaybackKeyPairsRequest&, const Model::ListPlaybackKeyPairsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListPlaybackKeyPairsResponseReceivedHandler;
+    typedef std::function<void(const IVSClient*, const Model::ListStreamKeysRequest&, const Model::ListStreamKeysOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListStreamKeysResponseReceivedHandler;
+    typedef std::function<void(const IVSClient*, const Model::ListStreamsRequest&, const Model::ListStreamsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListStreamsResponseReceivedHandler;
+    typedef std::function<void(const IVSClient*, const Model::ListTagsForResourceRequest&, const Model::ListTagsForResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTagsForResourceResponseReceivedHandler;
+    typedef std::function<void(const IVSClient*, const Model::PutMetadataRequest&, const Model::PutMetadataOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutMetadataResponseReceivedHandler;
+    typedef std::function<void(const IVSClient*, const Model::StopStreamRequest&, const Model::StopStreamOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StopStreamResponseReceivedHandler;
+    typedef std::function<void(const IVSClient*, const Model::TagResourceRequest&, const Model::TagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > TagResourceResponseReceivedHandler;
+    typedef std::function<void(const IVSClient*, const Model::UntagResourceRequest&, const Model::UntagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UntagResourceResponseReceivedHandler;
+    typedef std::function<void(const IVSClient*, const Model::UpdateChannelRequest&, const Model::UpdateChannelOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateChannelResponseReceivedHandler;
+
+  /**
+   * <p> <b>Introduction</b> </p> <p>The Amazon Interactive Video Service (IVS) API
+   * is REST compatible, using a standard HTTP API and an <a
+   * href="http://aws.amazon.com/sns">AWS SNS</a> event stream for responses. JSON is
+   * used for both requests and responses, including errors.</p> <p>The API is an AWS
+   * regional service, currently in these regions: us-west-2, us-east-1, and
+   * eu-west-1.</p> <p> <i> <b>All API request parameters and URLs are case
+   * sensitive. </b> </i> </p> <p>For a summary of notable documentation changes in
+   * each release, see <a
+   * href="https://docs.aws.amazon.com/ivs/latest/userguide/doc-history.html">
+   * Document History</a>.</p> <p> <b>Service Endpoints</b> </p> <p>The following are
+   * the Amazon IVS service endpoints (all HTTPS): </p> <p>Region name: US West
+   * (Oregon)</p> <ul> <li> <p>Region: <code>us-west-2</code> </p> </li> <li>
+   * <p>Endpoint: <code>ivs.us-west-2.amazonaws.com</code> </p> </li> </ul> <p>Region
+   * name: US East (Virginia)</p> <ul> <li> <p>Region: <code>us-east-1</code> </p>
+   * </li> <li> <p>Endpoint: <code>ivs.us-east-1.amazonaws.com</code> </p> </li>
+   * </ul> <p>Region name: EU West (Dublin)</p> <ul> <li> <p>Region:
+   * <code>eu-west-1</code> </p> </li> <li> <p>Endpoint:
+   * <code>ivs.eu-west-1.amazonaws.com</code> </p> </li> </ul> <p> <b>Allowed Header
+   * Values</b> </p> <ul> <li> <p> <code> <b>Accept:</b> </code> application/json</p>
+   * </li> <li> <p> <code> <b>Accept-Encoding:</b> </code> gzip, deflate</p> </li>
+   * <li> <p> <code> <b>Content-Type:</b> </code>application/json</p> </li> </ul> <p>
+   * <b>Resources</b> </p> <p>The following resources contain information about your
+   * IVS live stream (see <a
+   * href="https://docs.aws.amazon.com/ivs/latest/userguide/GSIVS.html"> Getting
+   * Started with Amazon IVS</a>):</p> <ul> <li> <p>Channel — Stores configuration
+   * data related to your live stream. You first create a channel and then use the
+   * channel’s stream key to start your live stream. See the Channel endpoints for
+   * more information. </p> </li> <li> <p>Stream key — An identifier assigned by
+   * Amazon IVS when you create a channel, which is then used to authorize streaming.
+   * See the StreamKey endpoints for more information. <i> <b>Treat the stream key
+   * like a secret, since it allows anyone to stream to the channel.</b> </i> </p>
+   * </li> <li> <p>Playback key pair — Video playback may be restricted using
+   * playback-authorization tokens, which use public-key encryption. A playback key
+   * pair is the public-private pair of keys used to sign and validate the
+   * playback-authorization token. See the PlaybackKeyPair endpoints for more
+   * information.</p> </li> </ul> <p> <b>Tagging</b> </p> <p>A <i>tag</i> is a
+   * metadata label that you assign to an AWS resource. A tag comprises a <i>key</i>
+   * and a <i>value</i>, both set by you. For example, you might set a tag as
+   * <code>topic:nature</code> to label a particular video category. See <a
+   * href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging
+   * AWS Resources</a> for more information, including restrictions that apply to
+   * tags.</p> <p>Tags can help you identify and organize your AWS resources. For
+   * example, you can use the same tag for different resources to indicate that they
+   * are related. You can also use tags to manage access (see <a
+   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html"> Access
+   * Tags</a>). </p> <p>The Amazon IVS API has these tag-related endpoints:
+   * <a>TagResource</a>, <a>UntagResource</a>, and <a>ListTagsForResource</a>. The
+   * following resources support tagging: Channels, Stream Keys, and Playback Key
+   * Pairs.</p> <p> <b>Channel Endpoints</b> </p> <ul> <li> <p> <a>CreateChannel</a>
+   * — Creates a new channel and an associated stream key to start streaming.</p>
+   * </li> <li> <p> <a>GetChannel</a> — Gets the channel configuration for the
+   * specified channel ARN (Amazon Resource Name).</p> </li> <li> <p>
+   * <a>BatchGetChannel</a> — Performs <a>GetChannel</a> on multiple ARNs
+   * simultaneously.</p> </li> <li> <p> <a>ListChannels</a> — Gets summary
+   * information about all channels in your account, in the AWS region where the API
+   * request is processed. This list can be filtered to match a specified string.</p>
+   * </li> <li> <p> <a>UpdateChannel</a> — Updates a channel's configuration. This
+   * does not affect an ongoing stream of this channel. You must stop and restart the
+   * stream for the changes to take effect.</p> </li> <li> <p> <a>DeleteChannel</a> —
+   * Deletes the specified channel.</p> </li> </ul> <p> <b>StreamKey Endpoints</b>
+   * </p> <ul> <li> <p> <a>CreateStreamKey</a> — Creates a stream key, used to
+   * initiate a stream, for the specified channel ARN.</p> </li> <li> <p>
+   * <a>GetStreamKey</a> — Gets stream key information for the specified ARN.</p>
+   * </li> <li> <p> <a>BatchGetStreamKey</a> — Performs <a>GetStreamKey</a> on
+   * multiple ARNs simultaneously.</p> </li> <li> <p> <a>ListStreamKeys</a> — Gets
+   * summary information about stream keys for the specified channel.</p> </li> <li>
+   * <p> <a>DeleteStreamKey</a> — Deletes the stream key for the specified ARN, so it
+   * can no longer be used to stream.</p> </li> </ul> <p> <b>Stream Endpoints</b>
+   * </p> <ul> <li> <p> <a>GetStream</a> — Gets information about the active (live)
+   * stream on a specified channel.</p> </li> <li> <p> <a>ListStreams</a> — Gets
+   * summary information about live streams in your account, in the AWS region where
+   * the API request is processed.</p> </li> <li> <p> <a>StopStream</a> — Disconnects
+   * the incoming RTMPS stream for the specified channel. Can be used in conjunction
+   * with <a>DeleteStreamKey</a> to prevent further streaming to a channel.</p> </li>
+   * <li> <p> <a>PutMetadata</a> — Inserts metadata into an RTMPS stream for the
+   * specified channel. A maximum of 5 requests per second per channel is allowed,
+   * each with a maximum 1KB payload.</p> </li> </ul> <p> <b>PlaybackKeyPair
+   * Endpoints</b> </p> <ul> <li> <p> <a>ImportPlaybackKeyPair</a> — Imports the
+   * public portion of a new key pair and returns its <code>arn</code> and
+   * <code>fingerprint</code>. The <code>privateKey</code> can then be used to
+   * generate viewer authorization tokens, to grant viewers access to authorized
+   * channels.</p> </li> <li> <p> <a>GetPlaybackKeyPair</a> — Gets a specified
+   * playback authorization key pair and returns the <code>arn</code> and
+   * <code>fingerprint</code>. The <code>privateKey</code> held by the caller can be
+   * used to generate viewer authorization tokens, to grant viewers access to
+   * authorized channels.</p> </li> <li> <p> <a>ListPlaybackKeyPairs</a> — Gets
+   * summary information about playback key pairs.</p> </li> <li> <p>
+   * <a>DeletePlaybackKeyPair</a> — Deletes a specified authorization key pair. This
+   * invalidates future viewer tokens generated using the key pair’s
+   * <code>privateKey</code>.</p> </li> </ul> <p> <b>AWS Tags Endpoints</b> </p> <ul>
+   * <li> <p> <a>TagResource</a> — Adds or updates tags for the AWS resource with the
+   * specified ARN.</p> </li> <li> <p> <a>UntagResource</a> — Removes tags from the
+   * resource with the specified ARN.</p> </li> <li> <p> <a>ListTagsForResource</a> —
+   * Gets information about AWS tags for the specified ARN.</p> </li> </ul>
+   */
+  class AWS_IVS_API IVSClient : 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.
+        */
+        IVSClient(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.
+        */
+        IVSClient(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
+        */
+        IVSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
+            const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());
+
+        virtual ~IVSClient();
+
+
+        /**
+         * <p>Performs <a>GetChannel</a> on multiple ARNs simultaneously.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/BatchGetChannel">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::BatchGetChannelOutcome BatchGetChannel(const Model::BatchGetChannelRequest& request) const;
+
+        /**
+         * <p>Performs <a>GetChannel</a> on multiple ARNs simultaneously.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/BatchGetChannel">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::BatchGetChannelOutcomeCallable BatchGetChannelCallable(const Model::BatchGetChannelRequest& request) const;
+
+        /**
+         * <p>Performs <a>GetChannel</a> on multiple ARNs simultaneously.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/BatchGetChannel">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void BatchGetChannelAsync(const Model::BatchGetChannelRequest& request, const BatchGetChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Performs <a>GetStreamKey</a> on multiple ARNs simultaneously.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/BatchGetStreamKey">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::BatchGetStreamKeyOutcome BatchGetStreamKey(const Model::BatchGetStreamKeyRequest& request) const;
+
+        /**
+         * <p>Performs <a>GetStreamKey</a> on multiple ARNs simultaneously.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/BatchGetStreamKey">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::BatchGetStreamKeyOutcomeCallable BatchGetStreamKeyCallable(const Model::BatchGetStreamKeyRequest& request) const;
+
+        /**
+         * <p>Performs <a>GetStreamKey</a> on multiple ARNs simultaneously.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/BatchGetStreamKey">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void BatchGetStreamKeyAsync(const Model::BatchGetStreamKeyRequest& request, const BatchGetStreamKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Creates a new channel and an associated stream key to start
+         * streaming.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/CreateChannel">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::CreateChannelOutcome CreateChannel(const Model::CreateChannelRequest& request) const;
+
+        /**
+         * <p>Creates a new channel and an associated stream key to start
+         * streaming.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/CreateChannel">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::CreateChannelOutcomeCallable CreateChannelCallable(const Model::CreateChannelRequest& request) const;
+
+        /**
+         * <p>Creates a new channel and an associated stream key to start
+         * streaming.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/CreateChannel">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void CreateChannelAsync(const Model::CreateChannelRequest& request, const CreateChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Creates a stream key, used to initiate a stream, for the specified channel
+         * ARN.</p> <p>Note that <a>CreateChannel</a> creates a stream key. If you
+         * subsequently use CreateStreamKey on the same channel, it will fail because a
+         * stream key already exists and there is a limit of 1 stream key per channel. To
+         * reset the stream key on a channel, use <a>DeleteStreamKey</a> and then
+         * CreateStreamKey.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/CreateStreamKey">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::CreateStreamKeyOutcome CreateStreamKey(const Model::CreateStreamKeyRequest& request) const;
+
+        /**
+         * <p>Creates a stream key, used to initiate a stream, for the specified channel
+         * ARN.</p> <p>Note that <a>CreateChannel</a> creates a stream key. If you
+         * subsequently use CreateStreamKey on the same channel, it will fail because a
+         * stream key already exists and there is a limit of 1 stream key per channel. To
+         * reset the stream key on a channel, use <a>DeleteStreamKey</a> and then
+         * CreateStreamKey.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/CreateStreamKey">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::CreateStreamKeyOutcomeCallable CreateStreamKeyCallable(const Model::CreateStreamKeyRequest& request) const;
+
+        /**
+         * <p>Creates a stream key, used to initiate a stream, for the specified channel
+         * ARN.</p> <p>Note that <a>CreateChannel</a> creates a stream key. If you
+         * subsequently use CreateStreamKey on the same channel, it will fail because a
+         * stream key already exists and there is a limit of 1 stream key per channel. To
+         * reset the stream key on a channel, use <a>DeleteStreamKey</a> and then
+         * CreateStreamKey.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/CreateStreamKey">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void CreateStreamKeyAsync(const Model::CreateStreamKeyRequest& request, const CreateStreamKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Deletes the specified channel and its associated stream keys.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/DeleteChannel">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DeleteChannelOutcome DeleteChannel(const Model::DeleteChannelRequest& request) const;
+
+        /**
+         * <p>Deletes the specified channel and its associated stream keys.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/DeleteChannel">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DeleteChannelOutcomeCallable DeleteChannelCallable(const Model::DeleteChannelRequest& request) const;
+
+        /**
+         * <p>Deletes the specified channel and its associated stream keys.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/DeleteChannel">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DeleteChannelAsync(const Model::DeleteChannelRequest& request, const DeleteChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Deletes a specified authorization key pair. This invalidates future viewer
+         * tokens generated using the key pair’s <code>privateKey</code>.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/DeletePlaybackKeyPair">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DeletePlaybackKeyPairOutcome DeletePlaybackKeyPair(const Model::DeletePlaybackKeyPairRequest& request) const;
+
+        /**
+         * <p>Deletes a specified authorization key pair. This invalidates future viewer
+         * tokens generated using the key pair’s <code>privateKey</code>.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/DeletePlaybackKeyPair">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DeletePlaybackKeyPairOutcomeCallable DeletePlaybackKeyPairCallable(const Model::DeletePlaybackKeyPairRequest& request) const;
+
+        /**
+         * <p>Deletes a specified authorization key pair. This invalidates future viewer
+         * tokens generated using the key pair’s <code>privateKey</code>.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/DeletePlaybackKeyPair">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DeletePlaybackKeyPairAsync(const Model::DeletePlaybackKeyPairRequest& request, const DeletePlaybackKeyPairResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Deletes the stream key for the specified ARN, so it can no longer be used to
+         * stream.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/DeleteStreamKey">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DeleteStreamKeyOutcome DeleteStreamKey(const Model::DeleteStreamKeyRequest& request) const;
+
+        /**
+         * <p>Deletes the stream key for the specified ARN, so it can no longer be used to
+         * stream.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/DeleteStreamKey">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DeleteStreamKeyOutcomeCallable DeleteStreamKeyCallable(const Model::DeleteStreamKeyRequest& request) const;
+
+        /**
+         * <p>Deletes the stream key for the specified ARN, so it can no longer be used to
+         * stream.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/DeleteStreamKey">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DeleteStreamKeyAsync(const Model::DeleteStreamKeyRequest& request, const DeleteStreamKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Gets the channel configuration for the specified channel ARN. See also
+         * <a>BatchGetChannel</a>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/GetChannel">AWS API
+         * Reference</a></p>
+         */
+        virtual Model::GetChannelOutcome GetChannel(const Model::GetChannelRequest& request) const;
+
+        /**
+         * <p>Gets the channel configuration for the specified channel ARN. See also
+         * <a>BatchGetChannel</a>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/GetChannel">AWS API
+         * Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::GetChannelOutcomeCallable GetChannelCallable(const Model::GetChannelRequest& request) const;
+
+        /**
+         * <p>Gets the channel configuration for the specified channel ARN. See also
+         * <a>BatchGetChannel</a>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/GetChannel">AWS API
+         * Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void GetChannelAsync(const Model::GetChannelRequest& request, const GetChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Gets a specified playback authorization key pair and returns the
+         * <code>arn</code> and <code>fingerprint</code>. The <code>privateKey</code> held
+         * by the caller can be used to generate viewer authorization tokens, to grant
+         * viewers access to authorized channels.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/GetPlaybackKeyPair">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::GetPlaybackKeyPairOutcome GetPlaybackKeyPair(const Model::GetPlaybackKeyPairRequest& request) const;
+
+        /**
+         * <p>Gets a specified playback authorization key pair and returns the
+         * <code>arn</code> and <code>fingerprint</code>. The <code>privateKey</code> held
+         * by the caller can be used to generate viewer authorization tokens, to grant
+         * viewers access to authorized channels.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/GetPlaybackKeyPair">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::GetPlaybackKeyPairOutcomeCallable GetPlaybackKeyPairCallable(const Model::GetPlaybackKeyPairRequest& request) const;
+
+        /**
+         * <p>Gets a specified playback authorization key pair and returns the
+         * <code>arn</code> and <code>fingerprint</code>. The <code>privateKey</code> held
+         * by the caller can be used to generate viewer authorization tokens, to grant
+         * viewers access to authorized channels.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/GetPlaybackKeyPair">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void GetPlaybackKeyPairAsync(const Model::GetPlaybackKeyPairRequest& request, const GetPlaybackKeyPairResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Gets information about the active (live) stream on a specified
+         * channel.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/GetStream">AWS API
+         * Reference</a></p>
+         */
+        virtual Model::GetStreamOutcome GetStream(const Model::GetStreamRequest& request) const;
+
+        /**
+         * <p>Gets information about the active (live) stream on a specified
+         * channel.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/GetStream">AWS API
+         * Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::GetStreamOutcomeCallable GetStreamCallable(const Model::GetStreamRequest& request) const;
+
+        /**
+         * <p>Gets information about the active (live) stream on a specified
+         * channel.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/GetStream">AWS API
+         * Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void GetStreamAsync(const Model::GetStreamRequest& request, const GetStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Gets stream-key information for a specified ARN.</p><p><h3>See Also:</h3>  
+         * <a href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/GetStreamKey">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::GetStreamKeyOutcome GetStreamKey(const Model::GetStreamKeyRequest& request) const;
+
+        /**
+         * <p>Gets stream-key information for a specified ARN.</p><p><h3>See Also:</h3>  
+         * <a href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/GetStreamKey">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::GetStreamKeyOutcomeCallable GetStreamKeyCallable(const Model::GetStreamKeyRequest& request) const;
+
+        /**
+         * <p>Gets stream-key information for a specified ARN.</p><p><h3>See Also:</h3>  
+         * <a href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/GetStreamKey">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void GetStreamKeyAsync(const Model::GetStreamKeyRequest& request, const GetStreamKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Imports the public portion of a new key pair and returns its <code>arn</code>
+         * and <code>fingerprint</code>. The <code>privateKey</code> can then be used to
+         * generate viewer authorization tokens, to grant viewers access to authorized
+         * channels.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/ImportPlaybackKeyPair">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ImportPlaybackKeyPairOutcome ImportPlaybackKeyPair(const Model::ImportPlaybackKeyPairRequest& request) const;
+
+        /**
+         * <p>Imports the public portion of a new key pair and returns its <code>arn</code>
+         * and <code>fingerprint</code>. The <code>privateKey</code> can then be used to
+         * generate viewer authorization tokens, to grant viewers access to authorized
+         * channels.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/ImportPlaybackKeyPair">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::ImportPlaybackKeyPairOutcomeCallable ImportPlaybackKeyPairCallable(const Model::ImportPlaybackKeyPairRequest& request) const;
+
+        /**
+         * <p>Imports the public portion of a new key pair and returns its <code>arn</code>
+         * and <code>fingerprint</code>. The <code>privateKey</code> can then be used to
+         * generate viewer authorization tokens, to grant viewers access to authorized
+         * channels.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/ImportPlaybackKeyPair">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void ImportPlaybackKeyPairAsync(const Model::ImportPlaybackKeyPairRequest& request, const ImportPlaybackKeyPairResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Gets summary information about all channels in your account, in the AWS
+         * region where the API request is processed. This list can be filtered to match a
+         * specified string.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/ListChannels">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ListChannelsOutcome ListChannels(const Model::ListChannelsRequest& request) const;
+
+        /**
+         * <p>Gets summary information about all channels in your account, in the AWS
+         * region where the API request is processed. This list can be filtered to match a
+         * specified string.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/ListChannels">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::ListChannelsOutcomeCallable ListChannelsCallable(const Model::ListChannelsRequest& request) const;
+
+        /**
+         * <p>Gets summary information about all channels in your account, in the AWS
+         * region where the API request is processed. This list can be filtered to match a
+         * specified string.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/ListChannels">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void ListChannelsAsync(const Model::ListChannelsRequest& request, const ListChannelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Gets summary information about playback key pairs.</p><p><h3>See Also:</h3>  
+         * <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/ListPlaybackKeyPairs">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ListPlaybackKeyPairsOutcome ListPlaybackKeyPairs(const Model::ListPlaybackKeyPairsRequest& request) const;
+
+        /**
+         * <p>Gets summary information about playback key pairs.</p><p><h3>See Also:</h3>  
+         * <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/ListPlaybackKeyPairs">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::ListPlaybackKeyPairsOutcomeCallable ListPlaybackKeyPairsCallable(const Model::ListPlaybackKeyPairsRequest& request) const;
+
+        /**
+         * <p>Gets summary information about playback key pairs.</p><p><h3>See Also:</h3>  
+         * <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/ListPlaybackKeyPairs">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void ListPlaybackKeyPairsAsync(const Model::ListPlaybackKeyPairsRequest& request, const ListPlaybackKeyPairsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Gets summary information about stream keys for the specified
+         * channel.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/ListStreamKeys">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ListStreamKeysOutcome ListStreamKeys(const Model::ListStreamKeysRequest& request) const;
+
+        /**
+         * <p>Gets summary information about stream keys for the specified
+         * channel.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/ListStreamKeys">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::ListStreamKeysOutcomeCallable ListStreamKeysCallable(const Model::ListStreamKeysRequest& request) const;
+
+        /**
+         * <p>Gets summary information about stream keys for the specified
+         * channel.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/ListStreamKeys">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void ListStreamKeysAsync(const Model::ListStreamKeysRequest& request, const ListStreamKeysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Gets summary information about live streams in your account, in the AWS
+         * region where the API request is processed.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/ListStreams">AWS API
+         * Reference</a></p>
+         */
+        virtual Model::ListStreamsOutcome ListStreams(const Model::ListStreamsRequest& request) const;
+
+        /**
+         * <p>Gets summary information about live streams in your account, in the AWS
+         * region where the API request is processed.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/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>Gets summary information about live streams in your account, in the AWS
+         * region where the API request is processed.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/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>Gets information about AWS tags for the specified ARN.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/ListTagsForResource">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
+
+        /**
+         * <p>Gets information about AWS tags for the specified ARN.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/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>Gets information about AWS tags for the specified ARN.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/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>Inserts metadata into an RTMPS stream for the specified channel. A maximum of
+         * 5 requests per second per channel is allowed, each with a maximum 1KB
+         * payload.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/PutMetadata">AWS API
+         * Reference</a></p>
+         */
+        virtual Model::PutMetadataOutcome PutMetadata(const Model::PutMetadataRequest& request) const;
+
+        /**
+         * <p>Inserts metadata into an RTMPS stream for the specified channel. A maximum of
+         * 5 requests per second per channel is allowed, each with a maximum 1KB
+         * payload.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/PutMetadata">AWS API
+         * Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::PutMetadataOutcomeCallable PutMetadataCallable(const Model::PutMetadataRequest& request) const;
+
+        /**
+         * <p>Inserts metadata into an RTMPS stream for the specified channel. A maximum of
+         * 5 requests per second per channel is allowed, each with a maximum 1KB
+         * payload.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/PutMetadata">AWS API
+         * Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void PutMetadataAsync(const Model::PutMetadataRequest& request, const PutMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Disconnects the incoming RTMPS stream for the specified channel. Can be used
+         * in conjunction with <a>DeleteStreamKey</a> to prevent further streaming to a
+         * channel.</p>  <p>Many streaming client-software libraries automatically
+         * reconnect a dropped RTMPS session, so to stop the stream permanently, you may
+         * want to first revoke the <code>streamKey</code> attached to the channel.</p>
+         * <p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/StopStream">AWS API
+         * Reference</a></p>
+         */
+        virtual Model::StopStreamOutcome StopStream(const Model::StopStreamRequest& request) const;
+
+        /**
+         * <p>Disconnects the incoming RTMPS stream for the specified channel. Can be used
+         * in conjunction with <a>DeleteStreamKey</a> to prevent further streaming to a
+         * channel.</p>  <p>Many streaming client-software libraries automatically
+         * reconnect a dropped RTMPS session, so to stop the stream permanently, you may
+         * want to first revoke the <code>streamKey</code> attached to the channel.</p>
+         * <p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/StopStream">AWS API
+         * Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::StopStreamOutcomeCallable StopStreamCallable(const Model::StopStreamRequest& request) const;
+
+        /**
+         * <p>Disconnects the incoming RTMPS stream for the specified channel. Can be used
+         * in conjunction with <a>DeleteStreamKey</a> to prevent further streaming to a
+         * channel.</p>  <p>Many streaming client-software libraries automatically
+         * reconnect a dropped RTMPS session, so to stop the stream permanently, you may
+         * want to first revoke the <code>streamKey</code> attached to the channel.</p>
+         * <p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/StopStream">AWS API
+         * Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void StopStreamAsync(const Model::StopStreamRequest& request, const StopStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Adds or updates tags for the AWS resource with the specified
+         * ARN.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/TagResource">AWS API
+         * Reference</a></p>
+         */
+        virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
+
+        /**
+         * <p>Adds or updates tags for the AWS resource with the specified
+         * ARN.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/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 or updates tags for the AWS resource with the specified
+         * ARN.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/TagResource">AWS API
+         * Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void TagResourceAsync(const Model::TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Removes tags from the resource with the specified ARN.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/UntagResource">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
+
+        /**
+         * <p>Removes tags from the resource with the specified ARN.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/UntagResource">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::UntagResourceOutcomeCallable UntagResourceCallable(const Model::UntagResourceRequest& request) const;
+
+        /**
+         * <p>Removes tags from the resource with the specified ARN.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/UntagResource">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void UntagResourceAsync(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Updates a channel's configuration. This does not affect an ongoing stream of
+         * this channel. You must stop and restart the stream for the changes to take
+         * effect.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/UpdateChannel">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::UpdateChannelOutcome UpdateChannel(const Model::UpdateChannelRequest& request) const;
+
+        /**
+         * <p>Updates a channel's configuration. This does not affect an ongoing stream of
+         * this channel. You must stop and restart the stream for the changes to take
+         * effect.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/UpdateChannel">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::UpdateChannelOutcomeCallable UpdateChannelCallable(const Model::UpdateChannelRequest& request) const;
+
+        /**
+         * <p>Updates a channel's configuration. This does not affect an ongoing stream of
+         * this channel. You must stop and restart the stream for the changes to take
+         * effect.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/UpdateChannel">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void UpdateChannelAsync(const Model::UpdateChannelRequest& request, const UpdateChannelResponseReceivedHandler& 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 BatchGetChannelAsyncHelper(const Model::BatchGetChannelRequest& request, const BatchGetChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void BatchGetStreamKeyAsyncHelper(const Model::BatchGetStreamKeyRequest& request, const BatchGetStreamKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void CreateChannelAsyncHelper(const Model::CreateChannelRequest& request, const CreateChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void CreateStreamKeyAsyncHelper(const Model::CreateStreamKeyRequest& request, const CreateStreamKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DeleteChannelAsyncHelper(const Model::DeleteChannelRequest& request, const DeleteChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DeletePlaybackKeyPairAsyncHelper(const Model::DeletePlaybackKeyPairRequest& request, const DeletePlaybackKeyPairResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DeleteStreamKeyAsyncHelper(const Model::DeleteStreamKeyRequest& request, const DeleteStreamKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void GetChannelAsyncHelper(const Model::GetChannelRequest& request, const GetChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void GetPlaybackKeyPairAsyncHelper(const Model::GetPlaybackKeyPairRequest& request, const GetPlaybackKeyPairResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void GetStreamAsyncHelper(const Model::GetStreamRequest& request, const GetStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void GetStreamKeyAsyncHelper(const Model::GetStreamKeyRequest& request, const GetStreamKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void ImportPlaybackKeyPairAsyncHelper(const Model::ImportPlaybackKeyPairRequest& request, const ImportPlaybackKeyPairResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void ListChannelsAsyncHelper(const Model::ListChannelsRequest& request, const ListChannelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void ListPlaybackKeyPairsAsyncHelper(const Model::ListPlaybackKeyPairsRequest& request, const ListPlaybackKeyPairsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void ListStreamKeysAsyncHelper(const Model::ListStreamKeysRequest& request, const ListStreamKeysResponseReceivedHandler& 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 PutMetadataAsyncHelper(const Model::PutMetadataRequest& request, const PutMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void StopStreamAsyncHelper(const Model::StopStreamRequest& request, const StopStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void TagResourceAsyncHelper(const Model::TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void UntagResourceAsyncHelper(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void UpdateChannelAsyncHelper(const Model::UpdateChannelRequest& request, const UpdateChannelResponseReceivedHandler& 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 IVS
+} // namespace Aws

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

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/IVSErrorMarshaller.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/ivs/IVS_EXPORTS.h>
+#include <aws/core/client/AWSErrorMarshaller.h>
+
+namespace Aws
+{
+namespace Client
+{
+
+class AWS_IVS_API IVSErrorMarshaller : 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-ivs/include/aws/ivs/IVSErrors.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/core/client/AWSError.h>
+#include <aws/core/client/CoreErrors.h>
+#include <aws/ivs/IVS_EXPORTS.h>
+
+namespace Aws
+{
+namespace IVS
+{
+enum class IVSErrors
+{
+  //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,
+  ///////////////////////////////////////////////////////////////////////////////////////////
+
+  CHANNEL_NOT_BROADCASTING= static_cast<int>(Aws::Client::CoreErrors::SERVICE_EXTENSION_START_RANGE) + 1,
+  CONFLICT,
+  INTERNAL_SERVER,
+  PENDING_VERIFICATION,
+  SERVICE_QUOTA_EXCEEDED,
+  STREAM_UNAVAILABLE
+};
+
+class AWS_IVS_API IVSError : public Aws::Client::AWSError<IVSErrors>
+{
+public:
+  IVSError() {}
+  IVSError(const Aws::Client::AWSError<Aws::Client::CoreErrors>& rhs) : Aws::Client::AWSError<IVSErrors>(rhs) {}
+  IVSError(Aws::Client::AWSError<Aws::Client::CoreErrors>&& rhs) : Aws::Client::AWSError<IVSErrors>(rhs) {}
+  IVSError(const Aws::Client::AWSError<IVSErrors>& rhs) : Aws::Client::AWSError<IVSErrors>(rhs) {}
+  IVSError(Aws::Client::AWSError<IVSErrors>&& rhs) : Aws::Client::AWSError<IVSErrors>(rhs) {}
+
+  template <typename T>
+  T GetModeledError();
+};
+
+namespace IVSErrorMapper
+{
+  AWS_IVS_API Aws::Client::AWSError<Aws::Client::CoreErrors> GetErrorForName(const char* errorName);
+}
+
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/IVSRequest.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/ivs/IVS_EXPORTS.h>
+#include <aws/core/AmazonSerializableWebServiceRequest.h>
+#include <aws/core/utils/UnreferencedParam.h>
+#include <aws/core/http/HttpRequest.h>
+
+namespace Aws
+{
+namespace IVS
+{
+  class AWS_IVS_API IVSRequest : public Aws::AmazonSerializableWebServiceRequest
+  {
+  public:
+    virtual ~IVSRequest () {}
+
+    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, "2020-07-14"));
+      return headers;
+    }
+
+  protected:
+    virtual Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const { return Aws::Http::HeaderValueCollection(); }
+
+  };
+
+
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/IVS_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_IVS_EXPORTS
+            #define AWS_IVS_API __declspec(dllexport)
+        #else
+            #define AWS_IVS_API __declspec(dllimport)
+        #endif /* AWS_IVS_EXPORTS */
+    #else
+        #define AWS_IVS_API
+    #endif // USE_IMPORT_EXPORT
+#else // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)
+    #define AWS_IVS_API
+#endif // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/AccessDeniedException.h

@@ -0,0 +1,83 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_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 IVS
+{
+namespace Model
+{
+
+  class AWS_IVS_API AccessDeniedException
+  {
+  public:
+    AccessDeniedException();
+    AccessDeniedException(Aws::Utils::Json::JsonView jsonValue);
+    AccessDeniedException& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>User does not have sufficient access to perform this action.</p>
+     */
+    inline const Aws::String& GetExceptionMessage() const{ return m_exceptionMessage; }
+
+    /**
+     * <p>User does not have sufficient access to perform this action.</p>
+     */
+    inline bool ExceptionMessageHasBeenSet() const { return m_exceptionMessageHasBeenSet; }
+
+    /**
+     * <p>User does not have sufficient access to perform this action.</p>
+     */
+    inline void SetExceptionMessage(const Aws::String& value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage = value; }
+
+    /**
+     * <p>User does not have sufficient access to perform this action.</p>
+     */
+    inline void SetExceptionMessage(Aws::String&& value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage = std::move(value); }
+
+    /**
+     * <p>User does not have sufficient access to perform this action.</p>
+     */
+    inline void SetExceptionMessage(const char* value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage.assign(value); }
+
+    /**
+     * <p>User does not have sufficient access to perform this action.</p>
+     */
+    inline AccessDeniedException& WithExceptionMessage(const Aws::String& value) { SetExceptionMessage(value); return *this;}
+
+    /**
+     * <p>User does not have sufficient access to perform this action.</p>
+     */
+    inline AccessDeniedException& WithExceptionMessage(Aws::String&& value) { SetExceptionMessage(std::move(value)); return *this;}
+
+    /**
+     * <p>User does not have sufficient access to perform this action.</p>
+     */
+    inline AccessDeniedException& WithExceptionMessage(const char* value) { SetExceptionMessage(value); return *this;}
+
+  private:
+
+    Aws::String m_exceptionMessage;
+    bool m_exceptionMessageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/BatchError.h

@@ -0,0 +1,177 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_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 IVS
+{
+namespace Model
+{
+
+  /**
+   * <p>Error related to a specific channel, specified by its ARN.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/BatchError">AWS API
+   * Reference</a></p>
+   */
+  class AWS_IVS_API BatchError
+  {
+  public:
+    BatchError();
+    BatchError(Aws::Utils::Json::JsonView jsonValue);
+    BatchError& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline BatchError& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline BatchError& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline BatchError& WithArn(const char* value) { SetArn(value); return *this;}
+
+
+    /**
+     * <p>Error code.</p>
+     */
+    inline const Aws::String& GetCode() const{ return m_code; }
+
+    /**
+     * <p>Error code.</p>
+     */
+    inline bool CodeHasBeenSet() const { return m_codeHasBeenSet; }
+
+    /**
+     * <p>Error code.</p>
+     */
+    inline void SetCode(const Aws::String& value) { m_codeHasBeenSet = true; m_code = value; }
+
+    /**
+     * <p>Error code.</p>
+     */
+    inline void SetCode(Aws::String&& value) { m_codeHasBeenSet = true; m_code = std::move(value); }
+
+    /**
+     * <p>Error code.</p>
+     */
+    inline void SetCode(const char* value) { m_codeHasBeenSet = true; m_code.assign(value); }
+
+    /**
+     * <p>Error code.</p>
+     */
+    inline BatchError& WithCode(const Aws::String& value) { SetCode(value); return *this;}
+
+    /**
+     * <p>Error code.</p>
+     */
+    inline BatchError& WithCode(Aws::String&& value) { SetCode(std::move(value)); return *this;}
+
+    /**
+     * <p>Error code.</p>
+     */
+    inline BatchError& WithCode(const char* value) { SetCode(value); return *this;}
+
+
+    /**
+     * <p>Error message, determined by the application.</p>
+     */
+    inline const Aws::String& GetMessage() const{ return m_message; }
+
+    /**
+     * <p>Error message, determined by the application.</p>
+     */
+    inline bool MessageHasBeenSet() const { return m_messageHasBeenSet; }
+
+    /**
+     * <p>Error message, determined by the application.</p>
+     */
+    inline void SetMessage(const Aws::String& value) { m_messageHasBeenSet = true; m_message = value; }
+
+    /**
+     * <p>Error message, determined by the application.</p>
+     */
+    inline void SetMessage(Aws::String&& value) { m_messageHasBeenSet = true; m_message = std::move(value); }
+
+    /**
+     * <p>Error message, determined by the application.</p>
+     */
+    inline void SetMessage(const char* value) { m_messageHasBeenSet = true; m_message.assign(value); }
+
+    /**
+     * <p>Error message, determined by the application.</p>
+     */
+    inline BatchError& WithMessage(const Aws::String& value) { SetMessage(value); return *this;}
+
+    /**
+     * <p>Error message, determined by the application.</p>
+     */
+    inline BatchError& WithMessage(Aws::String&& value) { SetMessage(std::move(value)); return *this;}
+
+    /**
+     * <p>Error message, determined by the application.</p>
+     */
+    inline BatchError& WithMessage(const char* value) { SetMessage(value); return *this;}
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+
+    Aws::String m_code;
+    bool m_codeHasBeenSet;
+
+    Aws::String m_message;
+    bool m_messageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/BatchGetChannelRequest.h

@@ -0,0 +1,89 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSRequest.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_IVS_API BatchGetChannelRequest : public IVSRequest
+  {
+  public:
+    BatchGetChannelRequest();
+
+    // 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 "BatchGetChannel"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>Array of ARNs, one per channel.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetArns() const{ return m_arns; }
+
+    /**
+     * <p>Array of ARNs, one per channel.</p>
+     */
+    inline bool ArnsHasBeenSet() const { return m_arnsHasBeenSet; }
+
+    /**
+     * <p>Array of ARNs, one per channel.</p>
+     */
+    inline void SetArns(const Aws::Vector<Aws::String>& value) { m_arnsHasBeenSet = true; m_arns = value; }
+
+    /**
+     * <p>Array of ARNs, one per channel.</p>
+     */
+    inline void SetArns(Aws::Vector<Aws::String>&& value) { m_arnsHasBeenSet = true; m_arns = std::move(value); }
+
+    /**
+     * <p>Array of ARNs, one per channel.</p>
+     */
+    inline BatchGetChannelRequest& WithArns(const Aws::Vector<Aws::String>& value) { SetArns(value); return *this;}
+
+    /**
+     * <p>Array of ARNs, one per channel.</p>
+     */
+    inline BatchGetChannelRequest& WithArns(Aws::Vector<Aws::String>&& value) { SetArns(std::move(value)); return *this;}
+
+    /**
+     * <p>Array of ARNs, one per channel.</p>
+     */
+    inline BatchGetChannelRequest& AddArns(const Aws::String& value) { m_arnsHasBeenSet = true; m_arns.push_back(value); return *this; }
+
+    /**
+     * <p>Array of ARNs, one per channel.</p>
+     */
+    inline BatchGetChannelRequest& AddArns(Aws::String&& value) { m_arnsHasBeenSet = true; m_arns.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>Array of ARNs, one per channel.</p>
+     */
+    inline BatchGetChannelRequest& AddArns(const char* value) { m_arnsHasBeenSet = true; m_arns.push_back(value); return *this; }
+
+  private:
+
+    Aws::Vector<Aws::String> m_arns;
+    bool m_arnsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/BatchGetChannelResult.h

@@ -0,0 +1,103 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/ivs/model/Channel.h>
+#include <aws/ivs/model/BatchError.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+  class AWS_IVS_API BatchGetChannelResult
+  {
+  public:
+    BatchGetChannelResult();
+    BatchGetChannelResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    BatchGetChannelResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    
+    inline const Aws::Vector<Channel>& GetChannels() const{ return m_channels; }
+
+    
+    inline void SetChannels(const Aws::Vector<Channel>& value) { m_channels = value; }
+
+    
+    inline void SetChannels(Aws::Vector<Channel>&& value) { m_channels = std::move(value); }
+
+    
+    inline BatchGetChannelResult& WithChannels(const Aws::Vector<Channel>& value) { SetChannels(value); return *this;}
+
+    
+    inline BatchGetChannelResult& WithChannels(Aws::Vector<Channel>&& value) { SetChannels(std::move(value)); return *this;}
+
+    
+    inline BatchGetChannelResult& AddChannels(const Channel& value) { m_channels.push_back(value); return *this; }
+
+    
+    inline BatchGetChannelResult& AddChannels(Channel&& value) { m_channels.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>Each error object is related to a specific ARN in the request.</p>
+     */
+    inline const Aws::Vector<BatchError>& GetErrors() const{ return m_errors; }
+
+    /**
+     * <p>Each error object is related to a specific ARN in the request.</p>
+     */
+    inline void SetErrors(const Aws::Vector<BatchError>& value) { m_errors = value; }
+
+    /**
+     * <p>Each error object is related to a specific ARN in the request.</p>
+     */
+    inline void SetErrors(Aws::Vector<BatchError>&& value) { m_errors = std::move(value); }
+
+    /**
+     * <p>Each error object is related to a specific ARN in the request.</p>
+     */
+    inline BatchGetChannelResult& WithErrors(const Aws::Vector<BatchError>& value) { SetErrors(value); return *this;}
+
+    /**
+     * <p>Each error object is related to a specific ARN in the request.</p>
+     */
+    inline BatchGetChannelResult& WithErrors(Aws::Vector<BatchError>&& value) { SetErrors(std::move(value)); return *this;}
+
+    /**
+     * <p>Each error object is related to a specific ARN in the request.</p>
+     */
+    inline BatchGetChannelResult& AddErrors(const BatchError& value) { m_errors.push_back(value); return *this; }
+
+    /**
+     * <p>Each error object is related to a specific ARN in the request.</p>
+     */
+    inline BatchGetChannelResult& AddErrors(BatchError&& value) { m_errors.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::Vector<Channel> m_channels;
+
+    Aws::Vector<BatchError> m_errors;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/BatchGetStreamKeyRequest.h

@@ -0,0 +1,89 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSRequest.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_IVS_API BatchGetStreamKeyRequest : public IVSRequest
+  {
+  public:
+    BatchGetStreamKeyRequest();
+
+    // 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 "BatchGetStreamKey"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>Array of ARNs, one per channel.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetArns() const{ return m_arns; }
+
+    /**
+     * <p>Array of ARNs, one per channel.</p>
+     */
+    inline bool ArnsHasBeenSet() const { return m_arnsHasBeenSet; }
+
+    /**
+     * <p>Array of ARNs, one per channel.</p>
+     */
+    inline void SetArns(const Aws::Vector<Aws::String>& value) { m_arnsHasBeenSet = true; m_arns = value; }
+
+    /**
+     * <p>Array of ARNs, one per channel.</p>
+     */
+    inline void SetArns(Aws::Vector<Aws::String>&& value) { m_arnsHasBeenSet = true; m_arns = std::move(value); }
+
+    /**
+     * <p>Array of ARNs, one per channel.</p>
+     */
+    inline BatchGetStreamKeyRequest& WithArns(const Aws::Vector<Aws::String>& value) { SetArns(value); return *this;}
+
+    /**
+     * <p>Array of ARNs, one per channel.</p>
+     */
+    inline BatchGetStreamKeyRequest& WithArns(Aws::Vector<Aws::String>&& value) { SetArns(std::move(value)); return *this;}
+
+    /**
+     * <p>Array of ARNs, one per channel.</p>
+     */
+    inline BatchGetStreamKeyRequest& AddArns(const Aws::String& value) { m_arnsHasBeenSet = true; m_arns.push_back(value); return *this; }
+
+    /**
+     * <p>Array of ARNs, one per channel.</p>
+     */
+    inline BatchGetStreamKeyRequest& AddArns(Aws::String&& value) { m_arnsHasBeenSet = true; m_arns.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>Array of ARNs, one per channel.</p>
+     */
+    inline BatchGetStreamKeyRequest& AddArns(const char* value) { m_arnsHasBeenSet = true; m_arns.push_back(value); return *this; }
+
+  private:
+
+    Aws::Vector<Aws::String> m_arns;
+    bool m_arnsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/BatchGetStreamKeyResult.h

@@ -0,0 +1,89 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/ivs/model/StreamKey.h>
+#include <aws/ivs/model/BatchError.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+  class AWS_IVS_API BatchGetStreamKeyResult
+  {
+  public:
+    BatchGetStreamKeyResult();
+    BatchGetStreamKeyResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    BatchGetStreamKeyResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    
+    inline const Aws::Vector<StreamKey>& GetStreamKeys() const{ return m_streamKeys; }
+
+    
+    inline void SetStreamKeys(const Aws::Vector<StreamKey>& value) { m_streamKeys = value; }
+
+    
+    inline void SetStreamKeys(Aws::Vector<StreamKey>&& value) { m_streamKeys = std::move(value); }
+
+    
+    inline BatchGetStreamKeyResult& WithStreamKeys(const Aws::Vector<StreamKey>& value) { SetStreamKeys(value); return *this;}
+
+    
+    inline BatchGetStreamKeyResult& WithStreamKeys(Aws::Vector<StreamKey>&& value) { SetStreamKeys(std::move(value)); return *this;}
+
+    
+    inline BatchGetStreamKeyResult& AddStreamKeys(const StreamKey& value) { m_streamKeys.push_back(value); return *this; }
+
+    
+    inline BatchGetStreamKeyResult& AddStreamKeys(StreamKey&& value) { m_streamKeys.push_back(std::move(value)); return *this; }
+
+
+    
+    inline const Aws::Vector<BatchError>& GetErrors() const{ return m_errors; }
+
+    
+    inline void SetErrors(const Aws::Vector<BatchError>& value) { m_errors = value; }
+
+    
+    inline void SetErrors(Aws::Vector<BatchError>&& value) { m_errors = std::move(value); }
+
+    
+    inline BatchGetStreamKeyResult& WithErrors(const Aws::Vector<BatchError>& value) { SetErrors(value); return *this;}
+
+    
+    inline BatchGetStreamKeyResult& WithErrors(Aws::Vector<BatchError>&& value) { SetErrors(std::move(value)); return *this;}
+
+    
+    inline BatchGetStreamKeyResult& AddErrors(const BatchError& value) { m_errors.push_back(value); return *this; }
+
+    
+    inline BatchGetStreamKeyResult& AddErrors(BatchError&& value) { m_errors.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::Vector<StreamKey> m_streamKeys;
+
+    Aws::Vector<BatchError> m_errors;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/Channel.h

@@ -0,0 +1,459 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/ivs/model/ChannelLatencyMode.h>
+#include <aws/ivs/model/ChannelType.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   * <p>Object specifying a channel.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/Channel">AWS API
+   * Reference</a></p>
+   */
+  class AWS_IVS_API Channel
+  {
+  public:
+    Channel();
+    Channel(Aws::Utils::Json::JsonView jsonValue);
+    Channel& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline Channel& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline Channel& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline Channel& WithArn(const char* value) { SetArn(value); return *this;}
+
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline Channel& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline Channel& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline Channel& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline const ChannelLatencyMode& GetLatencyMode() const{ return m_latencyMode; }
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline bool LatencyModeHasBeenSet() const { return m_latencyModeHasBeenSet; }
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline void SetLatencyMode(const ChannelLatencyMode& value) { m_latencyModeHasBeenSet = true; m_latencyMode = value; }
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline void SetLatencyMode(ChannelLatencyMode&& value) { m_latencyModeHasBeenSet = true; m_latencyMode = std::move(value); }
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline Channel& WithLatencyMode(const ChannelLatencyMode& value) { SetLatencyMode(value); return *this;}
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline Channel& WithLatencyMode(ChannelLatencyMode&& value) { SetLatencyMode(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Channel type, which determines the allowable resolution and bitrate. <i>If
+     * you exceed the allowable resolution or bitrate, the stream probably will
+     * disconnect immediately.</i> Valid values:</p> <ul> <li> <p>
+     * <code>STANDARD</code>: Multiple qualities are generated from the original input,
+     * to automatically give viewers the best experience for their devices and network
+     * conditions. Vertical resolution can be up to 1080 and bitrate can be up to 8.5
+     * Mbps.</p> </li> <li> <p> <code>BASIC</code>: Amazon IVS delivers the original
+     * input to viewers. The viewer’s video-quality choice is limited to the original
+     * input. Vertical resolution can be up to 480 and bitrate can be up to 1.5
+     * Mbps.</p> </li> </ul> <p>Default: <code>STANDARD</code>.</p>
+     */
+    inline const ChannelType& GetType() const{ return m_type; }
+
+    /**
+     * <p>Channel type, which determines the allowable resolution and bitrate. <i>If
+     * you exceed the allowable resolution or bitrate, the stream probably will
+     * disconnect immediately.</i> Valid values:</p> <ul> <li> <p>
+     * <code>STANDARD</code>: Multiple qualities are generated from the original input,
+     * to automatically give viewers the best experience for their devices and network
+     * conditions. Vertical resolution can be up to 1080 and bitrate can be up to 8.5
+     * Mbps.</p> </li> <li> <p> <code>BASIC</code>: Amazon IVS delivers the original
+     * input to viewers. The viewer’s video-quality choice is limited to the original
+     * input. Vertical resolution can be up to 480 and bitrate can be up to 1.5
+     * Mbps.</p> </li> </ul> <p>Default: <code>STANDARD</code>.</p>
+     */
+    inline bool TypeHasBeenSet() const { return m_typeHasBeenSet; }
+
+    /**
+     * <p>Channel type, which determines the allowable resolution and bitrate. <i>If
+     * you exceed the allowable resolution or bitrate, the stream probably will
+     * disconnect immediately.</i> Valid values:</p> <ul> <li> <p>
+     * <code>STANDARD</code>: Multiple qualities are generated from the original input,
+     * to automatically give viewers the best experience for their devices and network
+     * conditions. Vertical resolution can be up to 1080 and bitrate can be up to 8.5
+     * Mbps.</p> </li> <li> <p> <code>BASIC</code>: Amazon IVS delivers the original
+     * input to viewers. The viewer’s video-quality choice is limited to the original
+     * input. Vertical resolution can be up to 480 and bitrate can be up to 1.5
+     * Mbps.</p> </li> </ul> <p>Default: <code>STANDARD</code>.</p>
+     */
+    inline void SetType(const ChannelType& value) { m_typeHasBeenSet = true; m_type = value; }
+
+    /**
+     * <p>Channel type, which determines the allowable resolution and bitrate. <i>If
+     * you exceed the allowable resolution or bitrate, the stream probably will
+     * disconnect immediately.</i> Valid values:</p> <ul> <li> <p>
+     * <code>STANDARD</code>: Multiple qualities are generated from the original input,
+     * to automatically give viewers the best experience for their devices and network
+     * conditions. Vertical resolution can be up to 1080 and bitrate can be up to 8.5
+     * Mbps.</p> </li> <li> <p> <code>BASIC</code>: Amazon IVS delivers the original
+     * input to viewers. The viewer’s video-quality choice is limited to the original
+     * input. Vertical resolution can be up to 480 and bitrate can be up to 1.5
+     * Mbps.</p> </li> </ul> <p>Default: <code>STANDARD</code>.</p>
+     */
+    inline void SetType(ChannelType&& value) { m_typeHasBeenSet = true; m_type = std::move(value); }
+
+    /**
+     * <p>Channel type, which determines the allowable resolution and bitrate. <i>If
+     * you exceed the allowable resolution or bitrate, the stream probably will
+     * disconnect immediately.</i> Valid values:</p> <ul> <li> <p>
+     * <code>STANDARD</code>: Multiple qualities are generated from the original input,
+     * to automatically give viewers the best experience for their devices and network
+     * conditions. Vertical resolution can be up to 1080 and bitrate can be up to 8.5
+     * Mbps.</p> </li> <li> <p> <code>BASIC</code>: Amazon IVS delivers the original
+     * input to viewers. The viewer’s video-quality choice is limited to the original
+     * input. Vertical resolution can be up to 480 and bitrate can be up to 1.5
+     * Mbps.</p> </li> </ul> <p>Default: <code>STANDARD</code>.</p>
+     */
+    inline Channel& WithType(const ChannelType& value) { SetType(value); return *this;}
+
+    /**
+     * <p>Channel type, which determines the allowable resolution and bitrate. <i>If
+     * you exceed the allowable resolution or bitrate, the stream probably will
+     * disconnect immediately.</i> Valid values:</p> <ul> <li> <p>
+     * <code>STANDARD</code>: Multiple qualities are generated from the original input,
+     * to automatically give viewers the best experience for their devices and network
+     * conditions. Vertical resolution can be up to 1080 and bitrate can be up to 8.5
+     * Mbps.</p> </li> <li> <p> <code>BASIC</code>: Amazon IVS delivers the original
+     * input to viewers. The viewer’s video-quality choice is limited to the original
+     * input. Vertical resolution can be up to 480 and bitrate can be up to 1.5
+     * Mbps.</p> </li> </ul> <p>Default: <code>STANDARD</code>.</p>
+     */
+    inline Channel& WithType(ChannelType&& value) { SetType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Channel ingest endpoint, part of the definition of an ingest server, used
+     * when you set up streaming software.</p>
+     */
+    inline const Aws::String& GetIngestEndpoint() const{ return m_ingestEndpoint; }
+
+    /**
+     * <p>Channel ingest endpoint, part of the definition of an ingest server, used
+     * when you set up streaming software.</p>
+     */
+    inline bool IngestEndpointHasBeenSet() const { return m_ingestEndpointHasBeenSet; }
+
+    /**
+     * <p>Channel ingest endpoint, part of the definition of an ingest server, used
+     * when you set up streaming software.</p>
+     */
+    inline void SetIngestEndpoint(const Aws::String& value) { m_ingestEndpointHasBeenSet = true; m_ingestEndpoint = value; }
+
+    /**
+     * <p>Channel ingest endpoint, part of the definition of an ingest server, used
+     * when you set up streaming software.</p>
+     */
+    inline void SetIngestEndpoint(Aws::String&& value) { m_ingestEndpointHasBeenSet = true; m_ingestEndpoint = std::move(value); }
+
+    /**
+     * <p>Channel ingest endpoint, part of the definition of an ingest server, used
+     * when you set up streaming software.</p>
+     */
+    inline void SetIngestEndpoint(const char* value) { m_ingestEndpointHasBeenSet = true; m_ingestEndpoint.assign(value); }
+
+    /**
+     * <p>Channel ingest endpoint, part of the definition of an ingest server, used
+     * when you set up streaming software.</p>
+     */
+    inline Channel& WithIngestEndpoint(const Aws::String& value) { SetIngestEndpoint(value); return *this;}
+
+    /**
+     * <p>Channel ingest endpoint, part of the definition of an ingest server, used
+     * when you set up streaming software.</p>
+     */
+    inline Channel& WithIngestEndpoint(Aws::String&& value) { SetIngestEndpoint(std::move(value)); return *this;}
+
+    /**
+     * <p>Channel ingest endpoint, part of the definition of an ingest server, used
+     * when you set up streaming software.</p>
+     */
+    inline Channel& WithIngestEndpoint(const char* value) { SetIngestEndpoint(value); return *this;}
+
+
+    /**
+     * <p>Channel playback URL.</p>
+     */
+    inline const Aws::String& GetPlaybackUrl() const{ return m_playbackUrl; }
+
+    /**
+     * <p>Channel playback URL.</p>
+     */
+    inline bool PlaybackUrlHasBeenSet() const { return m_playbackUrlHasBeenSet; }
+
+    /**
+     * <p>Channel playback URL.</p>
+     */
+    inline void SetPlaybackUrl(const Aws::String& value) { m_playbackUrlHasBeenSet = true; m_playbackUrl = value; }
+
+    /**
+     * <p>Channel playback URL.</p>
+     */
+    inline void SetPlaybackUrl(Aws::String&& value) { m_playbackUrlHasBeenSet = true; m_playbackUrl = std::move(value); }
+
+    /**
+     * <p>Channel playback URL.</p>
+     */
+    inline void SetPlaybackUrl(const char* value) { m_playbackUrlHasBeenSet = true; m_playbackUrl.assign(value); }
+
+    /**
+     * <p>Channel playback URL.</p>
+     */
+    inline Channel& WithPlaybackUrl(const Aws::String& value) { SetPlaybackUrl(value); return *this;}
+
+    /**
+     * <p>Channel playback URL.</p>
+     */
+    inline Channel& WithPlaybackUrl(Aws::String&& value) { SetPlaybackUrl(std::move(value)); return *this;}
+
+    /**
+     * <p>Channel playback URL.</p>
+     */
+    inline Channel& WithPlaybackUrl(const char* value) { SetPlaybackUrl(value); return *this;}
+
+
+    /**
+     * <p>Whether the channel is authorized.</p>
+     */
+    inline bool GetAuthorized() const{ return m_authorized; }
+
+    /**
+     * <p>Whether the channel is authorized.</p>
+     */
+    inline bool AuthorizedHasBeenSet() const { return m_authorizedHasBeenSet; }
+
+    /**
+     * <p>Whether the channel is authorized.</p>
+     */
+    inline void SetAuthorized(bool value) { m_authorizedHasBeenSet = true; m_authorized = value; }
+
+    /**
+     * <p>Whether the channel is authorized.</p>
+     */
+    inline Channel& WithAuthorized(bool value) { SetAuthorized(value); return *this;}
+
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline void SetTags(const Aws::Map<Aws::String, Aws::String>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline void SetTags(Aws::Map<Aws::String, Aws::String>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline Channel& WithTags(const Aws::Map<Aws::String, Aws::String>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline Channel& WithTags(Aws::Map<Aws::String, Aws::String>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline Channel& AddTags(const Aws::String& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline Channel& AddTags(Aws::String&& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline Channel& AddTags(const Aws::String& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline Channel& AddTags(Aws::String&& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline Channel& AddTags(const char* key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline Channel& AddTags(Aws::String&& key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline Channel& AddTags(const char* key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    ChannelLatencyMode m_latencyMode;
+    bool m_latencyModeHasBeenSet;
+
+    ChannelType m_type;
+    bool m_typeHasBeenSet;
+
+    Aws::String m_ingestEndpoint;
+    bool m_ingestEndpointHasBeenSet;
+
+    Aws::String m_playbackUrl;
+    bool m_playbackUrlHasBeenSet;
+
+    bool m_authorized;
+    bool m_authorizedHasBeenSet;
+
+    Aws::Map<Aws::String, Aws::String> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/ChannelLatencyMode.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/ivs/IVS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+  enum class ChannelLatencyMode
+  {
+    NOT_SET,
+    NORMAL,
+    LOW
+  };
+
+namespace ChannelLatencyModeMapper
+{
+AWS_IVS_API ChannelLatencyMode GetChannelLatencyModeForName(const Aws::String& name);
+
+AWS_IVS_API Aws::String GetNameForChannelLatencyMode(ChannelLatencyMode value);
+} // namespace ChannelLatencyModeMapper
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/ChannelNotBroadcasting.h

@@ -0,0 +1,83 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_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 IVS
+{
+namespace Model
+{
+
+  class AWS_IVS_API ChannelNotBroadcasting
+  {
+  public:
+    ChannelNotBroadcasting();
+    ChannelNotBroadcasting(Aws::Utils::Json::JsonView jsonValue);
+    ChannelNotBroadcasting& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The stream is offline for the given channel ARN.</p>
+     */
+    inline const Aws::String& GetExceptionMessage() const{ return m_exceptionMessage; }
+
+    /**
+     * <p>The stream is offline for the given channel ARN.</p>
+     */
+    inline bool ExceptionMessageHasBeenSet() const { return m_exceptionMessageHasBeenSet; }
+
+    /**
+     * <p>The stream is offline for the given channel ARN.</p>
+     */
+    inline void SetExceptionMessage(const Aws::String& value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage = value; }
+
+    /**
+     * <p>The stream is offline for the given channel ARN.</p>
+     */
+    inline void SetExceptionMessage(Aws::String&& value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage = std::move(value); }
+
+    /**
+     * <p>The stream is offline for the given channel ARN.</p>
+     */
+    inline void SetExceptionMessage(const char* value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage.assign(value); }
+
+    /**
+     * <p>The stream is offline for the given channel ARN.</p>
+     */
+    inline ChannelNotBroadcasting& WithExceptionMessage(const Aws::String& value) { SetExceptionMessage(value); return *this;}
+
+    /**
+     * <p>The stream is offline for the given channel ARN.</p>
+     */
+    inline ChannelNotBroadcasting& WithExceptionMessage(Aws::String&& value) { SetExceptionMessage(std::move(value)); return *this;}
+
+    /**
+     * <p>The stream is offline for the given channel ARN.</p>
+     */
+    inline ChannelNotBroadcasting& WithExceptionMessage(const char* value) { SetExceptionMessage(value); return *this;}
+
+  private:
+
+    Aws::String m_exceptionMessage;
+    bool m_exceptionMessageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/ChannelSummary.h

@@ -0,0 +1,274 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/ivs/model/ChannelLatencyMode.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   * <p>Summary information about a channel.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/ChannelSummary">AWS
+   * API Reference</a></p>
+   */
+  class AWS_IVS_API ChannelSummary
+  {
+  public:
+    ChannelSummary();
+    ChannelSummary(Aws::Utils::Json::JsonView jsonValue);
+    ChannelSummary& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline ChannelSummary& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline ChannelSummary& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>Channel ARN.</p>
+     */
+    inline ChannelSummary& WithArn(const char* value) { SetArn(value); return *this;}
+
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline ChannelSummary& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline ChannelSummary& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline ChannelSummary& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline const ChannelLatencyMode& GetLatencyMode() const{ return m_latencyMode; }
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline bool LatencyModeHasBeenSet() const { return m_latencyModeHasBeenSet; }
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline void SetLatencyMode(const ChannelLatencyMode& value) { m_latencyModeHasBeenSet = true; m_latencyMode = value; }
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline void SetLatencyMode(ChannelLatencyMode&& value) { m_latencyModeHasBeenSet = true; m_latencyMode = std::move(value); }
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline ChannelSummary& WithLatencyMode(const ChannelLatencyMode& value) { SetLatencyMode(value); return *this;}
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline ChannelSummary& WithLatencyMode(ChannelLatencyMode&& value) { SetLatencyMode(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Whether the channel is authorized.</p>
+     */
+    inline bool GetAuthorized() const{ return m_authorized; }
+
+    /**
+     * <p>Whether the channel is authorized.</p>
+     */
+    inline bool AuthorizedHasBeenSet() const { return m_authorizedHasBeenSet; }
+
+    /**
+     * <p>Whether the channel is authorized.</p>
+     */
+    inline void SetAuthorized(bool value) { m_authorizedHasBeenSet = true; m_authorized = value; }
+
+    /**
+     * <p>Whether the channel is authorized.</p>
+     */
+    inline ChannelSummary& WithAuthorized(bool value) { SetAuthorized(value); return *this;}
+
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline void SetTags(const Aws::Map<Aws::String, Aws::String>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline void SetTags(Aws::Map<Aws::String, Aws::String>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline ChannelSummary& WithTags(const Aws::Map<Aws::String, Aws::String>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline ChannelSummary& WithTags(Aws::Map<Aws::String, Aws::String>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline ChannelSummary& AddTags(const Aws::String& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline ChannelSummary& AddTags(Aws::String&& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline ChannelSummary& AddTags(const Aws::String& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline ChannelSummary& AddTags(Aws::String&& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline ChannelSummary& AddTags(const char* key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline ChannelSummary& AddTags(Aws::String&& key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline ChannelSummary& AddTags(const char* key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    ChannelLatencyMode m_latencyMode;
+    bool m_latencyModeHasBeenSet;
+
+    bool m_authorized;
+    bool m_authorizedHasBeenSet;
+
+    Aws::Map<Aws::String, Aws::String> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/ChannelType.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/ivs/IVS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+  enum class ChannelType
+  {
+    NOT_SET,
+    BASIC,
+    STANDARD
+  };
+
+namespace ChannelTypeMapper
+{
+AWS_IVS_API ChannelType GetChannelTypeForName(const Aws::String& name);
+
+AWS_IVS_API Aws::String GetNameForChannelType(ChannelType value);
+} // namespace ChannelTypeMapper
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/ConflictException.h

@@ -0,0 +1,83 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_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 IVS
+{
+namespace Model
+{
+
+  class AWS_IVS_API ConflictException
+  {
+  public:
+    ConflictException();
+    ConflictException(Aws::Utils::Json::JsonView jsonValue);
+    ConflictException& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Updating or deleting a resource can cause an inconsistent state.</p>
+     */
+    inline const Aws::String& GetExceptionMessage() const{ return m_exceptionMessage; }
+
+    /**
+     * <p>Updating or deleting a resource can cause an inconsistent state.</p>
+     */
+    inline bool ExceptionMessageHasBeenSet() const { return m_exceptionMessageHasBeenSet; }
+
+    /**
+     * <p>Updating or deleting a resource can cause an inconsistent state.</p>
+     */
+    inline void SetExceptionMessage(const Aws::String& value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage = value; }
+
+    /**
+     * <p>Updating or deleting a resource can cause an inconsistent state.</p>
+     */
+    inline void SetExceptionMessage(Aws::String&& value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage = std::move(value); }
+
+    /**
+     * <p>Updating or deleting a resource can cause an inconsistent state.</p>
+     */
+    inline void SetExceptionMessage(const char* value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage.assign(value); }
+
+    /**
+     * <p>Updating or deleting a resource can cause an inconsistent state.</p>
+     */
+    inline ConflictException& WithExceptionMessage(const Aws::String& value) { SetExceptionMessage(value); return *this;}
+
+    /**
+     * <p>Updating or deleting a resource can cause an inconsistent state.</p>
+     */
+    inline ConflictException& WithExceptionMessage(Aws::String&& value) { SetExceptionMessage(std::move(value)); return *this;}
+
+    /**
+     * <p>Updating or deleting a resource can cause an inconsistent state.</p>
+     */
+    inline ConflictException& WithExceptionMessage(const char* value) { SetExceptionMessage(value); return *this;}
+
+  private:
+
+    Aws::String m_exceptionMessage;
+    bool m_exceptionMessageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/CreateChannelRequest.h

@@ -0,0 +1,301 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/ivs/model/ChannelLatencyMode.h>
+#include <aws/ivs/model/ChannelType.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_IVS_API CreateChannelRequest : public IVSRequest
+  {
+  public:
+    CreateChannelRequest();
+
+    // 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 "CreateChannel"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline CreateChannelRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline CreateChannelRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline CreateChannelRequest& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline const ChannelLatencyMode& GetLatencyMode() const{ return m_latencyMode; }
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline bool LatencyModeHasBeenSet() const { return m_latencyModeHasBeenSet; }
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline void SetLatencyMode(const ChannelLatencyMode& value) { m_latencyModeHasBeenSet = true; m_latencyMode = value; }
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline void SetLatencyMode(ChannelLatencyMode&& value) { m_latencyModeHasBeenSet = true; m_latencyMode = std::move(value); }
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline CreateChannelRequest& WithLatencyMode(const ChannelLatencyMode& value) { SetLatencyMode(value); return *this;}
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline CreateChannelRequest& WithLatencyMode(ChannelLatencyMode&& value) { SetLatencyMode(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Channel type, which determines the allowable resolution and bitrate. <i>If
+     * you exceed the allowable resolution or bitrate, the stream probably will
+     * disconnect immediately.</i> Valid values:</p> <ul> <li> <p>
+     * <code>STANDARD</code>: Multiple qualities are generated from the original input,
+     * to automatically give viewers the best experience for their devices and network
+     * conditions. Vertical resolution can be up to 1080 and bitrate can be up to 8.5
+     * Mbps.</p> </li> <li> <p> <code>BASIC</code>: Amazon IVS delivers the original
+     * input to viewers. The viewer’s video-quality choice is limited to the original
+     * input. Vertical resolution can be up to 480 and bitrate can be up to 1.5
+     * Mbps.</p> </li> </ul> <p>Default: <code>STANDARD</code>.</p>
+     */
+    inline const ChannelType& GetType() const{ return m_type; }
+
+    /**
+     * <p>Channel type, which determines the allowable resolution and bitrate. <i>If
+     * you exceed the allowable resolution or bitrate, the stream probably will
+     * disconnect immediately.</i> Valid values:</p> <ul> <li> <p>
+     * <code>STANDARD</code>: Multiple qualities are generated from the original input,
+     * to automatically give viewers the best experience for their devices and network
+     * conditions. Vertical resolution can be up to 1080 and bitrate can be up to 8.5
+     * Mbps.</p> </li> <li> <p> <code>BASIC</code>: Amazon IVS delivers the original
+     * input to viewers. The viewer’s video-quality choice is limited to the original
+     * input. Vertical resolution can be up to 480 and bitrate can be up to 1.5
+     * Mbps.</p> </li> </ul> <p>Default: <code>STANDARD</code>.</p>
+     */
+    inline bool TypeHasBeenSet() const { return m_typeHasBeenSet; }
+
+    /**
+     * <p>Channel type, which determines the allowable resolution and bitrate. <i>If
+     * you exceed the allowable resolution or bitrate, the stream probably will
+     * disconnect immediately.</i> Valid values:</p> <ul> <li> <p>
+     * <code>STANDARD</code>: Multiple qualities are generated from the original input,
+     * to automatically give viewers the best experience for their devices and network
+     * conditions. Vertical resolution can be up to 1080 and bitrate can be up to 8.5
+     * Mbps.</p> </li> <li> <p> <code>BASIC</code>: Amazon IVS delivers the original
+     * input to viewers. The viewer’s video-quality choice is limited to the original
+     * input. Vertical resolution can be up to 480 and bitrate can be up to 1.5
+     * Mbps.</p> </li> </ul> <p>Default: <code>STANDARD</code>.</p>
+     */
+    inline void SetType(const ChannelType& value) { m_typeHasBeenSet = true; m_type = value; }
+
+    /**
+     * <p>Channel type, which determines the allowable resolution and bitrate. <i>If
+     * you exceed the allowable resolution or bitrate, the stream probably will
+     * disconnect immediately.</i> Valid values:</p> <ul> <li> <p>
+     * <code>STANDARD</code>: Multiple qualities are generated from the original input,
+     * to automatically give viewers the best experience for their devices and network
+     * conditions. Vertical resolution can be up to 1080 and bitrate can be up to 8.5
+     * Mbps.</p> </li> <li> <p> <code>BASIC</code>: Amazon IVS delivers the original
+     * input to viewers. The viewer’s video-quality choice is limited to the original
+     * input. Vertical resolution can be up to 480 and bitrate can be up to 1.5
+     * Mbps.</p> </li> </ul> <p>Default: <code>STANDARD</code>.</p>
+     */
+    inline void SetType(ChannelType&& value) { m_typeHasBeenSet = true; m_type = std::move(value); }
+
+    /**
+     * <p>Channel type, which determines the allowable resolution and bitrate. <i>If
+     * you exceed the allowable resolution or bitrate, the stream probably will
+     * disconnect immediately.</i> Valid values:</p> <ul> <li> <p>
+     * <code>STANDARD</code>: Multiple qualities are generated from the original input,
+     * to automatically give viewers the best experience for their devices and network
+     * conditions. Vertical resolution can be up to 1080 and bitrate can be up to 8.5
+     * Mbps.</p> </li> <li> <p> <code>BASIC</code>: Amazon IVS delivers the original
+     * input to viewers. The viewer’s video-quality choice is limited to the original
+     * input. Vertical resolution can be up to 480 and bitrate can be up to 1.5
+     * Mbps.</p> </li> </ul> <p>Default: <code>STANDARD</code>.</p>
+     */
+    inline CreateChannelRequest& WithType(const ChannelType& value) { SetType(value); return *this;}
+
+    /**
+     * <p>Channel type, which determines the allowable resolution and bitrate. <i>If
+     * you exceed the allowable resolution or bitrate, the stream probably will
+     * disconnect immediately.</i> Valid values:</p> <ul> <li> <p>
+     * <code>STANDARD</code>: Multiple qualities are generated from the original input,
+     * to automatically give viewers the best experience for their devices and network
+     * conditions. Vertical resolution can be up to 1080 and bitrate can be up to 8.5
+     * Mbps.</p> </li> <li> <p> <code>BASIC</code>: Amazon IVS delivers the original
+     * input to viewers. The viewer’s video-quality choice is limited to the original
+     * input. Vertical resolution can be up to 480 and bitrate can be up to 1.5
+     * Mbps.</p> </li> </ul> <p>Default: <code>STANDARD</code>.</p>
+     */
+    inline CreateChannelRequest& WithType(ChannelType&& value) { SetType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Whether the channel is authorized. Default: <code>false</code>.</p>
+     */
+    inline bool GetAuthorized() const{ return m_authorized; }
+
+    /**
+     * <p>Whether the channel is authorized. Default: <code>false</code>.</p>
+     */
+    inline bool AuthorizedHasBeenSet() const { return m_authorizedHasBeenSet; }
+
+    /**
+     * <p>Whether the channel is authorized. Default: <code>false</code>.</p>
+     */
+    inline void SetAuthorized(bool value) { m_authorizedHasBeenSet = true; m_authorized = value; }
+
+    /**
+     * <p>Whether the channel is authorized. Default: <code>false</code>.</p>
+     */
+    inline CreateChannelRequest& WithAuthorized(bool value) { SetAuthorized(value); return *this;}
+
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline void SetTags(const Aws::Map<Aws::String, Aws::String>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline void SetTags(Aws::Map<Aws::String, Aws::String>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline CreateChannelRequest& WithTags(const Aws::Map<Aws::String, Aws::String>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline CreateChannelRequest& WithTags(Aws::Map<Aws::String, Aws::String>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline CreateChannelRequest& AddTags(const Aws::String& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline CreateChannelRequest& AddTags(Aws::String&& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline CreateChannelRequest& AddTags(const Aws::String& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline CreateChannelRequest& AddTags(Aws::String&& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline CreateChannelRequest& AddTags(const char* key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline CreateChannelRequest& AddTags(Aws::String&& key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline CreateChannelRequest& AddTags(const char* key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+  private:
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    ChannelLatencyMode m_latencyMode;
+    bool m_latencyModeHasBeenSet;
+
+    ChannelType m_type;
+    bool m_typeHasBeenSet;
+
+    bool m_authorized;
+    bool m_authorizedHasBeenSet;
+
+    Aws::Map<Aws::String, Aws::String> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/CreateChannelResult.h

@@ -0,0 +1,76 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/model/Channel.h>
+#include <aws/ivs/model/StreamKey.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+  class AWS_IVS_API CreateChannelResult
+  {
+  public:
+    CreateChannelResult();
+    CreateChannelResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    CreateChannelResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    
+    inline const Channel& GetChannel() const{ return m_channel; }
+
+    
+    inline void SetChannel(const Channel& value) { m_channel = value; }
+
+    
+    inline void SetChannel(Channel&& value) { m_channel = std::move(value); }
+
+    
+    inline CreateChannelResult& WithChannel(const Channel& value) { SetChannel(value); return *this;}
+
+    
+    inline CreateChannelResult& WithChannel(Channel&& value) { SetChannel(std::move(value)); return *this;}
+
+
+    
+    inline const StreamKey& GetStreamKey() const{ return m_streamKey; }
+
+    
+    inline void SetStreamKey(const StreamKey& value) { m_streamKey = value; }
+
+    
+    inline void SetStreamKey(StreamKey&& value) { m_streamKey = std::move(value); }
+
+    
+    inline CreateChannelResult& WithStreamKey(const StreamKey& value) { SetStreamKey(value); return *this;}
+
+    
+    inline CreateChannelResult& WithStreamKey(StreamKey&& value) { SetStreamKey(std::move(value)); return *this;}
+
+  private:
+
+    Channel m_channel;
+
+    StreamKey m_streamKey;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/CreateStreamKeyRequest.h

@@ -0,0 +1,153 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_IVS_API CreateStreamKeyRequest : public IVSRequest
+  {
+  public:
+    CreateStreamKeyRequest();
+
+    // 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 "CreateStreamKey"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>ARN of the channel for which to create the stream key.</p>
+     */
+    inline const Aws::String& GetChannelArn() const{ return m_channelArn; }
+
+    /**
+     * <p>ARN of the channel for which to create the stream key.</p>
+     */
+    inline bool ChannelArnHasBeenSet() const { return m_channelArnHasBeenSet; }
+
+    /**
+     * <p>ARN of the channel for which to create the stream key.</p>
+     */
+    inline void SetChannelArn(const Aws::String& value) { m_channelArnHasBeenSet = true; m_channelArn = value; }
+
+    /**
+     * <p>ARN of the channel for which to create the stream key.</p>
+     */
+    inline void SetChannelArn(Aws::String&& value) { m_channelArnHasBeenSet = true; m_channelArn = std::move(value); }
+
+    /**
+     * <p>ARN of the channel for which to create the stream key.</p>
+     */
+    inline void SetChannelArn(const char* value) { m_channelArnHasBeenSet = true; m_channelArn.assign(value); }
+
+    /**
+     * <p>ARN of the channel for which to create the stream key.</p>
+     */
+    inline CreateStreamKeyRequest& WithChannelArn(const Aws::String& value) { SetChannelArn(value); return *this;}
+
+    /**
+     * <p>ARN of the channel for which to create the stream key.</p>
+     */
+    inline CreateStreamKeyRequest& WithChannelArn(Aws::String&& value) { SetChannelArn(std::move(value)); return *this;}
+
+    /**
+     * <p>ARN of the channel for which to create the stream key.</p>
+     */
+    inline CreateStreamKeyRequest& WithChannelArn(const char* value) { SetChannelArn(value); return *this;}
+
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline void SetTags(const Aws::Map<Aws::String, Aws::String>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline void SetTags(Aws::Map<Aws::String, Aws::String>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline CreateStreamKeyRequest& WithTags(const Aws::Map<Aws::String, Aws::String>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline CreateStreamKeyRequest& WithTags(Aws::Map<Aws::String, Aws::String>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline CreateStreamKeyRequest& AddTags(const Aws::String& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline CreateStreamKeyRequest& AddTags(Aws::String&& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline CreateStreamKeyRequest& AddTags(const Aws::String& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline CreateStreamKeyRequest& AddTags(Aws::String&& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline CreateStreamKeyRequest& AddTags(const char* key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline CreateStreamKeyRequest& AddTags(Aws::String&& key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>See <a>Channel$tags</a>.</p>
+     */
+    inline CreateStreamKeyRequest& AddTags(const char* key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+  private:
+
+    Aws::String m_channelArn;
+    bool m_channelArnHasBeenSet;
+
+    Aws::Map<Aws::String, Aws::String> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/CreateStreamKeyResult.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/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/model/StreamKey.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+  class AWS_IVS_API CreateStreamKeyResult
+  {
+  public:
+    CreateStreamKeyResult();
+    CreateStreamKeyResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    CreateStreamKeyResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Stream key used to authenticate an RTMPS stream for ingestion.</p>
+     */
+    inline const StreamKey& GetStreamKey() const{ return m_streamKey; }
+
+    /**
+     * <p>Stream key used to authenticate an RTMPS stream for ingestion.</p>
+     */
+    inline void SetStreamKey(const StreamKey& value) { m_streamKey = value; }
+
+    /**
+     * <p>Stream key used to authenticate an RTMPS stream for ingestion.</p>
+     */
+    inline void SetStreamKey(StreamKey&& value) { m_streamKey = std::move(value); }
+
+    /**
+     * <p>Stream key used to authenticate an RTMPS stream for ingestion.</p>
+     */
+    inline CreateStreamKeyResult& WithStreamKey(const StreamKey& value) { SetStreamKey(value); return *this;}
+
+    /**
+     * <p>Stream key used to authenticate an RTMPS stream for ingestion.</p>
+     */
+    inline CreateStreamKeyResult& WithStreamKey(StreamKey&& value) { SetStreamKey(std::move(value)); return *this;}
+
+  private:
+
+    StreamKey m_streamKey;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/DeleteChannelRequest.h

@@ -0,0 +1,83 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_IVS_API DeleteChannelRequest : public IVSRequest
+  {
+  public:
+    DeleteChannelRequest();
+
+    // 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 "DeleteChannel"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>ARN of the channel to be deleted.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>ARN of the channel to be deleted.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>ARN of the channel to be deleted.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>ARN of the channel to be deleted.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>ARN of the channel to be deleted.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>ARN of the channel to be deleted.</p>
+     */
+    inline DeleteChannelRequest& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>ARN of the channel to be deleted.</p>
+     */
+    inline DeleteChannelRequest& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>ARN of the channel to be deleted.</p>
+     */
+    inline DeleteChannelRequest& WithArn(const char* value) { SetArn(value); return *this;}
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/DeletePlaybackKeyPairRequest.h

@@ -0,0 +1,83 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_IVS_API DeletePlaybackKeyPairRequest : public IVSRequest
+  {
+  public:
+    DeletePlaybackKeyPairRequest();
+
+    // 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 "DeletePlaybackKeyPair"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>ARN of the key pair to be deleted.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>ARN of the key pair to be deleted.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>ARN of the key pair to be deleted.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>ARN of the key pair to be deleted.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>ARN of the key pair to be deleted.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>ARN of the key pair to be deleted.</p>
+     */
+    inline DeletePlaybackKeyPairRequest& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>ARN of the key pair to be deleted.</p>
+     */
+    inline DeletePlaybackKeyPairRequest& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>ARN of the key pair to be deleted.</p>
+     */
+    inline DeletePlaybackKeyPairRequest& WithArn(const char* value) { SetArn(value); return *this;}
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

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

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/DeleteStreamKeyRequest.h

@@ -0,0 +1,83 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_IVS_API DeleteStreamKeyRequest : public IVSRequest
+  {
+  public:
+    DeleteStreamKeyRequest();
+
+    // 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 "DeleteStreamKey"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>ARN of the stream key to be deleted.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>ARN of the stream key to be deleted.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>ARN of the stream key to be deleted.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>ARN of the stream key to be deleted.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>ARN of the stream key to be deleted.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>ARN of the stream key to be deleted.</p>
+     */
+    inline DeleteStreamKeyRequest& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>ARN of the stream key to be deleted.</p>
+     */
+    inline DeleteStreamKeyRequest& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>ARN of the stream key to be deleted.</p>
+     */
+    inline DeleteStreamKeyRequest& WithArn(const char* value) { SetArn(value); return *this;}
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/GetChannelRequest.h

@@ -0,0 +1,83 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_IVS_API GetChannelRequest : public IVSRequest
+  {
+  public:
+    GetChannelRequest();
+
+    // 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 "GetChannel"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>ARN of the channel for which the configuration is to be retrieved.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>ARN of the channel for which the configuration is to be retrieved.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>ARN of the channel for which the configuration is to be retrieved.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>ARN of the channel for which the configuration is to be retrieved.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>ARN of the channel for which the configuration is to be retrieved.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>ARN of the channel for which the configuration is to be retrieved.</p>
+     */
+    inline GetChannelRequest& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>ARN of the channel for which the configuration is to be retrieved.</p>
+     */
+    inline GetChannelRequest& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>ARN of the channel for which the configuration is to be retrieved.</p>
+     */
+    inline GetChannelRequest& WithArn(const char* value) { SetArn(value); return *this;}
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/GetChannelResult.h

@@ -0,0 +1,57 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/model/Channel.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+  class AWS_IVS_API GetChannelResult
+  {
+  public:
+    GetChannelResult();
+    GetChannelResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    GetChannelResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    
+    inline const Channel& GetChannel() const{ return m_channel; }
+
+    
+    inline void SetChannel(const Channel& value) { m_channel = value; }
+
+    
+    inline void SetChannel(Channel&& value) { m_channel = std::move(value); }
+
+    
+    inline GetChannelResult& WithChannel(const Channel& value) { SetChannel(value); return *this;}
+
+    
+    inline GetChannelResult& WithChannel(Channel&& value) { SetChannel(std::move(value)); return *this;}
+
+  private:
+
+    Channel m_channel;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/GetPlaybackKeyPairRequest.h

@@ -0,0 +1,83 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_IVS_API GetPlaybackKeyPairRequest : public IVSRequest
+  {
+  public:
+    GetPlaybackKeyPairRequest();
+
+    // 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 "GetPlaybackKeyPair"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>ARN of the key pair to be returned.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>ARN of the key pair to be returned.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>ARN of the key pair to be returned.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>ARN of the key pair to be returned.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>ARN of the key pair to be returned.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>ARN of the key pair to be returned.</p>
+     */
+    inline GetPlaybackKeyPairRequest& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>ARN of the key pair to be returned.</p>
+     */
+    inline GetPlaybackKeyPairRequest& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>ARN of the key pair to be returned.</p>
+     */
+    inline GetPlaybackKeyPairRequest& WithArn(const char* value) { SetArn(value); return *this;}
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/GetPlaybackKeyPairResult.h

@@ -0,0 +1,57 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/model/PlaybackKeyPair.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+  class AWS_IVS_API GetPlaybackKeyPairResult
+  {
+  public:
+    GetPlaybackKeyPairResult();
+    GetPlaybackKeyPairResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    GetPlaybackKeyPairResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    
+    inline const PlaybackKeyPair& GetKeyPair() const{ return m_keyPair; }
+
+    
+    inline void SetKeyPair(const PlaybackKeyPair& value) { m_keyPair = value; }
+
+    
+    inline void SetKeyPair(PlaybackKeyPair&& value) { m_keyPair = std::move(value); }
+
+    
+    inline GetPlaybackKeyPairResult& WithKeyPair(const PlaybackKeyPair& value) { SetKeyPair(value); return *this;}
+
+    
+    inline GetPlaybackKeyPairResult& WithKeyPair(PlaybackKeyPair&& value) { SetKeyPair(std::move(value)); return *this;}
+
+  private:
+
+    PlaybackKeyPair m_keyPair;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/GetStreamKeyRequest.h

@@ -0,0 +1,83 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_IVS_API GetStreamKeyRequest : public IVSRequest
+  {
+  public:
+    GetStreamKeyRequest();
+
+    // 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 "GetStreamKey"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>ARN for the stream key to be retrieved.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>ARN for the stream key to be retrieved.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>ARN for the stream key to be retrieved.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>ARN for the stream key to be retrieved.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>ARN for the stream key to be retrieved.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>ARN for the stream key to be retrieved.</p>
+     */
+    inline GetStreamKeyRequest& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>ARN for the stream key to be retrieved.</p>
+     */
+    inline GetStreamKeyRequest& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>ARN for the stream key to be retrieved.</p>
+     */
+    inline GetStreamKeyRequest& WithArn(const char* value) { SetArn(value); return *this;}
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/GetStreamKeyResult.h

@@ -0,0 +1,57 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/model/StreamKey.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+  class AWS_IVS_API GetStreamKeyResult
+  {
+  public:
+    GetStreamKeyResult();
+    GetStreamKeyResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    GetStreamKeyResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    
+    inline const StreamKey& GetStreamKey() const{ return m_streamKey; }
+
+    
+    inline void SetStreamKey(const StreamKey& value) { m_streamKey = value; }
+
+    
+    inline void SetStreamKey(StreamKey&& value) { m_streamKey = std::move(value); }
+
+    
+    inline GetStreamKeyResult& WithStreamKey(const StreamKey& value) { SetStreamKey(value); return *this;}
+
+    
+    inline GetStreamKeyResult& WithStreamKey(StreamKey&& value) { SetStreamKey(std::move(value)); return *this;}
+
+  private:
+
+    StreamKey m_streamKey;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/GetStreamRequest.h

@@ -0,0 +1,83 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_IVS_API GetStreamRequest : public IVSRequest
+  {
+  public:
+    GetStreamRequest();
+
+    // 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 "GetStream"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>Channel ARN for stream to be accessed.</p>
+     */
+    inline const Aws::String& GetChannelArn() const{ return m_channelArn; }
+
+    /**
+     * <p>Channel ARN for stream to be accessed.</p>
+     */
+    inline bool ChannelArnHasBeenSet() const { return m_channelArnHasBeenSet; }
+
+    /**
+     * <p>Channel ARN for stream to be accessed.</p>
+     */
+    inline void SetChannelArn(const Aws::String& value) { m_channelArnHasBeenSet = true; m_channelArn = value; }
+
+    /**
+     * <p>Channel ARN for stream to be accessed.</p>
+     */
+    inline void SetChannelArn(Aws::String&& value) { m_channelArnHasBeenSet = true; m_channelArn = std::move(value); }
+
+    /**
+     * <p>Channel ARN for stream to be accessed.</p>
+     */
+    inline void SetChannelArn(const char* value) { m_channelArnHasBeenSet = true; m_channelArn.assign(value); }
+
+    /**
+     * <p>Channel ARN for stream to be accessed.</p>
+     */
+    inline GetStreamRequest& WithChannelArn(const Aws::String& value) { SetChannelArn(value); return *this;}
+
+    /**
+     * <p>Channel ARN for stream to be accessed.</p>
+     */
+    inline GetStreamRequest& WithChannelArn(Aws::String&& value) { SetChannelArn(std::move(value)); return *this;}
+
+    /**
+     * <p>Channel ARN for stream to be accessed.</p>
+     */
+    inline GetStreamRequest& WithChannelArn(const char* value) { SetChannelArn(value); return *this;}
+
+  private:
+
+    Aws::String m_channelArn;
+    bool m_channelArnHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/GetStreamResult.h

@@ -0,0 +1,57 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/model/Stream.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+  class AWS_IVS_API GetStreamResult
+  {
+  public:
+    GetStreamResult();
+    GetStreamResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    GetStreamResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    
+    inline const Stream& GetStream() const{ return m_stream; }
+
+    
+    inline void SetStream(const Stream& value) { m_stream = value; }
+
+    
+    inline void SetStream(Stream&& value) { m_stream = std::move(value); }
+
+    
+    inline GetStreamResult& WithStream(const Stream& value) { SetStream(value); return *this;}
+
+    
+    inline GetStreamResult& WithStream(Stream&& value) { SetStream(std::move(value)); return *this;}
+
+  private:
+
+    Stream m_stream;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/ImportPlaybackKeyPairRequest.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/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_IVS_API ImportPlaybackKeyPairRequest : public IVSRequest
+  {
+  public:
+    ImportPlaybackKeyPairRequest();
+
+    // 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 "ImportPlaybackKeyPair"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The public portion of a customer-generated key pair.</p>
+     */
+    inline const Aws::String& GetPublicKeyMaterial() const{ return m_publicKeyMaterial; }
+
+    /**
+     * <p>The public portion of a customer-generated key pair.</p>
+     */
+    inline bool PublicKeyMaterialHasBeenSet() const { return m_publicKeyMaterialHasBeenSet; }
+
+    /**
+     * <p>The public portion of a customer-generated key pair.</p>
+     */
+    inline void SetPublicKeyMaterial(const Aws::String& value) { m_publicKeyMaterialHasBeenSet = true; m_publicKeyMaterial = value; }
+
+    /**
+     * <p>The public portion of a customer-generated key pair.</p>
+     */
+    inline void SetPublicKeyMaterial(Aws::String&& value) { m_publicKeyMaterialHasBeenSet = true; m_publicKeyMaterial = std::move(value); }
+
+    /**
+     * <p>The public portion of a customer-generated key pair.</p>
+     */
+    inline void SetPublicKeyMaterial(const char* value) { m_publicKeyMaterialHasBeenSet = true; m_publicKeyMaterial.assign(value); }
+
+    /**
+     * <p>The public portion of a customer-generated key pair.</p>
+     */
+    inline ImportPlaybackKeyPairRequest& WithPublicKeyMaterial(const Aws::String& value) { SetPublicKeyMaterial(value); return *this;}
+
+    /**
+     * <p>The public portion of a customer-generated key pair.</p>
+     */
+    inline ImportPlaybackKeyPairRequest& WithPublicKeyMaterial(Aws::String&& value) { SetPublicKeyMaterial(std::move(value)); return *this;}
+
+    /**
+     * <p>The public portion of a customer-generated key pair.</p>
+     */
+    inline ImportPlaybackKeyPairRequest& WithPublicKeyMaterial(const char* value) { SetPublicKeyMaterial(value); return *this;}
+
+
+    /**
+     * <p>An arbitrary string (a nickname) assigned to a playback key pair that helps
+     * the customer identify that resource. The value does not need to be unique.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>An arbitrary string (a nickname) assigned to a playback key pair that helps
+     * the customer identify that resource. The value does not need to be unique.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>An arbitrary string (a nickname) assigned to a playback key pair that helps
+     * the customer identify that resource. The value does not need to be unique.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>An arbitrary string (a nickname) assigned to a playback key pair that helps
+     * the customer identify that resource. The value does not need to be unique.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>An arbitrary string (a nickname) assigned to a playback key pair that helps
+     * the customer identify that resource. The value does not need to be unique.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>An arbitrary string (a nickname) assigned to a playback key pair that helps
+     * the customer identify that resource. The value does not need to be unique.</p>
+     */
+    inline ImportPlaybackKeyPairRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>An arbitrary string (a nickname) assigned to a playback key pair that helps
+     * the customer identify that resource. The value does not need to be unique.</p>
+     */
+    inline ImportPlaybackKeyPairRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>An arbitrary string (a nickname) assigned to a playback key pair that helps
+     * the customer identify that resource. The value does not need to be unique.</p>
+     */
+    inline ImportPlaybackKeyPairRequest& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>Any tags provided with the request are added to the playback key pair
+     * tags.</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>Any tags provided with the request are added to the playback key pair
+     * tags.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>Any tags provided with the request are added to the playback key pair
+     * tags.</p>
+     */
+    inline void SetTags(const Aws::Map<Aws::String, Aws::String>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>Any tags provided with the request are added to the playback key pair
+     * tags.</p>
+     */
+    inline void SetTags(Aws::Map<Aws::String, Aws::String>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>Any tags provided with the request are added to the playback key pair
+     * tags.</p>
+     */
+    inline ImportPlaybackKeyPairRequest& WithTags(const Aws::Map<Aws::String, Aws::String>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>Any tags provided with the request are added to the playback key pair
+     * tags.</p>
+     */
+    inline ImportPlaybackKeyPairRequest& WithTags(Aws::Map<Aws::String, Aws::String>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>Any tags provided with the request are added to the playback key pair
+     * tags.</p>
+     */
+    inline ImportPlaybackKeyPairRequest& AddTags(const Aws::String& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+    /**
+     * <p>Any tags provided with the request are added to the playback key pair
+     * tags.</p>
+     */
+    inline ImportPlaybackKeyPairRequest& AddTags(Aws::String&& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>Any tags provided with the request are added to the playback key pair
+     * tags.</p>
+     */
+    inline ImportPlaybackKeyPairRequest& AddTags(const Aws::String& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>Any tags provided with the request are added to the playback key pair
+     * tags.</p>
+     */
+    inline ImportPlaybackKeyPairRequest& AddTags(Aws::String&& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>Any tags provided with the request are added to the playback key pair
+     * tags.</p>
+     */
+    inline ImportPlaybackKeyPairRequest& AddTags(const char* key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>Any tags provided with the request are added to the playback key pair
+     * tags.</p>
+     */
+    inline ImportPlaybackKeyPairRequest& AddTags(Aws::String&& key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>Any tags provided with the request are added to the playback key pair
+     * tags.</p>
+     */
+    inline ImportPlaybackKeyPairRequest& AddTags(const char* key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+  private:
+
+    Aws::String m_publicKeyMaterial;
+    bool m_publicKeyMaterialHasBeenSet;
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::Map<Aws::String, Aws::String> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/ImportPlaybackKeyPairResult.h

@@ -0,0 +1,57 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/model/PlaybackKeyPair.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+  class AWS_IVS_API ImportPlaybackKeyPairResult
+  {
+  public:
+    ImportPlaybackKeyPairResult();
+    ImportPlaybackKeyPairResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ImportPlaybackKeyPairResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    
+    inline const PlaybackKeyPair& GetKeyPair() const{ return m_keyPair; }
+
+    
+    inline void SetKeyPair(const PlaybackKeyPair& value) { m_keyPair = value; }
+
+    
+    inline void SetKeyPair(PlaybackKeyPair&& value) { m_keyPair = std::move(value); }
+
+    
+    inline ImportPlaybackKeyPairResult& WithKeyPair(const PlaybackKeyPair& value) { SetKeyPair(value); return *this;}
+
+    
+    inline ImportPlaybackKeyPairResult& WithKeyPair(PlaybackKeyPair&& value) { SetKeyPair(std::move(value)); return *this;}
+
+  private:
+
+    PlaybackKeyPair m_keyPair;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/InternalServerException.h

@@ -0,0 +1,83 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_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 IVS
+{
+namespace Model
+{
+
+  class AWS_IVS_API InternalServerException
+  {
+  public:
+    InternalServerException();
+    InternalServerException(Aws::Utils::Json::JsonView jsonValue);
+    InternalServerException& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Unexpected error during processing of request.</p>
+     */
+    inline const Aws::String& GetExceptionMessage() const{ return m_exceptionMessage; }
+
+    /**
+     * <p>Unexpected error during processing of request.</p>
+     */
+    inline bool ExceptionMessageHasBeenSet() const { return m_exceptionMessageHasBeenSet; }
+
+    /**
+     * <p>Unexpected error during processing of request.</p>
+     */
+    inline void SetExceptionMessage(const Aws::String& value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage = value; }
+
+    /**
+     * <p>Unexpected error during processing of request.</p>
+     */
+    inline void SetExceptionMessage(Aws::String&& value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage = std::move(value); }
+
+    /**
+     * <p>Unexpected error during processing of request.</p>
+     */
+    inline void SetExceptionMessage(const char* value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage.assign(value); }
+
+    /**
+     * <p>Unexpected error during processing of request.</p>
+     */
+    inline InternalServerException& WithExceptionMessage(const Aws::String& value) { SetExceptionMessage(value); return *this;}
+
+    /**
+     * <p>Unexpected error during processing of request.</p>
+     */
+    inline InternalServerException& WithExceptionMessage(Aws::String&& value) { SetExceptionMessage(std::move(value)); return *this;}
+
+    /**
+     * <p>Unexpected error during processing of request.</p>
+     */
+    inline InternalServerException& WithExceptionMessage(const char* value) { SetExceptionMessage(value); return *this;}
+
+  private:
+
+    Aws::String m_exceptionMessage;
+    bool m_exceptionMessageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/ListChannelsRequest.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/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_IVS_API ListChannelsRequest : public IVSRequest
+  {
+  public:
+    ListChannelsRequest();
+
+    // 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 "ListChannels"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>Filters the channel list to match the specified name.</p>
+     */
+    inline const Aws::String& GetFilterByName() const{ return m_filterByName; }
+
+    /**
+     * <p>Filters the channel list to match the specified name.</p>
+     */
+    inline bool FilterByNameHasBeenSet() const { return m_filterByNameHasBeenSet; }
+
+    /**
+     * <p>Filters the channel list to match the specified name.</p>
+     */
+    inline void SetFilterByName(const Aws::String& value) { m_filterByNameHasBeenSet = true; m_filterByName = value; }
+
+    /**
+     * <p>Filters the channel list to match the specified name.</p>
+     */
+    inline void SetFilterByName(Aws::String&& value) { m_filterByNameHasBeenSet = true; m_filterByName = std::move(value); }
+
+    /**
+     * <p>Filters the channel list to match the specified name.</p>
+     */
+    inline void SetFilterByName(const char* value) { m_filterByNameHasBeenSet = true; m_filterByName.assign(value); }
+
+    /**
+     * <p>Filters the channel list to match the specified name.</p>
+     */
+    inline ListChannelsRequest& WithFilterByName(const Aws::String& value) { SetFilterByName(value); return *this;}
+
+    /**
+     * <p>Filters the channel list to match the specified name.</p>
+     */
+    inline ListChannelsRequest& WithFilterByName(Aws::String&& value) { SetFilterByName(std::move(value)); return *this;}
+
+    /**
+     * <p>Filters the channel list to match the specified name.</p>
+     */
+    inline ListChannelsRequest& WithFilterByName(const char* value) { SetFilterByName(value); return *this;}
+
+
+    /**
+     * <p>The first channel to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>The first channel to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>The first channel to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>The first channel to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>The first channel to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>The first channel to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline ListChannelsRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>The first channel to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline ListChannelsRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>The first channel to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline ListChannelsRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>Maximum number of channels to return.</p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>Maximum number of channels to return.</p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>Maximum number of channels to return.</p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>Maximum number of channels to return.</p>
+     */
+    inline ListChannelsRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+  private:
+
+    Aws::String m_filterByName;
+    bool m_filterByNameHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/ListChannelsResult.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/ivs/IVS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/ivs/model/ChannelSummary.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+  class AWS_IVS_API ListChannelsResult
+  {
+  public:
+    ListChannelsResult();
+    ListChannelsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListChannelsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>List of the matching channels.</p>
+     */
+    inline const Aws::Vector<ChannelSummary>& GetChannels() const{ return m_channels; }
+
+    /**
+     * <p>List of the matching channels.</p>
+     */
+    inline void SetChannels(const Aws::Vector<ChannelSummary>& value) { m_channels = value; }
+
+    /**
+     * <p>List of the matching channels.</p>
+     */
+    inline void SetChannels(Aws::Vector<ChannelSummary>&& value) { m_channels = std::move(value); }
+
+    /**
+     * <p>List of the matching channels.</p>
+     */
+    inline ListChannelsResult& WithChannels(const Aws::Vector<ChannelSummary>& value) { SetChannels(value); return *this;}
+
+    /**
+     * <p>List of the matching channels.</p>
+     */
+    inline ListChannelsResult& WithChannels(Aws::Vector<ChannelSummary>&& value) { SetChannels(std::move(value)); return *this;}
+
+    /**
+     * <p>List of the matching channels.</p>
+     */
+    inline ListChannelsResult& AddChannels(const ChannelSummary& value) { m_channels.push_back(value); return *this; }
+
+    /**
+     * <p>List of the matching channels.</p>
+     */
+    inline ListChannelsResult& AddChannels(ChannelSummary&& value) { m_channels.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>If there are more channels than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>If there are more channels than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>If there are more channels than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>If there are more channels than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>If there are more channels than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline ListChannelsResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>If there are more channels than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline ListChannelsResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If there are more channels than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline ListChannelsResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    Aws::Vector<ChannelSummary> m_channels;
+
+    Aws::String m_nextToken;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/ListPlaybackKeyPairsRequest.h

@@ -0,0 +1,111 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_IVS_API ListPlaybackKeyPairsRequest : public IVSRequest
+  {
+  public:
+    ListPlaybackKeyPairsRequest();
+
+    // 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 "ListPlaybackKeyPairs"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>Maximum number of key pairs to return.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>Maximum number of key pairs to return.</p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>Maximum number of key pairs to return.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>Maximum number of key pairs to return.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>Maximum number of key pairs to return.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>Maximum number of key pairs to return.</p>
+     */
+    inline ListPlaybackKeyPairsRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>Maximum number of key pairs to return.</p>
+     */
+    inline ListPlaybackKeyPairsRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>Maximum number of key pairs to return.</p>
+     */
+    inline ListPlaybackKeyPairsRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>The first key pair to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>The first key pair to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>The first key pair to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>The first key pair to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline ListPlaybackKeyPairsRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+  private:
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/ListPlaybackKeyPairsResult.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/ivs/IVS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/ivs/model/PlaybackKeyPairSummary.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+  class AWS_IVS_API ListPlaybackKeyPairsResult
+  {
+  public:
+    ListPlaybackKeyPairsResult();
+    ListPlaybackKeyPairsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListPlaybackKeyPairsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>List of key pairs.</p>
+     */
+    inline const Aws::Vector<PlaybackKeyPairSummary>& GetKeyPairs() const{ return m_keyPairs; }
+
+    /**
+     * <p>List of key pairs.</p>
+     */
+    inline void SetKeyPairs(const Aws::Vector<PlaybackKeyPairSummary>& value) { m_keyPairs = value; }
+
+    /**
+     * <p>List of key pairs.</p>
+     */
+    inline void SetKeyPairs(Aws::Vector<PlaybackKeyPairSummary>&& value) { m_keyPairs = std::move(value); }
+
+    /**
+     * <p>List of key pairs.</p>
+     */
+    inline ListPlaybackKeyPairsResult& WithKeyPairs(const Aws::Vector<PlaybackKeyPairSummary>& value) { SetKeyPairs(value); return *this;}
+
+    /**
+     * <p>List of key pairs.</p>
+     */
+    inline ListPlaybackKeyPairsResult& WithKeyPairs(Aws::Vector<PlaybackKeyPairSummary>&& value) { SetKeyPairs(std::move(value)); return *this;}
+
+    /**
+     * <p>List of key pairs.</p>
+     */
+    inline ListPlaybackKeyPairsResult& AddKeyPairs(const PlaybackKeyPairSummary& value) { m_keyPairs.push_back(value); return *this; }
+
+    /**
+     * <p>List of key pairs.</p>
+     */
+    inline ListPlaybackKeyPairsResult& AddKeyPairs(PlaybackKeyPairSummary&& value) { m_keyPairs.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>If there are more key pairs than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>If there are more key pairs than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>If there are more key pairs than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>If there are more key pairs than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>If there are more key pairs than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline ListPlaybackKeyPairsResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>If there are more key pairs than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline ListPlaybackKeyPairsResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If there are more key pairs than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline ListPlaybackKeyPairsResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    Aws::Vector<PlaybackKeyPairSummary> m_keyPairs;
+
+    Aws::String m_nextToken;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/ListStreamKeysRequest.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/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_IVS_API ListStreamKeysRequest : public IVSRequest
+  {
+  public:
+    ListStreamKeysRequest();
+
+    // 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 "ListStreamKeys"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>Channel ARN used to filter the list.</p>
+     */
+    inline const Aws::String& GetChannelArn() const{ return m_channelArn; }
+
+    /**
+     * <p>Channel ARN used to filter the list.</p>
+     */
+    inline bool ChannelArnHasBeenSet() const { return m_channelArnHasBeenSet; }
+
+    /**
+     * <p>Channel ARN used to filter the list.</p>
+     */
+    inline void SetChannelArn(const Aws::String& value) { m_channelArnHasBeenSet = true; m_channelArn = value; }
+
+    /**
+     * <p>Channel ARN used to filter the list.</p>
+     */
+    inline void SetChannelArn(Aws::String&& value) { m_channelArnHasBeenSet = true; m_channelArn = std::move(value); }
+
+    /**
+     * <p>Channel ARN used to filter the list.</p>
+     */
+    inline void SetChannelArn(const char* value) { m_channelArnHasBeenSet = true; m_channelArn.assign(value); }
+
+    /**
+     * <p>Channel ARN used to filter the list.</p>
+     */
+    inline ListStreamKeysRequest& WithChannelArn(const Aws::String& value) { SetChannelArn(value); return *this;}
+
+    /**
+     * <p>Channel ARN used to filter the list.</p>
+     */
+    inline ListStreamKeysRequest& WithChannelArn(Aws::String&& value) { SetChannelArn(std::move(value)); return *this;}
+
+    /**
+     * <p>Channel ARN used to filter the list.</p>
+     */
+    inline ListStreamKeysRequest& WithChannelArn(const char* value) { SetChannelArn(value); return *this;}
+
+
+    /**
+     * <p>The first stream key to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>The first stream key to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>The first stream key to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>The first stream key to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>The first stream key to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>The first stream key to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline ListStreamKeysRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>The first stream key to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline ListStreamKeysRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>The first stream key to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline ListStreamKeysRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>Maximum number of streamKeys to return.</p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>Maximum number of streamKeys to return.</p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>Maximum number of streamKeys to return.</p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>Maximum number of streamKeys to return.</p>
+     */
+    inline ListStreamKeysRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+  private:
+
+    Aws::String m_channelArn;
+    bool m_channelArnHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/ListStreamKeysResult.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/ivs/IVS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/ivs/model/StreamKeySummary.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+  class AWS_IVS_API ListStreamKeysResult
+  {
+  public:
+    ListStreamKeysResult();
+    ListStreamKeysResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListStreamKeysResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>List of stream keys.</p>
+     */
+    inline const Aws::Vector<StreamKeySummary>& GetStreamKeys() const{ return m_streamKeys; }
+
+    /**
+     * <p>List of stream keys.</p>
+     */
+    inline void SetStreamKeys(const Aws::Vector<StreamKeySummary>& value) { m_streamKeys = value; }
+
+    /**
+     * <p>List of stream keys.</p>
+     */
+    inline void SetStreamKeys(Aws::Vector<StreamKeySummary>&& value) { m_streamKeys = std::move(value); }
+
+    /**
+     * <p>List of stream keys.</p>
+     */
+    inline ListStreamKeysResult& WithStreamKeys(const Aws::Vector<StreamKeySummary>& value) { SetStreamKeys(value); return *this;}
+
+    /**
+     * <p>List of stream keys.</p>
+     */
+    inline ListStreamKeysResult& WithStreamKeys(Aws::Vector<StreamKeySummary>&& value) { SetStreamKeys(std::move(value)); return *this;}
+
+    /**
+     * <p>List of stream keys.</p>
+     */
+    inline ListStreamKeysResult& AddStreamKeys(const StreamKeySummary& value) { m_streamKeys.push_back(value); return *this; }
+
+    /**
+     * <p>List of stream keys.</p>
+     */
+    inline ListStreamKeysResult& AddStreamKeys(StreamKeySummary&& value) { m_streamKeys.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>If there are more stream keys than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>If there are more stream keys than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>If there are more stream keys than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>If there are more stream keys than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>If there are more stream keys than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline ListStreamKeysResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>If there are more stream keys than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline ListStreamKeysResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If there are more stream keys than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline ListStreamKeysResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    Aws::Vector<StreamKeySummary> m_streamKeys;
+
+    Aws::String m_nextToken;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

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

@@ -0,0 +1,115 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_IVS_API ListStreamsRequest : public IVSRequest
+  {
+  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 first stream to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>The first stream to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>The first stream to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>The first stream to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>The first stream to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>The first stream to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline ListStreamsRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>The first stream to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline ListStreamsRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>The first stream to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline ListStreamsRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>Maximum number of streams to return.</p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>Maximum number of streams to return.</p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>Maximum number of streams to return.</p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>Maximum number of streams to return.</p>
+     */
+    inline ListStreamsRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+  private:
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/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/ivs/IVS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/ivs/model/StreamSummary.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+  class AWS_IVS_API ListStreamsResult
+  {
+  public:
+    ListStreamsResult();
+    ListStreamsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListStreamsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>List of streams.</p>
+     */
+    inline const Aws::Vector<StreamSummary>& GetStreams() const{ return m_streams; }
+
+    /**
+     * <p>List of streams.</p>
+     */
+    inline void SetStreams(const Aws::Vector<StreamSummary>& value) { m_streams = value; }
+
+    /**
+     * <p>List of streams.</p>
+     */
+    inline void SetStreams(Aws::Vector<StreamSummary>&& value) { m_streams = std::move(value); }
+
+    /**
+     * <p>List of streams.</p>
+     */
+    inline ListStreamsResult& WithStreams(const Aws::Vector<StreamSummary>& value) { SetStreams(value); return *this;}
+
+    /**
+     * <p>List of streams.</p>
+     */
+    inline ListStreamsResult& WithStreams(Aws::Vector<StreamSummary>&& value) { SetStreams(std::move(value)); return *this;}
+
+    /**
+     * <p>List of streams.</p>
+     */
+    inline ListStreamsResult& AddStreams(const StreamSummary& value) { m_streams.push_back(value); return *this; }
+
+    /**
+     * <p>List of streams.</p>
+     */
+    inline ListStreamsResult& AddStreams(StreamSummary&& value) { m_streams.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>If there are more streams than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>If there are more streams than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>If there are more streams than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>If there are more streams than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>If there are more streams than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline ListStreamsResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>If there are more streams than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline ListStreamsResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If there are more streams than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline ListStreamsResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    Aws::Vector<StreamSummary> m_streams;
+
+    Aws::String m_nextToken;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/ListTagsForResourceRequest.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/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_IVS_API ListTagsForResourceRequest : public IVSRequest
+  {
+  public:
+    ListTagsForResourceRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "ListTagsForResource"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>The ARN of the resource to be retrieved.</p>
+     */
+    inline const Aws::String& GetResourceArn() const{ return m_resourceArn; }
+
+    /**
+     * <p>The ARN of the resource to be retrieved.</p>
+     */
+    inline bool ResourceArnHasBeenSet() const { return m_resourceArnHasBeenSet; }
+
+    /**
+     * <p>The ARN of the resource to be retrieved.</p>
+     */
+    inline void SetResourceArn(const Aws::String& value) { m_resourceArnHasBeenSet = true; m_resourceArn = value; }
+
+    /**
+     * <p>The ARN of the resource to be retrieved.</p>
+     */
+    inline void SetResourceArn(Aws::String&& value) { m_resourceArnHasBeenSet = true; m_resourceArn = std::move(value); }
+
+    /**
+     * <p>The ARN of the resource to be retrieved.</p>
+     */
+    inline void SetResourceArn(const char* value) { m_resourceArnHasBeenSet = true; m_resourceArn.assign(value); }
+
+    /**
+     * <p>The ARN of the resource to be retrieved.</p>
+     */
+    inline ListTagsForResourceRequest& WithResourceArn(const Aws::String& value) { SetResourceArn(value); return *this;}
+
+    /**
+     * <p>The ARN of the resource to be retrieved.</p>
+     */
+    inline ListTagsForResourceRequest& WithResourceArn(Aws::String&& value) { SetResourceArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The ARN of the resource to be retrieved.</p>
+     */
+    inline ListTagsForResourceRequest& WithResourceArn(const char* value) { SetResourceArn(value); return *this;}
+
+
+    /**
+     * <p>The first tag to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>The first tag to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>The first tag to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>The first tag to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>The first tag to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>The first tag to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline ListTagsForResourceRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>The first tag to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline ListTagsForResourceRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>The first tag to retrieve. This is used for pagination; see the
+     * <code>nextToken</code> response field.</p>
+     */
+    inline ListTagsForResourceRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>Maximum number of tags to return.</p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>Maximum number of tags to return.</p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>Maximum number of tags to return.</p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>Maximum number of tags to return.</p>
+     */
+    inline ListTagsForResourceRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+  private:
+
+    Aws::String m_resourceArn;
+    bool m_resourceArnHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/ListTagsForResourceResult.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/ivs/IVS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+  class AWS_IVS_API ListTagsForResourceResult
+  {
+  public:
+    ListTagsForResourceResult();
+    ListTagsForResourceResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListTagsForResourceResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetTags() const{ return m_tags; }
+
+    
+    inline void SetTags(const Aws::Map<Aws::String, Aws::String>& value) { m_tags = value; }
+
+    
+    inline void SetTags(Aws::Map<Aws::String, Aws::String>&& value) { m_tags = std::move(value); }
+
+    
+    inline ListTagsForResourceResult& WithTags(const Aws::Map<Aws::String, Aws::String>& value) { SetTags(value); return *this;}
+
+    
+    inline ListTagsForResourceResult& WithTags(Aws::Map<Aws::String, Aws::String>&& value) { SetTags(std::move(value)); return *this;}
+
+    
+    inline ListTagsForResourceResult& AddTags(const Aws::String& key, const Aws::String& value) { m_tags.emplace(key, value); return *this; }
+
+    
+    inline ListTagsForResourceResult& AddTags(Aws::String&& key, const Aws::String& value) { m_tags.emplace(std::move(key), value); return *this; }
+
+    
+    inline ListTagsForResourceResult& AddTags(const Aws::String& key, Aws::String&& value) { m_tags.emplace(key, std::move(value)); return *this; }
+
+    
+    inline ListTagsForResourceResult& AddTags(Aws::String&& key, Aws::String&& value) { m_tags.emplace(std::move(key), std::move(value)); return *this; }
+
+    
+    inline ListTagsForResourceResult& AddTags(const char* key, Aws::String&& value) { m_tags.emplace(key, std::move(value)); return *this; }
+
+    
+    inline ListTagsForResourceResult& AddTags(Aws::String&& key, const char* value) { m_tags.emplace(std::move(key), value); return *this; }
+
+    
+    inline ListTagsForResourceResult& AddTags(const char* key, const char* value) { m_tags.emplace(key, value); return *this; }
+
+
+    /**
+     * <p>If there are more tags than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>If there are more tags than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>If there are more tags than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>If there are more tags than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>If there are more tags than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline ListTagsForResourceResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>If there are more tags than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline ListTagsForResourceResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If there are more tags than <code>maxResults</code>, use
+     * <code>nextToken</code> in the request to get the next set.</p>
+     */
+    inline ListTagsForResourceResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    Aws::Map<Aws::String, Aws::String> m_tags;
+
+    Aws::String m_nextToken;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/PendingVerification.h

@@ -0,0 +1,83 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_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 IVS
+{
+namespace Model
+{
+
+  class AWS_IVS_API PendingVerification
+  {
+  public:
+    PendingVerification();
+    PendingVerification(Aws::Utils::Json::JsonView jsonValue);
+    PendingVerification& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p> Your account is pending verification. </p>
+     */
+    inline const Aws::String& GetExceptionMessage() const{ return m_exceptionMessage; }
+
+    /**
+     * <p> Your account is pending verification. </p>
+     */
+    inline bool ExceptionMessageHasBeenSet() const { return m_exceptionMessageHasBeenSet; }
+
+    /**
+     * <p> Your account is pending verification. </p>
+     */
+    inline void SetExceptionMessage(const Aws::String& value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage = value; }
+
+    /**
+     * <p> Your account is pending verification. </p>
+     */
+    inline void SetExceptionMessage(Aws::String&& value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage = std::move(value); }
+
+    /**
+     * <p> Your account is pending verification. </p>
+     */
+    inline void SetExceptionMessage(const char* value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage.assign(value); }
+
+    /**
+     * <p> Your account is pending verification. </p>
+     */
+    inline PendingVerification& WithExceptionMessage(const Aws::String& value) { SetExceptionMessage(value); return *this;}
+
+    /**
+     * <p> Your account is pending verification. </p>
+     */
+    inline PendingVerification& WithExceptionMessage(Aws::String&& value) { SetExceptionMessage(std::move(value)); return *this;}
+
+    /**
+     * <p> Your account is pending verification. </p>
+     */
+    inline PendingVerification& WithExceptionMessage(const char* value) { SetExceptionMessage(value); return *this;}
+
+  private:
+
+    Aws::String m_exceptionMessage;
+    bool m_exceptionMessageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/PlaybackKeyPair.h

@@ -0,0 +1,260 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   * <p>A key pair used to sign and validate a playback authorization
+   * token.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/PlaybackKeyPair">AWS
+   * API Reference</a></p>
+   */
+  class AWS_IVS_API PlaybackKeyPair
+  {
+  public:
+    PlaybackKeyPair();
+    PlaybackKeyPair(Aws::Utils::Json::JsonView jsonValue);
+    PlaybackKeyPair& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Key-pair ARN.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>Key-pair ARN.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>Key-pair ARN.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>Key-pair ARN.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>Key-pair ARN.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>Key-pair ARN.</p>
+     */
+    inline PlaybackKeyPair& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>Key-pair ARN.</p>
+     */
+    inline PlaybackKeyPair& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>Key-pair ARN.</p>
+     */
+    inline PlaybackKeyPair& WithArn(const char* value) { SetArn(value); return *this;}
+
+
+    /**
+     * <p>Key-pair name.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>Key-pair name.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>Key-pair name.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>Key-pair name.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>Key-pair name.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>Key-pair name.</p>
+     */
+    inline PlaybackKeyPair& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>Key-pair name.</p>
+     */
+    inline PlaybackKeyPair& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>Key-pair name.</p>
+     */
+    inline PlaybackKeyPair& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>Key-pair identifier.</p>
+     */
+    inline const Aws::String& GetFingerprint() const{ return m_fingerprint; }
+
+    /**
+     * <p>Key-pair identifier.</p>
+     */
+    inline bool FingerprintHasBeenSet() const { return m_fingerprintHasBeenSet; }
+
+    /**
+     * <p>Key-pair identifier.</p>
+     */
+    inline void SetFingerprint(const Aws::String& value) { m_fingerprintHasBeenSet = true; m_fingerprint = value; }
+
+    /**
+     * <p>Key-pair identifier.</p>
+     */
+    inline void SetFingerprint(Aws::String&& value) { m_fingerprintHasBeenSet = true; m_fingerprint = std::move(value); }
+
+    /**
+     * <p>Key-pair identifier.</p>
+     */
+    inline void SetFingerprint(const char* value) { m_fingerprintHasBeenSet = true; m_fingerprint.assign(value); }
+
+    /**
+     * <p>Key-pair identifier.</p>
+     */
+    inline PlaybackKeyPair& WithFingerprint(const Aws::String& value) { SetFingerprint(value); return *this;}
+
+    /**
+     * <p>Key-pair identifier.</p>
+     */
+    inline PlaybackKeyPair& WithFingerprint(Aws::String&& value) { SetFingerprint(std::move(value)); return *this;}
+
+    /**
+     * <p>Key-pair identifier.</p>
+     */
+    inline PlaybackKeyPair& WithFingerprint(const char* value) { SetFingerprint(value); return *this;}
+
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline void SetTags(const Aws::Map<Aws::String, Aws::String>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline void SetTags(Aws::Map<Aws::String, Aws::String>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline PlaybackKeyPair& WithTags(const Aws::Map<Aws::String, Aws::String>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline PlaybackKeyPair& WithTags(Aws::Map<Aws::String, Aws::String>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline PlaybackKeyPair& AddTags(const Aws::String& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline PlaybackKeyPair& AddTags(Aws::String&& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline PlaybackKeyPair& AddTags(const Aws::String& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline PlaybackKeyPair& AddTags(Aws::String&& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline PlaybackKeyPair& AddTags(const char* key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline PlaybackKeyPair& AddTags(Aws::String&& key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline PlaybackKeyPair& AddTags(const char* key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::String m_fingerprint;
+    bool m_fingerprintHasBeenSet;
+
+    Aws::Map<Aws::String, Aws::String> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/PlaybackKeyPairSummary.h

@@ -0,0 +1,215 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   * <p>Summary information about a playback key pair.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/PlaybackKeyPairSummary">AWS
+   * API Reference</a></p>
+   */
+  class AWS_IVS_API PlaybackKeyPairSummary
+  {
+  public:
+    PlaybackKeyPairSummary();
+    PlaybackKeyPairSummary(Aws::Utils::Json::JsonView jsonValue);
+    PlaybackKeyPairSummary& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Key-pair ARN.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>Key-pair ARN.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>Key-pair ARN.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>Key-pair ARN.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>Key-pair ARN.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>Key-pair ARN.</p>
+     */
+    inline PlaybackKeyPairSummary& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>Key-pair ARN.</p>
+     */
+    inline PlaybackKeyPairSummary& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>Key-pair ARN.</p>
+     */
+    inline PlaybackKeyPairSummary& WithArn(const char* value) { SetArn(value); return *this;}
+
+
+    /**
+     * <p>Key-pair name.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>Key-pair name.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>Key-pair name.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>Key-pair name.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>Key-pair name.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>Key-pair name.</p>
+     */
+    inline PlaybackKeyPairSummary& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>Key-pair name.</p>
+     */
+    inline PlaybackKeyPairSummary& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>Key-pair name.</p>
+     */
+    inline PlaybackKeyPairSummary& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string (key:value)</code>
+     * </p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string (key:value)</code>
+     * </p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string (key:value)</code>
+     * </p>
+     */
+    inline void SetTags(const Aws::Map<Aws::String, Aws::String>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string (key:value)</code>
+     * </p>
+     */
+    inline void SetTags(Aws::Map<Aws::String, Aws::String>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string (key:value)</code>
+     * </p>
+     */
+    inline PlaybackKeyPairSummary& WithTags(const Aws::Map<Aws::String, Aws::String>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string (key:value)</code>
+     * </p>
+     */
+    inline PlaybackKeyPairSummary& WithTags(Aws::Map<Aws::String, Aws::String>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string (key:value)</code>
+     * </p>
+     */
+    inline PlaybackKeyPairSummary& AddTags(const Aws::String& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string (key:value)</code>
+     * </p>
+     */
+    inline PlaybackKeyPairSummary& AddTags(Aws::String&& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string (key:value)</code>
+     * </p>
+     */
+    inline PlaybackKeyPairSummary& AddTags(const Aws::String& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string (key:value)</code>
+     * </p>
+     */
+    inline PlaybackKeyPairSummary& AddTags(Aws::String&& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string (key:value)</code>
+     * </p>
+     */
+    inline PlaybackKeyPairSummary& AddTags(const char* key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string (key:value)</code>
+     * </p>
+     */
+    inline PlaybackKeyPairSummary& AddTags(Aws::String&& key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string (key:value)</code>
+     * </p>
+     */
+    inline PlaybackKeyPairSummary& AddTags(const char* key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::Map<Aws::String, Aws::String> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/PutMetadataRequest.h

@@ -0,0 +1,135 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_IVS_API PutMetadataRequest : public IVSRequest
+  {
+  public:
+    PutMetadataRequest();
+
+    // 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 "PutMetadata"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>ARN of the channel into which metadata is inserted. This channel must have an
+     * active stream.</p>
+     */
+    inline const Aws::String& GetChannelArn() const{ return m_channelArn; }
+
+    /**
+     * <p>ARN of the channel into which metadata is inserted. This channel must have an
+     * active stream.</p>
+     */
+    inline bool ChannelArnHasBeenSet() const { return m_channelArnHasBeenSet; }
+
+    /**
+     * <p>ARN of the channel into which metadata is inserted. This channel must have an
+     * active stream.</p>
+     */
+    inline void SetChannelArn(const Aws::String& value) { m_channelArnHasBeenSet = true; m_channelArn = value; }
+
+    /**
+     * <p>ARN of the channel into which metadata is inserted. This channel must have an
+     * active stream.</p>
+     */
+    inline void SetChannelArn(Aws::String&& value) { m_channelArnHasBeenSet = true; m_channelArn = std::move(value); }
+
+    /**
+     * <p>ARN of the channel into which metadata is inserted. This channel must have an
+     * active stream.</p>
+     */
+    inline void SetChannelArn(const char* value) { m_channelArnHasBeenSet = true; m_channelArn.assign(value); }
+
+    /**
+     * <p>ARN of the channel into which metadata is inserted. This channel must have an
+     * active stream.</p>
+     */
+    inline PutMetadataRequest& WithChannelArn(const Aws::String& value) { SetChannelArn(value); return *this;}
+
+    /**
+     * <p>ARN of the channel into which metadata is inserted. This channel must have an
+     * active stream.</p>
+     */
+    inline PutMetadataRequest& WithChannelArn(Aws::String&& value) { SetChannelArn(std::move(value)); return *this;}
+
+    /**
+     * <p>ARN of the channel into which metadata is inserted. This channel must have an
+     * active stream.</p>
+     */
+    inline PutMetadataRequest& WithChannelArn(const char* value) { SetChannelArn(value); return *this;}
+
+
+    /**
+     * <p>Metadata to insert into the stream. Maximum: 1 KB per request.</p>
+     */
+    inline const Aws::String& GetMetadata() const{ return m_metadata; }
+
+    /**
+     * <p>Metadata to insert into the stream. Maximum: 1 KB per request.</p>
+     */
+    inline bool MetadataHasBeenSet() const { return m_metadataHasBeenSet; }
+
+    /**
+     * <p>Metadata to insert into the stream. Maximum: 1 KB per request.</p>
+     */
+    inline void SetMetadata(const Aws::String& value) { m_metadataHasBeenSet = true; m_metadata = value; }
+
+    /**
+     * <p>Metadata to insert into the stream. Maximum: 1 KB per request.</p>
+     */
+    inline void SetMetadata(Aws::String&& value) { m_metadataHasBeenSet = true; m_metadata = std::move(value); }
+
+    /**
+     * <p>Metadata to insert into the stream. Maximum: 1 KB per request.</p>
+     */
+    inline void SetMetadata(const char* value) { m_metadataHasBeenSet = true; m_metadata.assign(value); }
+
+    /**
+     * <p>Metadata to insert into the stream. Maximum: 1 KB per request.</p>
+     */
+    inline PutMetadataRequest& WithMetadata(const Aws::String& value) { SetMetadata(value); return *this;}
+
+    /**
+     * <p>Metadata to insert into the stream. Maximum: 1 KB per request.</p>
+     */
+    inline PutMetadataRequest& WithMetadata(Aws::String&& value) { SetMetadata(std::move(value)); return *this;}
+
+    /**
+     * <p>Metadata to insert into the stream. Maximum: 1 KB per request.</p>
+     */
+    inline PutMetadataRequest& WithMetadata(const char* value) { SetMetadata(value); return *this;}
+
+  private:
+
+    Aws::String m_channelArn;
+    bool m_channelArnHasBeenSet;
+
+    Aws::String m_metadata;
+    bool m_metadataHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/ResourceNotFoundException.h

@@ -0,0 +1,83 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_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 IVS
+{
+namespace Model
+{
+
+  class AWS_IVS_API ResourceNotFoundException
+  {
+  public:
+    ResourceNotFoundException();
+    ResourceNotFoundException(Aws::Utils::Json::JsonView jsonValue);
+    ResourceNotFoundException& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Request references a resource which does not exist.</p>
+     */
+    inline const Aws::String& GetExceptionMessage() const{ return m_exceptionMessage; }
+
+    /**
+     * <p>Request references a resource which does not exist.</p>
+     */
+    inline bool ExceptionMessageHasBeenSet() const { return m_exceptionMessageHasBeenSet; }
+
+    /**
+     * <p>Request references a resource which does not exist.</p>
+     */
+    inline void SetExceptionMessage(const Aws::String& value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage = value; }
+
+    /**
+     * <p>Request references a resource which does not exist.</p>
+     */
+    inline void SetExceptionMessage(Aws::String&& value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage = std::move(value); }
+
+    /**
+     * <p>Request references a resource which does not exist.</p>
+     */
+    inline void SetExceptionMessage(const char* value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage.assign(value); }
+
+    /**
+     * <p>Request references a resource which does not exist.</p>
+     */
+    inline ResourceNotFoundException& WithExceptionMessage(const Aws::String& value) { SetExceptionMessage(value); return *this;}
+
+    /**
+     * <p>Request references a resource which does not exist.</p>
+     */
+    inline ResourceNotFoundException& WithExceptionMessage(Aws::String&& value) { SetExceptionMessage(std::move(value)); return *this;}
+
+    /**
+     * <p>Request references a resource which does not exist.</p>
+     */
+    inline ResourceNotFoundException& WithExceptionMessage(const char* value) { SetExceptionMessage(value); return *this;}
+
+  private:
+
+    Aws::String m_exceptionMessage;
+    bool m_exceptionMessageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/ServiceQuotaExceededException.h

@@ -0,0 +1,83 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_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 IVS
+{
+namespace Model
+{
+
+  class AWS_IVS_API ServiceQuotaExceededException
+  {
+  public:
+    ServiceQuotaExceededException();
+    ServiceQuotaExceededException(Aws::Utils::Json::JsonView jsonValue);
+    ServiceQuotaExceededException& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Request would cause a service quota to be exceeded.</p>
+     */
+    inline const Aws::String& GetExceptionMessage() const{ return m_exceptionMessage; }
+
+    /**
+     * <p>Request would cause a service quota to be exceeded.</p>
+     */
+    inline bool ExceptionMessageHasBeenSet() const { return m_exceptionMessageHasBeenSet; }
+
+    /**
+     * <p>Request would cause a service quota to be exceeded.</p>
+     */
+    inline void SetExceptionMessage(const Aws::String& value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage = value; }
+
+    /**
+     * <p>Request would cause a service quota to be exceeded.</p>
+     */
+    inline void SetExceptionMessage(Aws::String&& value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage = std::move(value); }
+
+    /**
+     * <p>Request would cause a service quota to be exceeded.</p>
+     */
+    inline void SetExceptionMessage(const char* value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage.assign(value); }
+
+    /**
+     * <p>Request would cause a service quota to be exceeded.</p>
+     */
+    inline ServiceQuotaExceededException& WithExceptionMessage(const Aws::String& value) { SetExceptionMessage(value); return *this;}
+
+    /**
+     * <p>Request would cause a service quota to be exceeded.</p>
+     */
+    inline ServiceQuotaExceededException& WithExceptionMessage(Aws::String&& value) { SetExceptionMessage(std::move(value)); return *this;}
+
+    /**
+     * <p>Request would cause a service quota to be exceeded.</p>
+     */
+    inline ServiceQuotaExceededException& WithExceptionMessage(const char* value) { SetExceptionMessage(value); return *this;}
+
+  private:
+
+    Aws::String m_exceptionMessage;
+    bool m_exceptionMessageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/StopStreamRequest.h

@@ -0,0 +1,83 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_IVS_API StopStreamRequest : public IVSRequest
+  {
+  public:
+    StopStreamRequest();
+
+    // 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 "StopStream"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>ARN of the channel for which the stream is to be stopped.</p>
+     */
+    inline const Aws::String& GetChannelArn() const{ return m_channelArn; }
+
+    /**
+     * <p>ARN of the channel for which the stream is to be stopped.</p>
+     */
+    inline bool ChannelArnHasBeenSet() const { return m_channelArnHasBeenSet; }
+
+    /**
+     * <p>ARN of the channel for which the stream is to be stopped.</p>
+     */
+    inline void SetChannelArn(const Aws::String& value) { m_channelArnHasBeenSet = true; m_channelArn = value; }
+
+    /**
+     * <p>ARN of the channel for which the stream is to be stopped.</p>
+     */
+    inline void SetChannelArn(Aws::String&& value) { m_channelArnHasBeenSet = true; m_channelArn = std::move(value); }
+
+    /**
+     * <p>ARN of the channel for which the stream is to be stopped.</p>
+     */
+    inline void SetChannelArn(const char* value) { m_channelArnHasBeenSet = true; m_channelArn.assign(value); }
+
+    /**
+     * <p>ARN of the channel for which the stream is to be stopped.</p>
+     */
+    inline StopStreamRequest& WithChannelArn(const Aws::String& value) { SetChannelArn(value); return *this;}
+
+    /**
+     * <p>ARN of the channel for which the stream is to be stopped.</p>
+     */
+    inline StopStreamRequest& WithChannelArn(Aws::String&& value) { SetChannelArn(std::move(value)); return *this;}
+
+    /**
+     * <p>ARN of the channel for which the stream is to be stopped.</p>
+     */
+    inline StopStreamRequest& WithChannelArn(const char* value) { SetChannelArn(value); return *this;}
+
+  private:
+
+    Aws::String m_channelArn;
+    bool m_channelArnHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

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

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/Stream.h

@@ -0,0 +1,270 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/DateTime.h>
+#include <aws/ivs/model/StreamState.h>
+#include <aws/ivs/model/StreamHealth.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   * <p>Specifies a live video stream that has been ingested and
+   * distributed.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/Stream">AWS API
+   * Reference</a></p>
+   */
+  class AWS_IVS_API Stream
+  {
+  public:
+    Stream();
+    Stream(Aws::Utils::Json::JsonView jsonValue);
+    Stream& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline const Aws::String& GetChannelArn() const{ return m_channelArn; }
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline bool ChannelArnHasBeenSet() const { return m_channelArnHasBeenSet; }
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline void SetChannelArn(const Aws::String& value) { m_channelArnHasBeenSet = true; m_channelArn = value; }
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline void SetChannelArn(Aws::String&& value) { m_channelArnHasBeenSet = true; m_channelArn = std::move(value); }
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline void SetChannelArn(const char* value) { m_channelArnHasBeenSet = true; m_channelArn.assign(value); }
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline Stream& WithChannelArn(const Aws::String& value) { SetChannelArn(value); return *this;}
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline Stream& WithChannelArn(Aws::String&& value) { SetChannelArn(std::move(value)); return *this;}
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline Stream& WithChannelArn(const char* value) { SetChannelArn(value); return *this;}
+
+
+    /**
+     * <p>URL of the video master manifest, required by the video player to play the
+     * HLS stream.</p>
+     */
+    inline const Aws::String& GetPlaybackUrl() const{ return m_playbackUrl; }
+
+    /**
+     * <p>URL of the video master manifest, required by the video player to play the
+     * HLS stream.</p>
+     */
+    inline bool PlaybackUrlHasBeenSet() const { return m_playbackUrlHasBeenSet; }
+
+    /**
+     * <p>URL of the video master manifest, required by the video player to play the
+     * HLS stream.</p>
+     */
+    inline void SetPlaybackUrl(const Aws::String& value) { m_playbackUrlHasBeenSet = true; m_playbackUrl = value; }
+
+    /**
+     * <p>URL of the video master manifest, required by the video player to play the
+     * HLS stream.</p>
+     */
+    inline void SetPlaybackUrl(Aws::String&& value) { m_playbackUrlHasBeenSet = true; m_playbackUrl = std::move(value); }
+
+    /**
+     * <p>URL of the video master manifest, required by the video player to play the
+     * HLS stream.</p>
+     */
+    inline void SetPlaybackUrl(const char* value) { m_playbackUrlHasBeenSet = true; m_playbackUrl.assign(value); }
+
+    /**
+     * <p>URL of the video master manifest, required by the video player to play the
+     * HLS stream.</p>
+     */
+    inline Stream& WithPlaybackUrl(const Aws::String& value) { SetPlaybackUrl(value); return *this;}
+
+    /**
+     * <p>URL of the video master manifest, required by the video player to play the
+     * HLS stream.</p>
+     */
+    inline Stream& WithPlaybackUrl(Aws::String&& value) { SetPlaybackUrl(std::move(value)); return *this;}
+
+    /**
+     * <p>URL of the video master manifest, required by the video player to play the
+     * HLS stream.</p>
+     */
+    inline Stream& WithPlaybackUrl(const char* value) { SetPlaybackUrl(value); return *this;}
+
+
+    /**
+     * <p>ISO-8601 formatted timestamp of the stream’s start.</p>
+     */
+    inline const Aws::Utils::DateTime& GetStartTime() const{ return m_startTime; }
+
+    /**
+     * <p>ISO-8601 formatted timestamp of the stream’s start.</p>
+     */
+    inline bool StartTimeHasBeenSet() const { return m_startTimeHasBeenSet; }
+
+    /**
+     * <p>ISO-8601 formatted timestamp of the stream’s start.</p>
+     */
+    inline void SetStartTime(const Aws::Utils::DateTime& value) { m_startTimeHasBeenSet = true; m_startTime = value; }
+
+    /**
+     * <p>ISO-8601 formatted timestamp of the stream’s start.</p>
+     */
+    inline void SetStartTime(Aws::Utils::DateTime&& value) { m_startTimeHasBeenSet = true; m_startTime = std::move(value); }
+
+    /**
+     * <p>ISO-8601 formatted timestamp of the stream’s start.</p>
+     */
+    inline Stream& WithStartTime(const Aws::Utils::DateTime& value) { SetStartTime(value); return *this;}
+
+    /**
+     * <p>ISO-8601 formatted timestamp of the stream’s start.</p>
+     */
+    inline Stream& WithStartTime(Aws::Utils::DateTime&& value) { SetStartTime(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The stream’s state.</p>
+     */
+    inline const StreamState& GetState() const{ return m_state; }
+
+    /**
+     * <p>The stream’s state.</p>
+     */
+    inline bool StateHasBeenSet() const { return m_stateHasBeenSet; }
+
+    /**
+     * <p>The stream’s state.</p>
+     */
+    inline void SetState(const StreamState& value) { m_stateHasBeenSet = true; m_state = value; }
+
+    /**
+     * <p>The stream’s state.</p>
+     */
+    inline void SetState(StreamState&& value) { m_stateHasBeenSet = true; m_state = std::move(value); }
+
+    /**
+     * <p>The stream’s state.</p>
+     */
+    inline Stream& WithState(const StreamState& value) { SetState(value); return *this;}
+
+    /**
+     * <p>The stream’s state.</p>
+     */
+    inline Stream& WithState(StreamState&& value) { SetState(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The stream’s health.</p>
+     */
+    inline const StreamHealth& GetHealth() const{ return m_health; }
+
+    /**
+     * <p>The stream’s health.</p>
+     */
+    inline bool HealthHasBeenSet() const { return m_healthHasBeenSet; }
+
+    /**
+     * <p>The stream’s health.</p>
+     */
+    inline void SetHealth(const StreamHealth& value) { m_healthHasBeenSet = true; m_health = value; }
+
+    /**
+     * <p>The stream’s health.</p>
+     */
+    inline void SetHealth(StreamHealth&& value) { m_healthHasBeenSet = true; m_health = std::move(value); }
+
+    /**
+     * <p>The stream’s health.</p>
+     */
+    inline Stream& WithHealth(const StreamHealth& value) { SetHealth(value); return *this;}
+
+    /**
+     * <p>The stream’s health.</p>
+     */
+    inline Stream& WithHealth(StreamHealth&& value) { SetHealth(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Number of current viewers of the stream.</p>
+     */
+    inline long long GetViewerCount() const{ return m_viewerCount; }
+
+    /**
+     * <p>Number of current viewers of the stream.</p>
+     */
+    inline bool ViewerCountHasBeenSet() const { return m_viewerCountHasBeenSet; }
+
+    /**
+     * <p>Number of current viewers of the stream.</p>
+     */
+    inline void SetViewerCount(long long value) { m_viewerCountHasBeenSet = true; m_viewerCount = value; }
+
+    /**
+     * <p>Number of current viewers of the stream.</p>
+     */
+    inline Stream& WithViewerCount(long long value) { SetViewerCount(value); return *this;}
+
+  private:
+
+    Aws::String m_channelArn;
+    bool m_channelArnHasBeenSet;
+
+    Aws::String m_playbackUrl;
+    bool m_playbackUrlHasBeenSet;
+
+    Aws::Utils::DateTime m_startTime;
+    bool m_startTimeHasBeenSet;
+
+    StreamState m_state;
+    bool m_stateHasBeenSet;
+
+    StreamHealth m_health;
+    bool m_healthHasBeenSet;
+
+    long long m_viewerCount;
+    bool m_viewerCountHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/StreamHealth.h

@@ -0,0 +1,32 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+  enum class StreamHealth
+  {
+    NOT_SET,
+    HEALTHY,
+    STARVING,
+    UNKNOWN
+  };
+
+namespace StreamHealthMapper
+{
+AWS_IVS_API StreamHealth GetStreamHealthForName(const Aws::String& name);
+
+AWS_IVS_API Aws::String GetNameForStreamHealth(StreamHealth value);
+} // namespace StreamHealthMapper
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/StreamKey.h

@@ -0,0 +1,259 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   * <p>Object specifying a stream key.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/StreamKey">AWS API
+   * Reference</a></p>
+   */
+  class AWS_IVS_API StreamKey
+  {
+  public:
+    StreamKey();
+    StreamKey(Aws::Utils::Json::JsonView jsonValue);
+    StreamKey& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Stream-key ARN.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>Stream-key ARN.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>Stream-key ARN.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>Stream-key ARN.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>Stream-key ARN.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>Stream-key ARN.</p>
+     */
+    inline StreamKey& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>Stream-key ARN.</p>
+     */
+    inline StreamKey& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>Stream-key ARN.</p>
+     */
+    inline StreamKey& WithArn(const char* value) { SetArn(value); return *this;}
+
+
+    /**
+     * <p>Stream-key value.</p>
+     */
+    inline const Aws::String& GetValue() const{ return m_value; }
+
+    /**
+     * <p>Stream-key value.</p>
+     */
+    inline bool ValueHasBeenSet() const { return m_valueHasBeenSet; }
+
+    /**
+     * <p>Stream-key value.</p>
+     */
+    inline void SetValue(const Aws::String& value) { m_valueHasBeenSet = true; m_value = value; }
+
+    /**
+     * <p>Stream-key value.</p>
+     */
+    inline void SetValue(Aws::String&& value) { m_valueHasBeenSet = true; m_value = std::move(value); }
+
+    /**
+     * <p>Stream-key value.</p>
+     */
+    inline void SetValue(const char* value) { m_valueHasBeenSet = true; m_value.assign(value); }
+
+    /**
+     * <p>Stream-key value.</p>
+     */
+    inline StreamKey& WithValue(const Aws::String& value) { SetValue(value); return *this;}
+
+    /**
+     * <p>Stream-key value.</p>
+     */
+    inline StreamKey& WithValue(Aws::String&& value) { SetValue(std::move(value)); return *this;}
+
+    /**
+     * <p>Stream-key value.</p>
+     */
+    inline StreamKey& WithValue(const char* value) { SetValue(value); return *this;}
+
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline const Aws::String& GetChannelArn() const{ return m_channelArn; }
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline bool ChannelArnHasBeenSet() const { return m_channelArnHasBeenSet; }
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline void SetChannelArn(const Aws::String& value) { m_channelArnHasBeenSet = true; m_channelArn = value; }
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline void SetChannelArn(Aws::String&& value) { m_channelArnHasBeenSet = true; m_channelArn = std::move(value); }
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline void SetChannelArn(const char* value) { m_channelArnHasBeenSet = true; m_channelArn.assign(value); }
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline StreamKey& WithChannelArn(const Aws::String& value) { SetChannelArn(value); return *this;}
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline StreamKey& WithChannelArn(Aws::String&& value) { SetChannelArn(std::move(value)); return *this;}
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline StreamKey& WithChannelArn(const char* value) { SetChannelArn(value); return *this;}
+
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline void SetTags(const Aws::Map<Aws::String, Aws::String>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline void SetTags(Aws::Map<Aws::String, Aws::String>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline StreamKey& WithTags(const Aws::Map<Aws::String, Aws::String>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline StreamKey& WithTags(Aws::Map<Aws::String, Aws::String>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline StreamKey& AddTags(const Aws::String& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline StreamKey& AddTags(Aws::String&& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline StreamKey& AddTags(const Aws::String& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline StreamKey& AddTags(Aws::String&& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline StreamKey& AddTags(const char* key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline StreamKey& AddTags(Aws::String&& key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline StreamKey& AddTags(const char* key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+
+    Aws::String m_value;
+    bool m_valueHasBeenSet;
+
+    Aws::String m_channelArn;
+    bool m_channelArnHasBeenSet;
+
+    Aws::Map<Aws::String, Aws::String> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/StreamKeySummary.h

@@ -0,0 +1,215 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   * <p>Summary information about a stream key.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/StreamKeySummary">AWS
+   * API Reference</a></p>
+   */
+  class AWS_IVS_API StreamKeySummary
+  {
+  public:
+    StreamKeySummary();
+    StreamKeySummary(Aws::Utils::Json::JsonView jsonValue);
+    StreamKeySummary& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Stream-key ARN.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>Stream-key ARN.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>Stream-key ARN.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>Stream-key ARN.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>Stream-key ARN.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>Stream-key ARN.</p>
+     */
+    inline StreamKeySummary& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>Stream-key ARN.</p>
+     */
+    inline StreamKeySummary& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>Stream-key ARN.</p>
+     */
+    inline StreamKeySummary& WithArn(const char* value) { SetArn(value); return *this;}
+
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline const Aws::String& GetChannelArn() const{ return m_channelArn; }
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline bool ChannelArnHasBeenSet() const { return m_channelArnHasBeenSet; }
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline void SetChannelArn(const Aws::String& value) { m_channelArnHasBeenSet = true; m_channelArn = value; }
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline void SetChannelArn(Aws::String&& value) { m_channelArnHasBeenSet = true; m_channelArn = std::move(value); }
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline void SetChannelArn(const char* value) { m_channelArnHasBeenSet = true; m_channelArn.assign(value); }
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline StreamKeySummary& WithChannelArn(const Aws::String& value) { SetChannelArn(value); return *this;}
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline StreamKeySummary& WithChannelArn(Aws::String&& value) { SetChannelArn(std::move(value)); return *this;}
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline StreamKeySummary& WithChannelArn(const char* value) { SetChannelArn(value); return *this;}
+
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline void SetTags(const Aws::Map<Aws::String, Aws::String>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline void SetTags(Aws::Map<Aws::String, Aws::String>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline StreamKeySummary& WithTags(const Aws::Map<Aws::String, Aws::String>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline StreamKeySummary& WithTags(Aws::Map<Aws::String, Aws::String>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline StreamKeySummary& AddTags(const Aws::String& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline StreamKeySummary& AddTags(Aws::String&& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline StreamKeySummary& AddTags(const Aws::String& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline StreamKeySummary& AddTags(Aws::String&& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline StreamKeySummary& AddTags(const char* key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline StreamKeySummary& AddTags(Aws::String&& key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>Array of 1-50 maps, each of the form <code>string:string
+     * (key:value)</code>.</p>
+     */
+    inline StreamKeySummary& AddTags(const char* key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+
+    Aws::String m_channelArn;
+    bool m_channelArnHasBeenSet;
+
+    Aws::Map<Aws::String, Aws::String> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/StreamState.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/ivs/IVS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+  enum class StreamState
+  {
+    NOT_SET,
+    LIVE,
+    OFFLINE
+  };
+
+namespace StreamStateMapper
+{
+AWS_IVS_API StreamState GetStreamStateForName(const Aws::String& name);
+
+AWS_IVS_API Aws::String GetNameForStreamState(StreamState value);
+} // namespace StreamStateMapper
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/StreamSummary.h

@@ -0,0 +1,217 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/ivs/model/StreamState.h>
+#include <aws/ivs/model/StreamHealth.h>
+#include <aws/core/utils/DateTime.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   * <p>Summary information about a stream.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/StreamSummary">AWS
+   * API Reference</a></p>
+   */
+  class AWS_IVS_API StreamSummary
+  {
+  public:
+    StreamSummary();
+    StreamSummary(Aws::Utils::Json::JsonView jsonValue);
+    StreamSummary& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline const Aws::String& GetChannelArn() const{ return m_channelArn; }
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline bool ChannelArnHasBeenSet() const { return m_channelArnHasBeenSet; }
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline void SetChannelArn(const Aws::String& value) { m_channelArnHasBeenSet = true; m_channelArn = value; }
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline void SetChannelArn(Aws::String&& value) { m_channelArnHasBeenSet = true; m_channelArn = std::move(value); }
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline void SetChannelArn(const char* value) { m_channelArnHasBeenSet = true; m_channelArn.assign(value); }
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline StreamSummary& WithChannelArn(const Aws::String& value) { SetChannelArn(value); return *this;}
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline StreamSummary& WithChannelArn(Aws::String&& value) { SetChannelArn(std::move(value)); return *this;}
+
+    /**
+     * <p>Channel ARN for the stream.</p>
+     */
+    inline StreamSummary& WithChannelArn(const char* value) { SetChannelArn(value); return *this;}
+
+
+    /**
+     * <p>The stream’s state.</p>
+     */
+    inline const StreamState& GetState() const{ return m_state; }
+
+    /**
+     * <p>The stream’s state.</p>
+     */
+    inline bool StateHasBeenSet() const { return m_stateHasBeenSet; }
+
+    /**
+     * <p>The stream’s state.</p>
+     */
+    inline void SetState(const StreamState& value) { m_stateHasBeenSet = true; m_state = value; }
+
+    /**
+     * <p>The stream’s state.</p>
+     */
+    inline void SetState(StreamState&& value) { m_stateHasBeenSet = true; m_state = std::move(value); }
+
+    /**
+     * <p>The stream’s state.</p>
+     */
+    inline StreamSummary& WithState(const StreamState& value) { SetState(value); return *this;}
+
+    /**
+     * <p>The stream’s state.</p>
+     */
+    inline StreamSummary& WithState(StreamState&& value) { SetState(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The stream’s health.</p>
+     */
+    inline const StreamHealth& GetHealth() const{ return m_health; }
+
+    /**
+     * <p>The stream’s health.</p>
+     */
+    inline bool HealthHasBeenSet() const { return m_healthHasBeenSet; }
+
+    /**
+     * <p>The stream’s health.</p>
+     */
+    inline void SetHealth(const StreamHealth& value) { m_healthHasBeenSet = true; m_health = value; }
+
+    /**
+     * <p>The stream’s health.</p>
+     */
+    inline void SetHealth(StreamHealth&& value) { m_healthHasBeenSet = true; m_health = std::move(value); }
+
+    /**
+     * <p>The stream’s health.</p>
+     */
+    inline StreamSummary& WithHealth(const StreamHealth& value) { SetHealth(value); return *this;}
+
+    /**
+     * <p>The stream’s health.</p>
+     */
+    inline StreamSummary& WithHealth(StreamHealth&& value) { SetHealth(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Number of current viewers of the stream.</p>
+     */
+    inline long long GetViewerCount() const{ return m_viewerCount; }
+
+    /**
+     * <p>Number of current viewers of the stream.</p>
+     */
+    inline bool ViewerCountHasBeenSet() const { return m_viewerCountHasBeenSet; }
+
+    /**
+     * <p>Number of current viewers of the stream.</p>
+     */
+    inline void SetViewerCount(long long value) { m_viewerCountHasBeenSet = true; m_viewerCount = value; }
+
+    /**
+     * <p>Number of current viewers of the stream.</p>
+     */
+    inline StreamSummary& WithViewerCount(long long value) { SetViewerCount(value); return *this;}
+
+
+    /**
+     * <p>ISO-8601 formatted timestamp of the stream’s start.</p>
+     */
+    inline const Aws::Utils::DateTime& GetStartTime() const{ return m_startTime; }
+
+    /**
+     * <p>ISO-8601 formatted timestamp of the stream’s start.</p>
+     */
+    inline bool StartTimeHasBeenSet() const { return m_startTimeHasBeenSet; }
+
+    /**
+     * <p>ISO-8601 formatted timestamp of the stream’s start.</p>
+     */
+    inline void SetStartTime(const Aws::Utils::DateTime& value) { m_startTimeHasBeenSet = true; m_startTime = value; }
+
+    /**
+     * <p>ISO-8601 formatted timestamp of the stream’s start.</p>
+     */
+    inline void SetStartTime(Aws::Utils::DateTime&& value) { m_startTimeHasBeenSet = true; m_startTime = std::move(value); }
+
+    /**
+     * <p>ISO-8601 formatted timestamp of the stream’s start.</p>
+     */
+    inline StreamSummary& WithStartTime(const Aws::Utils::DateTime& value) { SetStartTime(value); return *this;}
+
+    /**
+     * <p>ISO-8601 formatted timestamp of the stream’s start.</p>
+     */
+    inline StreamSummary& WithStartTime(Aws::Utils::DateTime&& value) { SetStartTime(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_channelArn;
+    bool m_channelArnHasBeenSet;
+
+    StreamState m_state;
+    bool m_stateHasBeenSet;
+
+    StreamHealth m_health;
+    bool m_healthHasBeenSet;
+
+    long long m_viewerCount;
+    bool m_viewerCountHasBeenSet;
+
+    Aws::Utils::DateTime m_startTime;
+    bool m_startTimeHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/StreamUnavailable.h

@@ -0,0 +1,83 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_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 IVS
+{
+namespace Model
+{
+
+  class AWS_IVS_API StreamUnavailable
+  {
+  public:
+    StreamUnavailable();
+    StreamUnavailable(Aws::Utils::Json::JsonView jsonValue);
+    StreamUnavailable& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The stream is temporarily unavailable.</p>
+     */
+    inline const Aws::String& GetExceptionMessage() const{ return m_exceptionMessage; }
+
+    /**
+     * <p>The stream is temporarily unavailable.</p>
+     */
+    inline bool ExceptionMessageHasBeenSet() const { return m_exceptionMessageHasBeenSet; }
+
+    /**
+     * <p>The stream is temporarily unavailable.</p>
+     */
+    inline void SetExceptionMessage(const Aws::String& value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage = value; }
+
+    /**
+     * <p>The stream is temporarily unavailable.</p>
+     */
+    inline void SetExceptionMessage(Aws::String&& value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage = std::move(value); }
+
+    /**
+     * <p>The stream is temporarily unavailable.</p>
+     */
+    inline void SetExceptionMessage(const char* value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage.assign(value); }
+
+    /**
+     * <p>The stream is temporarily unavailable.</p>
+     */
+    inline StreamUnavailable& WithExceptionMessage(const Aws::String& value) { SetExceptionMessage(value); return *this;}
+
+    /**
+     * <p>The stream is temporarily unavailable.</p>
+     */
+    inline StreamUnavailable& WithExceptionMessage(Aws::String&& value) { SetExceptionMessage(std::move(value)); return *this;}
+
+    /**
+     * <p>The stream is temporarily unavailable.</p>
+     */
+    inline StreamUnavailable& WithExceptionMessage(const char* value) { SetExceptionMessage(value); return *this;}
+
+  private:
+
+    Aws::String m_exceptionMessage;
+    bool m_exceptionMessageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

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

@@ -0,0 +1,153 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_IVS_API TagResourceRequest : public IVSRequest
+  {
+  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>ARN of the resource for which tags are to be added or updated.</p>
+     */
+    inline const Aws::String& GetResourceArn() const{ return m_resourceArn; }
+
+    /**
+     * <p>ARN of the resource for which tags are to be added or updated.</p>
+     */
+    inline bool ResourceArnHasBeenSet() const { return m_resourceArnHasBeenSet; }
+
+    /**
+     * <p>ARN of the resource for which tags are to be added or updated.</p>
+     */
+    inline void SetResourceArn(const Aws::String& value) { m_resourceArnHasBeenSet = true; m_resourceArn = value; }
+
+    /**
+     * <p>ARN of the resource for which tags are to be added or updated.</p>
+     */
+    inline void SetResourceArn(Aws::String&& value) { m_resourceArnHasBeenSet = true; m_resourceArn = std::move(value); }
+
+    /**
+     * <p>ARN of the resource for which tags are to be added or updated.</p>
+     */
+    inline void SetResourceArn(const char* value) { m_resourceArnHasBeenSet = true; m_resourceArn.assign(value); }
+
+    /**
+     * <p>ARN of the resource for which tags are to be added or updated.</p>
+     */
+    inline TagResourceRequest& WithResourceArn(const Aws::String& value) { SetResourceArn(value); return *this;}
+
+    /**
+     * <p>ARN of the resource for which tags are to be added or updated.</p>
+     */
+    inline TagResourceRequest& WithResourceArn(Aws::String&& value) { SetResourceArn(std::move(value)); return *this;}
+
+    /**
+     * <p>ARN of the resource for which tags are to be added or updated.</p>
+     */
+    inline TagResourceRequest& WithResourceArn(const char* value) { SetResourceArn(value); return *this;}
+
+
+    /**
+     * <p>Array of tags to be added or updated.</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>Array of tags to be added or updated.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>Array of tags to be added or updated.</p>
+     */
+    inline void SetTags(const Aws::Map<Aws::String, Aws::String>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>Array of tags to be added or updated.</p>
+     */
+    inline void SetTags(Aws::Map<Aws::String, Aws::String>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>Array of tags to be added or updated.</p>
+     */
+    inline TagResourceRequest& WithTags(const Aws::Map<Aws::String, Aws::String>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>Array of tags to be added or updated.</p>
+     */
+    inline TagResourceRequest& WithTags(Aws::Map<Aws::String, Aws::String>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>Array of tags to be added or updated.</p>
+     */
+    inline TagResourceRequest& AddTags(const Aws::String& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+    /**
+     * <p>Array of tags to be added or updated.</p>
+     */
+    inline TagResourceRequest& AddTags(Aws::String&& key, const Aws::String& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>Array of tags to be added or updated.</p>
+     */
+    inline TagResourceRequest& AddTags(const Aws::String& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>Array of tags to be added or updated.</p>
+     */
+    inline TagResourceRequest& AddTags(Aws::String&& key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), std::move(value)); return *this; }
+
+    /**
+     * <p>Array of tags to be added or updated.</p>
+     */
+    inline TagResourceRequest& AddTags(const char* key, Aws::String&& value) { m_tagsHasBeenSet = true; m_tags.emplace(key, std::move(value)); return *this; }
+
+    /**
+     * <p>Array of tags to be added or updated.</p>
+     */
+    inline TagResourceRequest& AddTags(Aws::String&& key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(std::move(key), value); return *this; }
+
+    /**
+     * <p>Array of tags to be added or updated.</p>
+     */
+    inline TagResourceRequest& AddTags(const char* key, const char* value) { m_tagsHasBeenSet = true; m_tags.emplace(key, value); return *this; }
+
+  private:
+
+    Aws::String m_resourceArn;
+    bool m_resourceArnHasBeenSet;
+
+    Aws::Map<Aws::String, Aws::String> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

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

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/ThrottlingException.h

@@ -0,0 +1,83 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_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 IVS
+{
+namespace Model
+{
+
+  class AWS_IVS_API ThrottlingException
+  {
+  public:
+    ThrottlingException();
+    ThrottlingException(Aws::Utils::Json::JsonView jsonValue);
+    ThrottlingException& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>Request was denied due to request throttling.</p>
+     */
+    inline const Aws::String& GetExceptionMessage() const{ return m_exceptionMessage; }
+
+    /**
+     * <p>Request was denied due to request throttling.</p>
+     */
+    inline bool ExceptionMessageHasBeenSet() const { return m_exceptionMessageHasBeenSet; }
+
+    /**
+     * <p>Request was denied due to request throttling.</p>
+     */
+    inline void SetExceptionMessage(const Aws::String& value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage = value; }
+
+    /**
+     * <p>Request was denied due to request throttling.</p>
+     */
+    inline void SetExceptionMessage(Aws::String&& value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage = std::move(value); }
+
+    /**
+     * <p>Request was denied due to request throttling.</p>
+     */
+    inline void SetExceptionMessage(const char* value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage.assign(value); }
+
+    /**
+     * <p>Request was denied due to request throttling.</p>
+     */
+    inline ThrottlingException& WithExceptionMessage(const Aws::String& value) { SetExceptionMessage(value); return *this;}
+
+    /**
+     * <p>Request was denied due to request throttling.</p>
+     */
+    inline ThrottlingException& WithExceptionMessage(Aws::String&& value) { SetExceptionMessage(std::move(value)); return *this;}
+
+    /**
+     * <p>Request was denied due to request throttling.</p>
+     */
+    inline ThrottlingException& WithExceptionMessage(const char* value) { SetExceptionMessage(value); return *this;}
+
+  private:
+
+    Aws::String m_exceptionMessage;
+    bool m_exceptionMessageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/UntagResourceRequest.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/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_IVS_API UntagResourceRequest : public IVSRequest
+  {
+  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;
+
+    void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+
+    /**
+     * <p>ARN of the resource for which tags are to be removed.</p>
+     */
+    inline const Aws::String& GetResourceArn() const{ return m_resourceArn; }
+
+    /**
+     * <p>ARN of the resource for which tags are to be removed.</p>
+     */
+    inline bool ResourceArnHasBeenSet() const { return m_resourceArnHasBeenSet; }
+
+    /**
+     * <p>ARN of the resource for which tags are to be removed.</p>
+     */
+    inline void SetResourceArn(const Aws::String& value) { m_resourceArnHasBeenSet = true; m_resourceArn = value; }
+
+    /**
+     * <p>ARN of the resource for which tags are to be removed.</p>
+     */
+    inline void SetResourceArn(Aws::String&& value) { m_resourceArnHasBeenSet = true; m_resourceArn = std::move(value); }
+
+    /**
+     * <p>ARN of the resource for which tags are to be removed.</p>
+     */
+    inline void SetResourceArn(const char* value) { m_resourceArnHasBeenSet = true; m_resourceArn.assign(value); }
+
+    /**
+     * <p>ARN of the resource for which tags are to be removed.</p>
+     */
+    inline UntagResourceRequest& WithResourceArn(const Aws::String& value) { SetResourceArn(value); return *this;}
+
+    /**
+     * <p>ARN of the resource for which tags are to be removed.</p>
+     */
+    inline UntagResourceRequest& WithResourceArn(Aws::String&& value) { SetResourceArn(std::move(value)); return *this;}
+
+    /**
+     * <p>ARN of the resource for which tags are to be removed.</p>
+     */
+    inline UntagResourceRequest& WithResourceArn(const char* value) { SetResourceArn(value); return *this;}
+
+
+    /**
+     * <p>Array of tags to be removed.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetTagKeys() const{ return m_tagKeys; }
+
+    /**
+     * <p>Array of tags to be removed.</p>
+     */
+    inline bool TagKeysHasBeenSet() const { return m_tagKeysHasBeenSet; }
+
+    /**
+     * <p>Array of tags to be removed.</p>
+     */
+    inline void SetTagKeys(const Aws::Vector<Aws::String>& value) { m_tagKeysHasBeenSet = true; m_tagKeys = value; }
+
+    /**
+     * <p>Array of tags to be removed.</p>
+     */
+    inline void SetTagKeys(Aws::Vector<Aws::String>&& value) { m_tagKeysHasBeenSet = true; m_tagKeys = std::move(value); }
+
+    /**
+     * <p>Array of tags to be removed.</p>
+     */
+    inline UntagResourceRequest& WithTagKeys(const Aws::Vector<Aws::String>& value) { SetTagKeys(value); return *this;}
+
+    /**
+     * <p>Array of tags to be removed.</p>
+     */
+    inline UntagResourceRequest& WithTagKeys(Aws::Vector<Aws::String>&& value) { SetTagKeys(std::move(value)); return *this;}
+
+    /**
+     * <p>Array of tags to be removed.</p>
+     */
+    inline UntagResourceRequest& AddTagKeys(const Aws::String& value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(value); return *this; }
+
+    /**
+     * <p>Array of tags to be removed.</p>
+     */
+    inline UntagResourceRequest& AddTagKeys(Aws::String&& value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>Array of tags to be removed.</p>
+     */
+    inline UntagResourceRequest& AddTagKeys(const char* value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(value); return *this; }
+
+  private:
+
+    Aws::String m_resourceArn;
+    bool m_resourceArnHasBeenSet;
+
+    Aws::Vector<Aws::String> m_tagKeys;
+    bool m_tagKeysHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

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

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/UpdateChannelRequest.h

@@ -0,0 +1,275 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/IVSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/ivs/model/ChannelLatencyMode.h>
+#include <aws/ivs/model/ChannelType.h>
+#include <utility>
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_IVS_API UpdateChannelRequest : public IVSRequest
+  {
+  public:
+    UpdateChannelRequest();
+
+    // 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 "UpdateChannel"; }
+
+    Aws::String SerializePayload() const override;
+
+
+    /**
+     * <p>ARN of the channel to be updated.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>ARN of the channel to be updated.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>ARN of the channel to be updated.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>ARN of the channel to be updated.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>ARN of the channel to be updated.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>ARN of the channel to be updated.</p>
+     */
+    inline UpdateChannelRequest& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>ARN of the channel to be updated.</p>
+     */
+    inline UpdateChannelRequest& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>ARN of the channel to be updated.</p>
+     */
+    inline UpdateChannelRequest& WithArn(const char* value) { SetArn(value); return *this;}
+
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline UpdateChannelRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline UpdateChannelRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>Channel name.</p>
+     */
+    inline UpdateChannelRequest& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline const ChannelLatencyMode& GetLatencyMode() const{ return m_latencyMode; }
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline bool LatencyModeHasBeenSet() const { return m_latencyModeHasBeenSet; }
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline void SetLatencyMode(const ChannelLatencyMode& value) { m_latencyModeHasBeenSet = true; m_latencyMode = value; }
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline void SetLatencyMode(ChannelLatencyMode&& value) { m_latencyModeHasBeenSet = true; m_latencyMode = std::move(value); }
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline UpdateChannelRequest& WithLatencyMode(const ChannelLatencyMode& value) { SetLatencyMode(value); return *this;}
+
+    /**
+     * <p>Channel latency mode. Default: <code>LOW</code>.</p>
+     */
+    inline UpdateChannelRequest& WithLatencyMode(ChannelLatencyMode&& value) { SetLatencyMode(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Channel type, which determines the allowable resolution and bitrate. <i>If
+     * you exceed the allowable resolution or bitrate, the stream probably will
+     * disconnect immediately.</i> Valid values:</p> <ul> <li> <p>
+     * <code>STANDARD</code>: Multiple qualities are generated from the original input,
+     * to automatically give viewers the best experience for their devices and network
+     * conditions. Vertical resolution can be up to 1080 and bitrate can be up to 8.5
+     * Mbps.</p> </li> <li> <p> <code>BASIC</code>: Amazon IVS delivers the original
+     * input to viewers. The viewer’s video-quality choice is limited to the original
+     * input. Vertical resolution can be up to 480 and bitrate can be up to 1.5
+     * Mbps.</p> </li> </ul> <p>Default: <code>STANDARD</code>.</p>
+     */
+    inline const ChannelType& GetType() const{ return m_type; }
+
+    /**
+     * <p>Channel type, which determines the allowable resolution and bitrate. <i>If
+     * you exceed the allowable resolution or bitrate, the stream probably will
+     * disconnect immediately.</i> Valid values:</p> <ul> <li> <p>
+     * <code>STANDARD</code>: Multiple qualities are generated from the original input,
+     * to automatically give viewers the best experience for their devices and network
+     * conditions. Vertical resolution can be up to 1080 and bitrate can be up to 8.5
+     * Mbps.</p> </li> <li> <p> <code>BASIC</code>: Amazon IVS delivers the original
+     * input to viewers. The viewer’s video-quality choice is limited to the original
+     * input. Vertical resolution can be up to 480 and bitrate can be up to 1.5
+     * Mbps.</p> </li> </ul> <p>Default: <code>STANDARD</code>.</p>
+     */
+    inline bool TypeHasBeenSet() const { return m_typeHasBeenSet; }
+
+    /**
+     * <p>Channel type, which determines the allowable resolution and bitrate. <i>If
+     * you exceed the allowable resolution or bitrate, the stream probably will
+     * disconnect immediately.</i> Valid values:</p> <ul> <li> <p>
+     * <code>STANDARD</code>: Multiple qualities are generated from the original input,
+     * to automatically give viewers the best experience for their devices and network
+     * conditions. Vertical resolution can be up to 1080 and bitrate can be up to 8.5
+     * Mbps.</p> </li> <li> <p> <code>BASIC</code>: Amazon IVS delivers the original
+     * input to viewers. The viewer’s video-quality choice is limited to the original
+     * input. Vertical resolution can be up to 480 and bitrate can be up to 1.5
+     * Mbps.</p> </li> </ul> <p>Default: <code>STANDARD</code>.</p>
+     */
+    inline void SetType(const ChannelType& value) { m_typeHasBeenSet = true; m_type = value; }
+
+    /**
+     * <p>Channel type, which determines the allowable resolution and bitrate. <i>If
+     * you exceed the allowable resolution or bitrate, the stream probably will
+     * disconnect immediately.</i> Valid values:</p> <ul> <li> <p>
+     * <code>STANDARD</code>: Multiple qualities are generated from the original input,
+     * to automatically give viewers the best experience for their devices and network
+     * conditions. Vertical resolution can be up to 1080 and bitrate can be up to 8.5
+     * Mbps.</p> </li> <li> <p> <code>BASIC</code>: Amazon IVS delivers the original
+     * input to viewers. The viewer’s video-quality choice is limited to the original
+     * input. Vertical resolution can be up to 480 and bitrate can be up to 1.5
+     * Mbps.</p> </li> </ul> <p>Default: <code>STANDARD</code>.</p>
+     */
+    inline void SetType(ChannelType&& value) { m_typeHasBeenSet = true; m_type = std::move(value); }
+
+    /**
+     * <p>Channel type, which determines the allowable resolution and bitrate. <i>If
+     * you exceed the allowable resolution or bitrate, the stream probably will
+     * disconnect immediately.</i> Valid values:</p> <ul> <li> <p>
+     * <code>STANDARD</code>: Multiple qualities are generated from the original input,
+     * to automatically give viewers the best experience for their devices and network
+     * conditions. Vertical resolution can be up to 1080 and bitrate can be up to 8.5
+     * Mbps.</p> </li> <li> <p> <code>BASIC</code>: Amazon IVS delivers the original
+     * input to viewers. The viewer’s video-quality choice is limited to the original
+     * input. Vertical resolution can be up to 480 and bitrate can be up to 1.5
+     * Mbps.</p> </li> </ul> <p>Default: <code>STANDARD</code>.</p>
+     */
+    inline UpdateChannelRequest& WithType(const ChannelType& value) { SetType(value); return *this;}
+
+    /**
+     * <p>Channel type, which determines the allowable resolution and bitrate. <i>If
+     * you exceed the allowable resolution or bitrate, the stream probably will
+     * disconnect immediately.</i> Valid values:</p> <ul> <li> <p>
+     * <code>STANDARD</code>: Multiple qualities are generated from the original input,
+     * to automatically give viewers the best experience for their devices and network
+     * conditions. Vertical resolution can be up to 1080 and bitrate can be up to 8.5
+     * Mbps.</p> </li> <li> <p> <code>BASIC</code>: Amazon IVS delivers the original
+     * input to viewers. The viewer’s video-quality choice is limited to the original
+     * input. Vertical resolution can be up to 480 and bitrate can be up to 1.5
+     * Mbps.</p> </li> </ul> <p>Default: <code>STANDARD</code>.</p>
+     */
+    inline UpdateChannelRequest& WithType(ChannelType&& value) { SetType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Whether the channel is authorized. Default: <code>false</code>.</p>
+     */
+    inline bool GetAuthorized() const{ return m_authorized; }
+
+    /**
+     * <p>Whether the channel is authorized. Default: <code>false</code>.</p>
+     */
+    inline bool AuthorizedHasBeenSet() const { return m_authorizedHasBeenSet; }
+
+    /**
+     * <p>Whether the channel is authorized. Default: <code>false</code>.</p>
+     */
+    inline void SetAuthorized(bool value) { m_authorizedHasBeenSet = true; m_authorized = value; }
+
+    /**
+     * <p>Whether the channel is authorized. Default: <code>false</code>.</p>
+     */
+    inline UpdateChannelRequest& WithAuthorized(bool value) { SetAuthorized(value); return *this;}
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    ChannelLatencyMode m_latencyMode;
+    bool m_latencyModeHasBeenSet;
+
+    ChannelType m_type;
+    bool m_typeHasBeenSet;
+
+    bool m_authorized;
+    bool m_authorizedHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/UpdateChannelResult.h

@@ -0,0 +1,57 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_EXPORTS.h>
+#include <aws/ivs/model/Channel.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace IVS
+{
+namespace Model
+{
+  class AWS_IVS_API UpdateChannelResult
+  {
+  public:
+    UpdateChannelResult();
+    UpdateChannelResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    UpdateChannelResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    
+    inline const Channel& GetChannel() const{ return m_channel; }
+
+    
+    inline void SetChannel(const Channel& value) { m_channel = value; }
+
+    
+    inline void SetChannel(Channel&& value) { m_channel = std::move(value); }
+
+    
+    inline UpdateChannelResult& WithChannel(const Channel& value) { SetChannel(value); return *this;}
+
+    
+    inline UpdateChannelResult& WithChannel(Channel&& value) { SetChannel(std::move(value)); return *this;}
+
+  private:
+
+    Channel m_channel;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/include/aws/ivs/model/ValidationException.h

@@ -0,0 +1,83 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/ivs/IVS_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 IVS
+{
+namespace Model
+{
+
+  class AWS_IVS_API ValidationException
+  {
+  public:
+    ValidationException();
+    ValidationException(Aws::Utils::Json::JsonView jsonValue);
+    ValidationException& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The input fails to satisfy the constraints specified by an AWS service.</p>
+     */
+    inline const Aws::String& GetExceptionMessage() const{ return m_exceptionMessage; }
+
+    /**
+     * <p>The input fails to satisfy the constraints specified by an AWS service.</p>
+     */
+    inline bool ExceptionMessageHasBeenSet() const { return m_exceptionMessageHasBeenSet; }
+
+    /**
+     * <p>The input fails to satisfy the constraints specified by an AWS service.</p>
+     */
+    inline void SetExceptionMessage(const Aws::String& value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage = value; }
+
+    /**
+     * <p>The input fails to satisfy the constraints specified by an AWS service.</p>
+     */
+    inline void SetExceptionMessage(Aws::String&& value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage = std::move(value); }
+
+    /**
+     * <p>The input fails to satisfy the constraints specified by an AWS service.</p>
+     */
+    inline void SetExceptionMessage(const char* value) { m_exceptionMessageHasBeenSet = true; m_exceptionMessage.assign(value); }
+
+    /**
+     * <p>The input fails to satisfy the constraints specified by an AWS service.</p>
+     */
+    inline ValidationException& WithExceptionMessage(const Aws::String& value) { SetExceptionMessage(value); return *this;}
+
+    /**
+     * <p>The input fails to satisfy the constraints specified by an AWS service.</p>
+     */
+    inline ValidationException& WithExceptionMessage(Aws::String&& value) { SetExceptionMessage(std::move(value)); return *this;}
+
+    /**
+     * <p>The input fails to satisfy the constraints specified by an AWS service.</p>
+     */
+    inline ValidationException& WithExceptionMessage(const char* value) { SetExceptionMessage(value); return *this;}
+
+  private:
+
+    Aws::String m_exceptionMessage;
+    bool m_exceptionMessageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/IVSClient.cpp

@@ -0,0 +1,735 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/core/utils/Outcome.h>
+#include <aws/core/auth/AWSAuthSigner.h>
+#include <aws/core/client/CoreErrors.h>
+#include <aws/core/client/RetryStrategy.h>
+#include <aws/core/http/HttpClient.h>
+#include <aws/core/http/HttpResponse.h>
+#include <aws/core/http/HttpClientFactory.h>
+#include <aws/core/auth/AWSCredentialsProviderChain.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+#include <aws/core/utils/threading/Executor.h>
+#include <aws/core/utils/DNS.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <aws/ivs/IVSClient.h>
+#include <aws/ivs/IVSEndpoint.h>
+#include <aws/ivs/IVSErrorMarshaller.h>
+#include <aws/ivs/model/BatchGetChannelRequest.h>
+#include <aws/ivs/model/BatchGetStreamKeyRequest.h>
+#include <aws/ivs/model/CreateChannelRequest.h>
+#include <aws/ivs/model/CreateStreamKeyRequest.h>
+#include <aws/ivs/model/DeleteChannelRequest.h>
+#include <aws/ivs/model/DeletePlaybackKeyPairRequest.h>
+#include <aws/ivs/model/DeleteStreamKeyRequest.h>
+#include <aws/ivs/model/GetChannelRequest.h>
+#include <aws/ivs/model/GetPlaybackKeyPairRequest.h>
+#include <aws/ivs/model/GetStreamRequest.h>
+#include <aws/ivs/model/GetStreamKeyRequest.h>
+#include <aws/ivs/model/ImportPlaybackKeyPairRequest.h>
+#include <aws/ivs/model/ListChannelsRequest.h>
+#include <aws/ivs/model/ListPlaybackKeyPairsRequest.h>
+#include <aws/ivs/model/ListStreamKeysRequest.h>
+#include <aws/ivs/model/ListStreamsRequest.h>
+#include <aws/ivs/model/ListTagsForResourceRequest.h>
+#include <aws/ivs/model/PutMetadataRequest.h>
+#include <aws/ivs/model/StopStreamRequest.h>
+#include <aws/ivs/model/TagResourceRequest.h>
+#include <aws/ivs/model/UntagResourceRequest.h>
+#include <aws/ivs/model/UpdateChannelRequest.h>
+
+using namespace Aws;
+using namespace Aws::Auth;
+using namespace Aws::Client;
+using namespace Aws::IVS;
+using namespace Aws::IVS::Model;
+using namespace Aws::Http;
+using namespace Aws::Utils::Json;
+
+static const char* SERVICE_NAME = "ivs";
+static const char* ALLOCATION_TAG = "IVSClient";
+
+
+IVSClient::IVSClient(const Client::ClientConfiguration& clientConfiguration) :
+  BASECLASS(clientConfiguration,
+    Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<DefaultAWSCredentialsProviderChain>(ALLOCATION_TAG),
+        SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
+    Aws::MakeShared<IVSErrorMarshaller>(ALLOCATION_TAG)),
+    m_executor(clientConfiguration.executor)
+{
+  init(clientConfiguration);
+}
+
+IVSClient::IVSClient(const AWSCredentials& credentials, const Client::ClientConfiguration& clientConfiguration) :
+  BASECLASS(clientConfiguration,
+    Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<SimpleAWSCredentialsProvider>(ALLOCATION_TAG, credentials),
+         SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
+    Aws::MakeShared<IVSErrorMarshaller>(ALLOCATION_TAG)),
+    m_executor(clientConfiguration.executor)
+{
+  init(clientConfiguration);
+}
+
+IVSClient::IVSClient(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider,
+  const Client::ClientConfiguration& clientConfiguration) :
+  BASECLASS(clientConfiguration,
+    Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, credentialsProvider,
+         SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
+    Aws::MakeShared<IVSErrorMarshaller>(ALLOCATION_TAG)),
+    m_executor(clientConfiguration.executor)
+{
+  init(clientConfiguration);
+}
+
+IVSClient::~IVSClient()
+{
+}
+
+void IVSClient::init(const ClientConfiguration& config)
+{
+  SetServiceClientName("ivs");
+  m_configScheme = SchemeMapper::ToString(config.scheme);
+  if (config.endpointOverride.empty())
+  {
+      m_uri = m_configScheme + "://" + IVSEndpoint::ForRegion(config.region, config.useDualStack);
+  }
+  else
+  {
+      OverrideEndpoint(config.endpointOverride);
+  }
+}
+
+void IVSClient::OverrideEndpoint(const Aws::String& endpoint)
+{
+  if (endpoint.compare(0, 7, "http://") == 0 || endpoint.compare(0, 8, "https://") == 0)
+  {
+      m_uri = endpoint;
+  }
+  else
+  {
+      m_uri = m_configScheme + "://" + endpoint;
+  }
+}
+
+BatchGetChannelOutcome IVSClient::BatchGetChannel(const BatchGetChannelRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/BatchGetChannel";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return BatchGetChannelOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+BatchGetChannelOutcomeCallable IVSClient::BatchGetChannelCallable(const BatchGetChannelRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< BatchGetChannelOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->BatchGetChannel(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IVSClient::BatchGetChannelAsync(const BatchGetChannelRequest& request, const BatchGetChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->BatchGetChannelAsyncHelper( request, handler, context ); } );
+}
+
+void IVSClient::BatchGetChannelAsyncHelper(const BatchGetChannelRequest& request, const BatchGetChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, BatchGetChannel(request), context);
+}
+
+BatchGetStreamKeyOutcome IVSClient::BatchGetStreamKey(const BatchGetStreamKeyRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/BatchGetStreamKey";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return BatchGetStreamKeyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+BatchGetStreamKeyOutcomeCallable IVSClient::BatchGetStreamKeyCallable(const BatchGetStreamKeyRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< BatchGetStreamKeyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->BatchGetStreamKey(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IVSClient::BatchGetStreamKeyAsync(const BatchGetStreamKeyRequest& request, const BatchGetStreamKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->BatchGetStreamKeyAsyncHelper( request, handler, context ); } );
+}
+
+void IVSClient::BatchGetStreamKeyAsyncHelper(const BatchGetStreamKeyRequest& request, const BatchGetStreamKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, BatchGetStreamKey(request), context);
+}
+
+CreateChannelOutcome IVSClient::CreateChannel(const CreateChannelRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/CreateChannel";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return CreateChannelOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+CreateChannelOutcomeCallable IVSClient::CreateChannelCallable(const CreateChannelRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< CreateChannelOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateChannel(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IVSClient::CreateChannelAsync(const CreateChannelRequest& request, const CreateChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->CreateChannelAsyncHelper( request, handler, context ); } );
+}
+
+void IVSClient::CreateChannelAsyncHelper(const CreateChannelRequest& request, const CreateChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, CreateChannel(request), context);
+}
+
+CreateStreamKeyOutcome IVSClient::CreateStreamKey(const CreateStreamKeyRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/CreateStreamKey";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return CreateStreamKeyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+CreateStreamKeyOutcomeCallable IVSClient::CreateStreamKeyCallable(const CreateStreamKeyRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< CreateStreamKeyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateStreamKey(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IVSClient::CreateStreamKeyAsync(const CreateStreamKeyRequest& request, const CreateStreamKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->CreateStreamKeyAsyncHelper( request, handler, context ); } );
+}
+
+void IVSClient::CreateStreamKeyAsyncHelper(const CreateStreamKeyRequest& request, const CreateStreamKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, CreateStreamKey(request), context);
+}
+
+DeleteChannelOutcome IVSClient::DeleteChannel(const DeleteChannelRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/DeleteChannel";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DeleteChannelOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+DeleteChannelOutcomeCallable IVSClient::DeleteChannelCallable(const DeleteChannelRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DeleteChannelOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteChannel(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IVSClient::DeleteChannelAsync(const DeleteChannelRequest& request, const DeleteChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DeleteChannelAsyncHelper( request, handler, context ); } );
+}
+
+void IVSClient::DeleteChannelAsyncHelper(const DeleteChannelRequest& request, const DeleteChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DeleteChannel(request), context);
+}
+
+DeletePlaybackKeyPairOutcome IVSClient::DeletePlaybackKeyPair(const DeletePlaybackKeyPairRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/DeletePlaybackKeyPair";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DeletePlaybackKeyPairOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+DeletePlaybackKeyPairOutcomeCallable IVSClient::DeletePlaybackKeyPairCallable(const DeletePlaybackKeyPairRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DeletePlaybackKeyPairOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeletePlaybackKeyPair(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IVSClient::DeletePlaybackKeyPairAsync(const DeletePlaybackKeyPairRequest& request, const DeletePlaybackKeyPairResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DeletePlaybackKeyPairAsyncHelper( request, handler, context ); } );
+}
+
+void IVSClient::DeletePlaybackKeyPairAsyncHelper(const DeletePlaybackKeyPairRequest& request, const DeletePlaybackKeyPairResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DeletePlaybackKeyPair(request), context);
+}
+
+DeleteStreamKeyOutcome IVSClient::DeleteStreamKey(const DeleteStreamKeyRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/DeleteStreamKey";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DeleteStreamKeyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+DeleteStreamKeyOutcomeCallable IVSClient::DeleteStreamKeyCallable(const DeleteStreamKeyRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DeleteStreamKeyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteStreamKey(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IVSClient::DeleteStreamKeyAsync(const DeleteStreamKeyRequest& request, const DeleteStreamKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DeleteStreamKeyAsyncHelper( request, handler, context ); } );
+}
+
+void IVSClient::DeleteStreamKeyAsyncHelper(const DeleteStreamKeyRequest& request, const DeleteStreamKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DeleteStreamKey(request), context);
+}
+
+GetChannelOutcome IVSClient::GetChannel(const GetChannelRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/GetChannel";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return GetChannelOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+GetChannelOutcomeCallable IVSClient::GetChannelCallable(const GetChannelRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< GetChannelOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetChannel(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IVSClient::GetChannelAsync(const GetChannelRequest& request, const GetChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->GetChannelAsyncHelper( request, handler, context ); } );
+}
+
+void IVSClient::GetChannelAsyncHelper(const GetChannelRequest& request, const GetChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, GetChannel(request), context);
+}
+
+GetPlaybackKeyPairOutcome IVSClient::GetPlaybackKeyPair(const GetPlaybackKeyPairRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/GetPlaybackKeyPair";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return GetPlaybackKeyPairOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+GetPlaybackKeyPairOutcomeCallable IVSClient::GetPlaybackKeyPairCallable(const GetPlaybackKeyPairRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< GetPlaybackKeyPairOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetPlaybackKeyPair(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IVSClient::GetPlaybackKeyPairAsync(const GetPlaybackKeyPairRequest& request, const GetPlaybackKeyPairResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->GetPlaybackKeyPairAsyncHelper( request, handler, context ); } );
+}
+
+void IVSClient::GetPlaybackKeyPairAsyncHelper(const GetPlaybackKeyPairRequest& request, const GetPlaybackKeyPairResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, GetPlaybackKeyPair(request), context);
+}
+
+GetStreamOutcome IVSClient::GetStream(const GetStreamRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/GetStream";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return GetStreamOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+GetStreamOutcomeCallable IVSClient::GetStreamCallable(const GetStreamRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< GetStreamOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetStream(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IVSClient::GetStreamAsync(const GetStreamRequest& request, const GetStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->GetStreamAsyncHelper( request, handler, context ); } );
+}
+
+void IVSClient::GetStreamAsyncHelper(const GetStreamRequest& request, const GetStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, GetStream(request), context);
+}
+
+GetStreamKeyOutcome IVSClient::GetStreamKey(const GetStreamKeyRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/GetStreamKey";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return GetStreamKeyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+GetStreamKeyOutcomeCallable IVSClient::GetStreamKeyCallable(const GetStreamKeyRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< GetStreamKeyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetStreamKey(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IVSClient::GetStreamKeyAsync(const GetStreamKeyRequest& request, const GetStreamKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->GetStreamKeyAsyncHelper( request, handler, context ); } );
+}
+
+void IVSClient::GetStreamKeyAsyncHelper(const GetStreamKeyRequest& request, const GetStreamKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, GetStreamKey(request), context);
+}
+
+ImportPlaybackKeyPairOutcome IVSClient::ImportPlaybackKeyPair(const ImportPlaybackKeyPairRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/ImportPlaybackKeyPair";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return ImportPlaybackKeyPairOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+ImportPlaybackKeyPairOutcomeCallable IVSClient::ImportPlaybackKeyPairCallable(const ImportPlaybackKeyPairRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< ImportPlaybackKeyPairOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ImportPlaybackKeyPair(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IVSClient::ImportPlaybackKeyPairAsync(const ImportPlaybackKeyPairRequest& request, const ImportPlaybackKeyPairResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->ImportPlaybackKeyPairAsyncHelper( request, handler, context ); } );
+}
+
+void IVSClient::ImportPlaybackKeyPairAsyncHelper(const ImportPlaybackKeyPairRequest& request, const ImportPlaybackKeyPairResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, ImportPlaybackKeyPair(request), context);
+}
+
+ListChannelsOutcome IVSClient::ListChannels(const ListChannelsRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/ListChannels";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return ListChannelsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+ListChannelsOutcomeCallable IVSClient::ListChannelsCallable(const ListChannelsRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< ListChannelsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListChannels(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IVSClient::ListChannelsAsync(const ListChannelsRequest& request, const ListChannelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->ListChannelsAsyncHelper( request, handler, context ); } );
+}
+
+void IVSClient::ListChannelsAsyncHelper(const ListChannelsRequest& request, const ListChannelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, ListChannels(request), context);
+}
+
+ListPlaybackKeyPairsOutcome IVSClient::ListPlaybackKeyPairs(const ListPlaybackKeyPairsRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/ListPlaybackKeyPairs";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return ListPlaybackKeyPairsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+ListPlaybackKeyPairsOutcomeCallable IVSClient::ListPlaybackKeyPairsCallable(const ListPlaybackKeyPairsRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< ListPlaybackKeyPairsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListPlaybackKeyPairs(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IVSClient::ListPlaybackKeyPairsAsync(const ListPlaybackKeyPairsRequest& request, const ListPlaybackKeyPairsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->ListPlaybackKeyPairsAsyncHelper( request, handler, context ); } );
+}
+
+void IVSClient::ListPlaybackKeyPairsAsyncHelper(const ListPlaybackKeyPairsRequest& request, const ListPlaybackKeyPairsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, ListPlaybackKeyPairs(request), context);
+}
+
+ListStreamKeysOutcome IVSClient::ListStreamKeys(const ListStreamKeysRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/ListStreamKeys";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return ListStreamKeysOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+ListStreamKeysOutcomeCallable IVSClient::ListStreamKeysCallable(const ListStreamKeysRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< ListStreamKeysOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListStreamKeys(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IVSClient::ListStreamKeysAsync(const ListStreamKeysRequest& request, const ListStreamKeysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->ListStreamKeysAsyncHelper( request, handler, context ); } );
+}
+
+void IVSClient::ListStreamKeysAsyncHelper(const ListStreamKeysRequest& request, const ListStreamKeysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, ListStreamKeys(request), context);
+}
+
+ListStreamsOutcome IVSClient::ListStreams(const ListStreamsRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/ListStreams";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return ListStreamsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+ListStreamsOutcomeCallable IVSClient::ListStreamsCallable(const ListStreamsRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< ListStreamsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListStreams(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IVSClient::ListStreamsAsync(const ListStreamsRequest& request, const ListStreamsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->ListStreamsAsyncHelper( request, handler, context ); } );
+}
+
+void IVSClient::ListStreamsAsyncHelper(const ListStreamsRequest& request, const ListStreamsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, ListStreams(request), context);
+}
+
+ListTagsForResourceOutcome IVSClient::ListTagsForResource(const ListTagsForResourceRequest& request) const
+{
+  if (!request.ResourceArnHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("ListTagsForResource", "Required field: ResourceArn, is not set");
+    return ListTagsForResourceOutcome(Aws::Client::AWSError<IVSErrors>(IVSErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
+  }
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/tags/";
+  ss << request.GetResourceArn();
+  uri.SetPath(uri.GetPath() + ss.str());
+  return ListTagsForResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
+}
+
+ListTagsForResourceOutcomeCallable IVSClient::ListTagsForResourceCallable(const ListTagsForResourceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< ListTagsForResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTagsForResource(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IVSClient::ListTagsForResourceAsync(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->ListTagsForResourceAsyncHelper( request, handler, context ); } );
+}
+
+void IVSClient::ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, ListTagsForResource(request), context);
+}
+
+PutMetadataOutcome IVSClient::PutMetadata(const PutMetadataRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/PutMetadata";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return PutMetadataOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+PutMetadataOutcomeCallable IVSClient::PutMetadataCallable(const PutMetadataRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< PutMetadataOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutMetadata(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IVSClient::PutMetadataAsync(const PutMetadataRequest& request, const PutMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->PutMetadataAsyncHelper( request, handler, context ); } );
+}
+
+void IVSClient::PutMetadataAsyncHelper(const PutMetadataRequest& request, const PutMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, PutMetadata(request), context);
+}
+
+StopStreamOutcome IVSClient::StopStream(const StopStreamRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/StopStream";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return StopStreamOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+StopStreamOutcomeCallable IVSClient::StopStreamCallable(const StopStreamRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< StopStreamOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StopStream(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IVSClient::StopStreamAsync(const StopStreamRequest& request, const StopStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->StopStreamAsyncHelper( request, handler, context ); } );
+}
+
+void IVSClient::StopStreamAsyncHelper(const StopStreamRequest& request, const StopStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, StopStream(request), context);
+}
+
+TagResourceOutcome IVSClient::TagResource(const TagResourceRequest& request) const
+{
+  if (!request.ResourceArnHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("TagResource", "Required field: ResourceArn, is not set");
+    return TagResourceOutcome(Aws::Client::AWSError<IVSErrors>(IVSErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
+  }
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/tags/";
+  ss << request.GetResourceArn();
+  uri.SetPath(uri.GetPath() + ss.str());
+  return TagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+TagResourceOutcomeCallable IVSClient::TagResourceCallable(const TagResourceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< TagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagResource(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IVSClient::TagResourceAsync(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->TagResourceAsyncHelper( request, handler, context ); } );
+}
+
+void IVSClient::TagResourceAsyncHelper(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, TagResource(request), context);
+}
+
+UntagResourceOutcome IVSClient::UntagResource(const UntagResourceRequest& request) const
+{
+  if (!request.ResourceArnHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("UntagResource", "Required field: ResourceArn, is not set");
+    return UntagResourceOutcome(Aws::Client::AWSError<IVSErrors>(IVSErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
+  }
+  if (!request.TagKeysHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("UntagResource", "Required field: TagKeys, is not set");
+    return UntagResourceOutcome(Aws::Client::AWSError<IVSErrors>(IVSErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TagKeys]", false));
+  }
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/tags/";
+  ss << request.GetResourceArn();
+  uri.SetPath(uri.GetPath() + ss.str());
+  return UntagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
+}
+
+UntagResourceOutcomeCallable IVSClient::UntagResourceCallable(const UntagResourceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< UntagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagResource(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IVSClient::UntagResourceAsync(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->UntagResourceAsyncHelper( request, handler, context ); } );
+}
+
+void IVSClient::UntagResourceAsyncHelper(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, UntagResource(request), context);
+}
+
+UpdateChannelOutcome IVSClient::UpdateChannel(const UpdateChannelRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/UpdateChannel";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return UpdateChannelOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+UpdateChannelOutcomeCallable IVSClient::UpdateChannelCallable(const UpdateChannelRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< UpdateChannelOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateChannel(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IVSClient::UpdateChannelAsync(const UpdateChannelRequest& request, const UpdateChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->UpdateChannelAsyncHelper( request, handler, context ); } );
+}
+
+void IVSClient::UpdateChannelAsyncHelper(const UpdateChannelRequest& request, const UpdateChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, UpdateChannel(request), context);
+}
+

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/IVSEndpoint.cpp

@@ -0,0 +1,64 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/IVSEndpoint.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+#include <aws/core/utils/HashingUtils.h>
+
+using namespace Aws;
+using namespace Aws::IVS;
+
+namespace Aws
+{
+namespace IVS
+{
+namespace IVSEndpoint
+{
+  static const int CN_NORTH_1_HASH = Aws::Utils::HashingUtils::HashString("cn-north-1");
+  static const int CN_NORTHWEST_1_HASH = Aws::Utils::HashingUtils::HashString("cn-northwest-1");
+  static const int US_ISO_EAST_1_HASH = Aws::Utils::HashingUtils::HashString("us-iso-east-1");
+  static const int US_ISOB_EAST_1_HASH = Aws::Utils::HashingUtils::HashString("us-isob-east-1");
+
+
+  Aws::String ForRegion(const Aws::String& regionName, bool useDualStack)
+  {
+    // Fallback to us-east-1 if global endpoint does not exists.
+    Aws::String region = regionName == Aws::Region::AWS_GLOBAL ? Aws::Region::US_EAST_1 : regionName;
+    auto hash = Aws::Utils::HashingUtils::HashString(region.c_str());
+
+    Aws::StringStream ss;
+    ss << "ivs" << ".";
+
+    if(useDualStack)
+    {
+      ss << "dualstack.";
+    }
+
+    ss << region;
+
+    if (hash == CN_NORTH_1_HASH || hash == CN_NORTHWEST_1_HASH)
+    {
+      ss << ".amazonaws.com.cn";
+    }
+    else if (hash == US_ISO_EAST_1_HASH)
+    {
+      ss << ".c2s.ic.gov";
+    }
+    else if (hash == US_ISOB_EAST_1_HASH)
+    {
+      ss << ".sc2s.sgov.gov";
+    }
+    else
+    {
+      ss << ".amazonaws.com";
+    }
+
+    return ss.str();
+  }
+
+} // namespace IVSEndpoint
+} // namespace IVS
+} // namespace Aws
+

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/IVSErrorMarshaller.cpp

@@ -0,0 +1,22 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/core/client/AWSError.h>
+#include <aws/ivs/IVSErrorMarshaller.h>
+#include <aws/ivs/IVSErrors.h>
+
+using namespace Aws::Client;
+using namespace Aws::IVS;
+
+AWSError<CoreErrors> IVSErrorMarshaller::FindErrorByName(const char* errorName) const
+{
+  AWSError<CoreErrors> error = IVSErrorMapper::GetErrorForName(errorName);
+  if(error.GetErrorType() != CoreErrors::UNKNOWN)
+  {
+    return error;
+  }
+
+  return AWSErrorMarshaller::FindErrorByName(errorName);
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/IVSErrors.cpp

@@ -0,0 +1,133 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/core/client/AWSError.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/ivs/IVSErrors.h>
+#include <aws/ivs/model/ConflictException.h>
+#include <aws/ivs/model/ServiceQuotaExceededException.h>
+#include <aws/ivs/model/ThrottlingException.h>
+#include <aws/ivs/model/StreamUnavailable.h>
+#include <aws/ivs/model/ResourceNotFoundException.h>
+#include <aws/ivs/model/InternalServerException.h>
+#include <aws/ivs/model/ValidationException.h>
+#include <aws/ivs/model/PendingVerification.h>
+#include <aws/ivs/model/AccessDeniedException.h>
+#include <aws/ivs/model/ChannelNotBroadcasting.h>
+
+using namespace Aws::Client;
+using namespace Aws::Utils;
+using namespace Aws::IVS;
+using namespace Aws::IVS::Model;
+
+namespace Aws
+{
+namespace IVS
+{
+template<> AWS_IVS_API ConflictException IVSError::GetModeledError()
+{
+  assert(this->GetErrorType() == IVSErrors::CONFLICT);
+  return ConflictException(this->GetJsonPayload().View());
+}
+
+template<> AWS_IVS_API ServiceQuotaExceededException IVSError::GetModeledError()
+{
+  assert(this->GetErrorType() == IVSErrors::SERVICE_QUOTA_EXCEEDED);
+  return ServiceQuotaExceededException(this->GetJsonPayload().View());
+}
+
+template<> AWS_IVS_API ThrottlingException IVSError::GetModeledError()
+{
+  assert(this->GetErrorType() == IVSErrors::THROTTLING);
+  return ThrottlingException(this->GetJsonPayload().View());
+}
+
+template<> AWS_IVS_API StreamUnavailable IVSError::GetModeledError()
+{
+  assert(this->GetErrorType() == IVSErrors::STREAM_UNAVAILABLE);
+  return StreamUnavailable(this->GetJsonPayload().View());
+}
+
+template<> AWS_IVS_API ResourceNotFoundException IVSError::GetModeledError()
+{
+  assert(this->GetErrorType() == IVSErrors::RESOURCE_NOT_FOUND);
+  return ResourceNotFoundException(this->GetJsonPayload().View());
+}
+
+template<> AWS_IVS_API InternalServerException IVSError::GetModeledError()
+{
+  assert(this->GetErrorType() == IVSErrors::INTERNAL_SERVER);
+  return InternalServerException(this->GetJsonPayload().View());
+}
+
+template<> AWS_IVS_API ValidationException IVSError::GetModeledError()
+{
+  assert(this->GetErrorType() == IVSErrors::VALIDATION);
+  return ValidationException(this->GetJsonPayload().View());
+}
+
+template<> AWS_IVS_API PendingVerification IVSError::GetModeledError()
+{
+  assert(this->GetErrorType() == IVSErrors::PENDING_VERIFICATION);
+  return PendingVerification(this->GetJsonPayload().View());
+}
+
+template<> AWS_IVS_API AccessDeniedException IVSError::GetModeledError()
+{
+  assert(this->GetErrorType() == IVSErrors::ACCESS_DENIED);
+  return AccessDeniedException(this->GetJsonPayload().View());
+}
+
+template<> AWS_IVS_API ChannelNotBroadcasting IVSError::GetModeledError()
+{
+  assert(this->GetErrorType() == IVSErrors::CHANNEL_NOT_BROADCASTING);
+  return ChannelNotBroadcasting(this->GetJsonPayload().View());
+}
+
+namespace IVSErrorMapper
+{
+
+static const int CONFLICT_HASH = HashingUtils::HashString("ConflictException");
+static const int SERVICE_QUOTA_EXCEEDED_HASH = HashingUtils::HashString("ServiceQuotaExceededException");
+static const int STREAM_UNAVAILABLE_HASH = HashingUtils::HashString("StreamUnavailable");
+static const int INTERNAL_SERVER_HASH = HashingUtils::HashString("InternalServerException");
+static const int PENDING_VERIFICATION_HASH = HashingUtils::HashString("PendingVerification");
+static const int CHANNEL_NOT_BROADCASTING_HASH = HashingUtils::HashString("ChannelNotBroadcasting");
+
+
+AWSError<CoreErrors> GetErrorForName(const char* errorName)
+{
+  int hashCode = HashingUtils::HashString(errorName);
+
+  if (hashCode == CONFLICT_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(IVSErrors::CONFLICT), false);
+  }
+  else if (hashCode == SERVICE_QUOTA_EXCEEDED_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(IVSErrors::SERVICE_QUOTA_EXCEEDED), false);
+  }
+  else if (hashCode == STREAM_UNAVAILABLE_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(IVSErrors::STREAM_UNAVAILABLE), false);
+  }
+  else if (hashCode == INTERNAL_SERVER_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(IVSErrors::INTERNAL_SERVER), false);
+  }
+  else if (hashCode == PENDING_VERIFICATION_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(IVSErrors::PENDING_VERIFICATION), false);
+  }
+  else if (hashCode == CHANNEL_NOT_BROADCASTING_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(IVSErrors::CHANNEL_NOT_BROADCASTING), false);
+  }
+  return AWSError<CoreErrors>(CoreErrors::UNKNOWN, false);
+}
+
+} // namespace IVSErrorMapper
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/AccessDeniedException.cpp

@@ -0,0 +1,59 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/AccessDeniedException.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+AccessDeniedException::AccessDeniedException() : 
+    m_exceptionMessageHasBeenSet(false)
+{
+}
+
+AccessDeniedException::AccessDeniedException(JsonView jsonValue) : 
+    m_exceptionMessageHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+AccessDeniedException& AccessDeniedException::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("exceptionMessage"))
+  {
+    m_exceptionMessage = jsonValue.GetString("exceptionMessage");
+
+    m_exceptionMessageHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue AccessDeniedException::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_exceptionMessageHasBeenSet)
+  {
+   payload.WithString("exceptionMessage", m_exceptionMessage);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/BatchError.cpp

@@ -0,0 +1,89 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/BatchError.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+BatchError::BatchError() : 
+    m_arnHasBeenSet(false),
+    m_codeHasBeenSet(false),
+    m_messageHasBeenSet(false)
+{
+}
+
+BatchError::BatchError(JsonView jsonValue) : 
+    m_arnHasBeenSet(false),
+    m_codeHasBeenSet(false),
+    m_messageHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+BatchError& BatchError::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("arn"))
+  {
+    m_arn = jsonValue.GetString("arn");
+
+    m_arnHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("code"))
+  {
+    m_code = jsonValue.GetString("code");
+
+    m_codeHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("message"))
+  {
+    m_message = jsonValue.GetString("message");
+
+    m_messageHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue BatchError::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_arnHasBeenSet)
+  {
+   payload.WithString("arn", m_arn);
+
+  }
+
+  if(m_codeHasBeenSet)
+  {
+   payload.WithString("code", m_code);
+
+  }
+
+  if(m_messageHasBeenSet)
+  {
+   payload.WithString("message", m_message);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/BatchGetChannelRequest.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/BatchGetChannelRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::IVS::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+BatchGetChannelRequest::BatchGetChannelRequest() : 
+    m_arnsHasBeenSet(false)
+{
+}
+
+Aws::String BatchGetChannelRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_arnsHasBeenSet)
+  {
+   Array<JsonValue> arnsJsonList(m_arns.size());
+   for(unsigned arnsIndex = 0; arnsIndex < arnsJsonList.GetLength(); ++arnsIndex)
+   {
+     arnsJsonList[arnsIndex].AsString(m_arns[arnsIndex]);
+   }
+   payload.WithArray("arns", std::move(arnsJsonList));
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/BatchGetChannelResult.cpp

@@ -0,0 +1,52 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/BatchGetChannelResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::IVS::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+BatchGetChannelResult::BatchGetChannelResult()
+{
+}
+
+BatchGetChannelResult::BatchGetChannelResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+BatchGetChannelResult& BatchGetChannelResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("channels"))
+  {
+    Array<JsonView> channelsJsonList = jsonValue.GetArray("channels");
+    for(unsigned channelsIndex = 0; channelsIndex < channelsJsonList.GetLength(); ++channelsIndex)
+    {
+      m_channels.push_back(channelsJsonList[channelsIndex].AsObject());
+    }
+  }
+
+  if(jsonValue.ValueExists("errors"))
+  {
+    Array<JsonView> errorsJsonList = jsonValue.GetArray("errors");
+    for(unsigned errorsIndex = 0; errorsIndex < errorsJsonList.GetLength(); ++errorsIndex)
+    {
+      m_errors.push_back(errorsJsonList[errorsIndex].AsObject());
+    }
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/BatchGetStreamKeyRequest.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/BatchGetStreamKeyRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::IVS::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+BatchGetStreamKeyRequest::BatchGetStreamKeyRequest() : 
+    m_arnsHasBeenSet(false)
+{
+}
+
+Aws::String BatchGetStreamKeyRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_arnsHasBeenSet)
+  {
+   Array<JsonValue> arnsJsonList(m_arns.size());
+   for(unsigned arnsIndex = 0; arnsIndex < arnsJsonList.GetLength(); ++arnsIndex)
+   {
+     arnsJsonList[arnsIndex].AsString(m_arns[arnsIndex]);
+   }
+   payload.WithArray("arns", std::move(arnsJsonList));
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/BatchGetStreamKeyResult.cpp

@@ -0,0 +1,52 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/BatchGetStreamKeyResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::IVS::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+BatchGetStreamKeyResult::BatchGetStreamKeyResult()
+{
+}
+
+BatchGetStreamKeyResult::BatchGetStreamKeyResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+BatchGetStreamKeyResult& BatchGetStreamKeyResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("streamKeys"))
+  {
+    Array<JsonView> streamKeysJsonList = jsonValue.GetArray("streamKeys");
+    for(unsigned streamKeysIndex = 0; streamKeysIndex < streamKeysJsonList.GetLength(); ++streamKeysIndex)
+    {
+      m_streamKeys.push_back(streamKeysJsonList[streamKeysIndex].AsObject());
+    }
+  }
+
+  if(jsonValue.ValueExists("errors"))
+  {
+    Array<JsonView> errorsJsonList = jsonValue.GetArray("errors");
+    for(unsigned errorsIndex = 0; errorsIndex < errorsJsonList.GetLength(); ++errorsIndex)
+    {
+      m_errors.push_back(errorsJsonList[errorsIndex].AsObject());
+    }
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/Channel.cpp

@@ -0,0 +1,176 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/Channel.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+Channel::Channel() : 
+    m_arnHasBeenSet(false),
+    m_nameHasBeenSet(false),
+    m_latencyMode(ChannelLatencyMode::NOT_SET),
+    m_latencyModeHasBeenSet(false),
+    m_type(ChannelType::NOT_SET),
+    m_typeHasBeenSet(false),
+    m_ingestEndpointHasBeenSet(false),
+    m_playbackUrlHasBeenSet(false),
+    m_authorized(false),
+    m_authorizedHasBeenSet(false),
+    m_tagsHasBeenSet(false)
+{
+}
+
+Channel::Channel(JsonView jsonValue) : 
+    m_arnHasBeenSet(false),
+    m_nameHasBeenSet(false),
+    m_latencyMode(ChannelLatencyMode::NOT_SET),
+    m_latencyModeHasBeenSet(false),
+    m_type(ChannelType::NOT_SET),
+    m_typeHasBeenSet(false),
+    m_ingestEndpointHasBeenSet(false),
+    m_playbackUrlHasBeenSet(false),
+    m_authorized(false),
+    m_authorizedHasBeenSet(false),
+    m_tagsHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+Channel& Channel::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("arn"))
+  {
+    m_arn = jsonValue.GetString("arn");
+
+    m_arnHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("name"))
+  {
+    m_name = jsonValue.GetString("name");
+
+    m_nameHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("latencyMode"))
+  {
+    m_latencyMode = ChannelLatencyModeMapper::GetChannelLatencyModeForName(jsonValue.GetString("latencyMode"));
+
+    m_latencyModeHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("type"))
+  {
+    m_type = ChannelTypeMapper::GetChannelTypeForName(jsonValue.GetString("type"));
+
+    m_typeHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("ingestEndpoint"))
+  {
+    m_ingestEndpoint = jsonValue.GetString("ingestEndpoint");
+
+    m_ingestEndpointHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("playbackUrl"))
+  {
+    m_playbackUrl = jsonValue.GetString("playbackUrl");
+
+    m_playbackUrlHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("authorized"))
+  {
+    m_authorized = jsonValue.GetBool("authorized");
+
+    m_authorizedHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("tags"))
+  {
+    Aws::Map<Aws::String, JsonView> tagsJsonMap = jsonValue.GetObject("tags").GetAllObjects();
+    for(auto& tagsItem : tagsJsonMap)
+    {
+      m_tags[tagsItem.first] = tagsItem.second.AsString();
+    }
+    m_tagsHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue Channel::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_arnHasBeenSet)
+  {
+   payload.WithString("arn", m_arn);
+
+  }
+
+  if(m_nameHasBeenSet)
+  {
+   payload.WithString("name", m_name);
+
+  }
+
+  if(m_latencyModeHasBeenSet)
+  {
+   payload.WithString("latencyMode", ChannelLatencyModeMapper::GetNameForChannelLatencyMode(m_latencyMode));
+  }
+
+  if(m_typeHasBeenSet)
+  {
+   payload.WithString("type", ChannelTypeMapper::GetNameForChannelType(m_type));
+  }
+
+  if(m_ingestEndpointHasBeenSet)
+  {
+   payload.WithString("ingestEndpoint", m_ingestEndpoint);
+
+  }
+
+  if(m_playbackUrlHasBeenSet)
+  {
+   payload.WithString("playbackUrl", m_playbackUrl);
+
+  }
+
+  if(m_authorizedHasBeenSet)
+  {
+   payload.WithBool("authorized", m_authorized);
+
+  }
+
+  if(m_tagsHasBeenSet)
+  {
+   JsonValue tagsJsonMap;
+   for(auto& tagsItem : m_tags)
+   {
+     tagsJsonMap.WithString(tagsItem.first, tagsItem.second);
+   }
+   payload.WithObject("tags", std::move(tagsJsonMap));
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/ChannelLatencyMode.cpp

@@ -0,0 +1,70 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/ChannelLatencyMode.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/core/Globals.h>
+#include <aws/core/utils/EnumParseOverflowContainer.h>
+
+using namespace Aws::Utils;
+
+
+namespace Aws
+{
+  namespace IVS
+  {
+    namespace Model
+    {
+      namespace ChannelLatencyModeMapper
+      {
+
+        static const int NORMAL_HASH = HashingUtils::HashString("NORMAL");
+        static const int LOW_HASH = HashingUtils::HashString("LOW");
+
+
+        ChannelLatencyMode GetChannelLatencyModeForName(const Aws::String& name)
+        {
+          int hashCode = HashingUtils::HashString(name.c_str());
+          if (hashCode == NORMAL_HASH)
+          {
+            return ChannelLatencyMode::NORMAL;
+          }
+          else if (hashCode == LOW_HASH)
+          {
+            return ChannelLatencyMode::LOW;
+          }
+          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+          if(overflowContainer)
+          {
+            overflowContainer->StoreOverflow(hashCode, name);
+            return static_cast<ChannelLatencyMode>(hashCode);
+          }
+
+          return ChannelLatencyMode::NOT_SET;
+        }
+
+        Aws::String GetNameForChannelLatencyMode(ChannelLatencyMode enumValue)
+        {
+          switch(enumValue)
+          {
+          case ChannelLatencyMode::NORMAL:
+            return "NORMAL";
+          case ChannelLatencyMode::LOW:
+            return "LOW";
+          default:
+            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+            if(overflowContainer)
+            {
+              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
+            }
+
+            return {};
+          }
+        }
+
+      } // namespace ChannelLatencyModeMapper
+    } // namespace Model
+  } // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/ChannelNotBroadcasting.cpp

@@ -0,0 +1,59 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/ChannelNotBroadcasting.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+ChannelNotBroadcasting::ChannelNotBroadcasting() : 
+    m_exceptionMessageHasBeenSet(false)
+{
+}
+
+ChannelNotBroadcasting::ChannelNotBroadcasting(JsonView jsonValue) : 
+    m_exceptionMessageHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+ChannelNotBroadcasting& ChannelNotBroadcasting::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("exceptionMessage"))
+  {
+    m_exceptionMessage = jsonValue.GetString("exceptionMessage");
+
+    m_exceptionMessageHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue ChannelNotBroadcasting::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_exceptionMessageHasBeenSet)
+  {
+   payload.WithString("exceptionMessage", m_exceptionMessage);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/ChannelSummary.cpp

@@ -0,0 +1,130 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/ChannelSummary.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+ChannelSummary::ChannelSummary() : 
+    m_arnHasBeenSet(false),
+    m_nameHasBeenSet(false),
+    m_latencyMode(ChannelLatencyMode::NOT_SET),
+    m_latencyModeHasBeenSet(false),
+    m_authorized(false),
+    m_authorizedHasBeenSet(false),
+    m_tagsHasBeenSet(false)
+{
+}
+
+ChannelSummary::ChannelSummary(JsonView jsonValue) : 
+    m_arnHasBeenSet(false),
+    m_nameHasBeenSet(false),
+    m_latencyMode(ChannelLatencyMode::NOT_SET),
+    m_latencyModeHasBeenSet(false),
+    m_authorized(false),
+    m_authorizedHasBeenSet(false),
+    m_tagsHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+ChannelSummary& ChannelSummary::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("arn"))
+  {
+    m_arn = jsonValue.GetString("arn");
+
+    m_arnHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("name"))
+  {
+    m_name = jsonValue.GetString("name");
+
+    m_nameHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("latencyMode"))
+  {
+    m_latencyMode = ChannelLatencyModeMapper::GetChannelLatencyModeForName(jsonValue.GetString("latencyMode"));
+
+    m_latencyModeHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("authorized"))
+  {
+    m_authorized = jsonValue.GetBool("authorized");
+
+    m_authorizedHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("tags"))
+  {
+    Aws::Map<Aws::String, JsonView> tagsJsonMap = jsonValue.GetObject("tags").GetAllObjects();
+    for(auto& tagsItem : tagsJsonMap)
+    {
+      m_tags[tagsItem.first] = tagsItem.second.AsString();
+    }
+    m_tagsHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue ChannelSummary::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_arnHasBeenSet)
+  {
+   payload.WithString("arn", m_arn);
+
+  }
+
+  if(m_nameHasBeenSet)
+  {
+   payload.WithString("name", m_name);
+
+  }
+
+  if(m_latencyModeHasBeenSet)
+  {
+   payload.WithString("latencyMode", ChannelLatencyModeMapper::GetNameForChannelLatencyMode(m_latencyMode));
+  }
+
+  if(m_authorizedHasBeenSet)
+  {
+   payload.WithBool("authorized", m_authorized);
+
+  }
+
+  if(m_tagsHasBeenSet)
+  {
+   JsonValue tagsJsonMap;
+   for(auto& tagsItem : m_tags)
+   {
+     tagsJsonMap.WithString(tagsItem.first, tagsItem.second);
+   }
+   payload.WithObject("tags", std::move(tagsJsonMap));
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/ChannelType.cpp

@@ -0,0 +1,70 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/ChannelType.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/core/Globals.h>
+#include <aws/core/utils/EnumParseOverflowContainer.h>
+
+using namespace Aws::Utils;
+
+
+namespace Aws
+{
+  namespace IVS
+  {
+    namespace Model
+    {
+      namespace ChannelTypeMapper
+      {
+
+        static const int BASIC_HASH = HashingUtils::HashString("BASIC");
+        static const int STANDARD_HASH = HashingUtils::HashString("STANDARD");
+
+
+        ChannelType GetChannelTypeForName(const Aws::String& name)
+        {
+          int hashCode = HashingUtils::HashString(name.c_str());
+          if (hashCode == BASIC_HASH)
+          {
+            return ChannelType::BASIC;
+          }
+          else if (hashCode == STANDARD_HASH)
+          {
+            return ChannelType::STANDARD;
+          }
+          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+          if(overflowContainer)
+          {
+            overflowContainer->StoreOverflow(hashCode, name);
+            return static_cast<ChannelType>(hashCode);
+          }
+
+          return ChannelType::NOT_SET;
+        }
+
+        Aws::String GetNameForChannelType(ChannelType enumValue)
+        {
+          switch(enumValue)
+          {
+          case ChannelType::BASIC:
+            return "BASIC";
+          case ChannelType::STANDARD:
+            return "STANDARD";
+          default:
+            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+            if(overflowContainer)
+            {
+              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
+            }
+
+            return {};
+          }
+        }
+
+      } // namespace ChannelTypeMapper
+    } // namespace Model
+  } // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/ConflictException.cpp

@@ -0,0 +1,59 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/ConflictException.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace IVS
+{
+namespace Model
+{
+
+ConflictException::ConflictException() : 
+    m_exceptionMessageHasBeenSet(false)
+{
+}
+
+ConflictException::ConflictException(JsonView jsonValue) : 
+    m_exceptionMessageHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+ConflictException& ConflictException::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("exceptionMessage"))
+  {
+    m_exceptionMessage = jsonValue.GetString("exceptionMessage");
+
+    m_exceptionMessageHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue ConflictException::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_exceptionMessageHasBeenSet)
+  {
+   payload.WithString("exceptionMessage", m_exceptionMessage);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace IVS
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/CreateChannelRequest.cpp

@@ -0,0 +1,69 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/CreateChannelRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::IVS::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+CreateChannelRequest::CreateChannelRequest() : 
+    m_nameHasBeenSet(false),
+    m_latencyMode(ChannelLatencyMode::NOT_SET),
+    m_latencyModeHasBeenSet(false),
+    m_type(ChannelType::NOT_SET),
+    m_typeHasBeenSet(false),
+    m_authorized(false),
+    m_authorizedHasBeenSet(false),
+    m_tagsHasBeenSet(false)
+{
+}
+
+Aws::String CreateChannelRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_nameHasBeenSet)
+  {
+   payload.WithString("name", m_name);
+
+  }
+
+  if(m_latencyModeHasBeenSet)
+  {
+   payload.WithString("latencyMode", ChannelLatencyModeMapper::GetNameForChannelLatencyMode(m_latencyMode));
+  }
+
+  if(m_typeHasBeenSet)
+  {
+   payload.WithString("type", ChannelTypeMapper::GetNameForChannelType(m_type));
+  }
+
+  if(m_authorizedHasBeenSet)
+  {
+   payload.WithBool("authorized", m_authorized);
+
+  }
+
+  if(m_tagsHasBeenSet)
+  {
+   JsonValue tagsJsonMap;
+   for(auto& tagsItem : m_tags)
+   {
+     tagsJsonMap.WithString(tagsItem.first, tagsItem.second);
+   }
+   payload.WithObject("tags", std::move(tagsJsonMap));
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/CreateChannelResult.cpp

@@ -0,0 +1,46 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/CreateChannelResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::IVS::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+CreateChannelResult::CreateChannelResult()
+{
+}
+
+CreateChannelResult::CreateChannelResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+CreateChannelResult& CreateChannelResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("channel"))
+  {
+    m_channel = jsonValue.GetObject("channel");
+
+  }
+
+  if(jsonValue.ValueExists("streamKey"))
+  {
+    m_streamKey = jsonValue.GetObject("streamKey");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/CreateStreamKeyRequest.cpp

@@ -0,0 +1,47 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/CreateStreamKeyRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::IVS::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+CreateStreamKeyRequest::CreateStreamKeyRequest() : 
+    m_channelArnHasBeenSet(false),
+    m_tagsHasBeenSet(false)
+{
+}
+
+Aws::String CreateStreamKeyRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_channelArnHasBeenSet)
+  {
+   payload.WithString("channelArn", m_channelArn);
+
+  }
+
+  if(m_tagsHasBeenSet)
+  {
+   JsonValue tagsJsonMap;
+   for(auto& tagsItem : m_tags)
+   {
+     tagsJsonMap.WithString(tagsItem.first, tagsItem.second);
+   }
+   payload.WithObject("tags", std::move(tagsJsonMap));
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/CreateStreamKeyResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/CreateStreamKeyResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::IVS::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+CreateStreamKeyResult::CreateStreamKeyResult()
+{
+}
+
+CreateStreamKeyResult::CreateStreamKeyResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+CreateStreamKeyResult& CreateStreamKeyResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("streamKey"))
+  {
+    m_streamKey = jsonValue.GetObject("streamKey");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/DeleteChannelRequest.cpp

@@ -0,0 +1,35 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/DeleteChannelRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::IVS::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+DeleteChannelRequest::DeleteChannelRequest() : 
+    m_arnHasBeenSet(false)
+{
+}
+
+Aws::String DeleteChannelRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_arnHasBeenSet)
+  {
+   payload.WithString("arn", m_arn);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/DeletePlaybackKeyPairRequest.cpp

@@ -0,0 +1,35 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/DeletePlaybackKeyPairRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::IVS::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+DeletePlaybackKeyPairRequest::DeletePlaybackKeyPairRequest() : 
+    m_arnHasBeenSet(false)
+{
+}
+
+Aws::String DeletePlaybackKeyPairRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_arnHasBeenSet)
+  {
+   payload.WithString("arn", m_arn);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/DeletePlaybackKeyPairResult.cpp

@@ -0,0 +1,34 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/DeletePlaybackKeyPairResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::IVS::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+DeletePlaybackKeyPairResult::DeletePlaybackKeyPairResult()
+{
+}
+
+DeletePlaybackKeyPairResult::DeletePlaybackKeyPairResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+DeletePlaybackKeyPairResult& DeletePlaybackKeyPairResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  AWS_UNREFERENCED_PARAM(result);
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/DeleteStreamKeyRequest.cpp

@@ -0,0 +1,35 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/DeleteStreamKeyRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::IVS::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+DeleteStreamKeyRequest::DeleteStreamKeyRequest() : 
+    m_arnHasBeenSet(false)
+{
+}
+
+Aws::String DeleteStreamKeyRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_arnHasBeenSet)
+  {
+   payload.WithString("arn", m_arn);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/GetChannelRequest.cpp

@@ -0,0 +1,35 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/GetChannelRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::IVS::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+GetChannelRequest::GetChannelRequest() : 
+    m_arnHasBeenSet(false)
+{
+}
+
+Aws::String GetChannelRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_arnHasBeenSet)
+  {
+   payload.WithString("arn", m_arn);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/GetChannelResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/GetChannelResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::IVS::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+GetChannelResult::GetChannelResult()
+{
+}
+
+GetChannelResult::GetChannelResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+GetChannelResult& GetChannelResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("channel"))
+  {
+    m_channel = jsonValue.GetObject("channel");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/GetPlaybackKeyPairRequest.cpp

@@ -0,0 +1,35 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/GetPlaybackKeyPairRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::IVS::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+GetPlaybackKeyPairRequest::GetPlaybackKeyPairRequest() : 
+    m_arnHasBeenSet(false)
+{
+}
+
+Aws::String GetPlaybackKeyPairRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_arnHasBeenSet)
+  {
+   payload.WithString("arn", m_arn);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/GetPlaybackKeyPairResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/GetPlaybackKeyPairResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::IVS::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+GetPlaybackKeyPairResult::GetPlaybackKeyPairResult()
+{
+}
+
+GetPlaybackKeyPairResult::GetPlaybackKeyPairResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+GetPlaybackKeyPairResult& GetPlaybackKeyPairResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("keyPair"))
+  {
+    m_keyPair = jsonValue.GetObject("keyPair");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-ivs/source/model/GetStreamKeyRequest.cpp

@@ -0,0 +1,35 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/ivs/model/GetStreamKeyRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::IVS::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+GetStreamKeyRequest::GetStreamKeyRequest() : 
+    m_arnHasBeenSet(false)
+{
+}
+
+Aws::String GetStreamKeyRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_arnHasBeenSet)
+  {
+   payload.WithString("arn", m_arn);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+
+
+