/**
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 * SPDX-License-Identifier: Apache-2.0.
 */

#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/ivs/IVSPaginationBase.h>
#include <aws/ivs/IVSServiceClientModel.h>
#include <aws/ivs/IVSWaiter.h>
#include <aws/ivs/IVS_EXPORTS.h>

namespace Aws {
namespace IVS {
/**
 * <p> <b>Introduction</b> </p> <p>The Amazon Interactive Video Service (IVS) API
 * is REST compatible, using a standard HTTP API and an Amazon Web Services
 * EventBridge event stream for responses. JSON is used for both requests and
 * responses, including errors.</p> <p>The API is an Amazon Web Services regional
 * service. For a list of supported regions and Amazon IVS HTTPS service endpoints,
 * see the <a href="https://docs.aws.amazon.com/general/latest/gr/ivs.html">Amazon
 * IVS page</a> in the <i>Amazon Web Services General Reference</i>.</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>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>Key
 * Concepts</b> </p> <ul> <li> <p> <b>Channel</b> — 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.</p> </li> <li> <p> <b>Stream
 * key</b> — An identifier assigned by Amazon IVS when you create a channel, which
 * is then used to authorize streaming. <i> <b>Treat the stream key like a secret,
 * since it allows anyone to stream to the channel.</b> </i> </p> </li> <li> <p>
 * <b>Playback key pair</b> — 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.</p> </li> <li> <p> <b>Recording configuration</b>
 * — Stores configuration related to recording a live stream and where to store the
 * recorded content. Multiple channels can reference the same recording
 * configuration.</p> </li> <li> <p> <b>Playback restriction policy</b> — Restricts
 * playback by countries and/or origin sites.</p> </li> </ul> <p>For more
 * information about your IVS live stream, also see <a
 * href="https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/getting-started.html">Getting
 * Started with IVS Low-Latency Streaming</a>.</p> <p> <b>Tagging</b> </p> <p>A
 * <i>tag</i> is a metadata label that you assign to an Amazon Web Services
 * 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/tag-editor/latest/userguide/best-practices-and-strats.html">Best
 * practices and strategies</a> in <i>Tagging Amazon Web Services Resources and Tag
 * Editor</i> for details, including restrictions that apply to tags and "Tag
 * naming limits and requirements"; Amazon IVS has no service-specific constraints
 * beyond what is documented there.</p> <p>Tags can help you identify and organize
 * your Amazon Web Services 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 operations:
 * <a>TagResource</a>, <a>UntagResource</a>, and <a>ListTagsForResource</a>. The
 * following resources support tagging: Channels, Stream Keys, Playback Key Pairs,
 * and Recording Configurations.</p> <p>At most 50 tags can be applied to a
 * resource. </p> <p> <b>Authentication versus Authorization</b> </p> <p>Note the
 * differences between these concepts:</p> <ul> <li> <p> <i>Authentication</i> is
 * about verifying identity. You need to be authenticated to sign Amazon IVS API
 * requests.</p> </li> <li> <p> <i>Authorization</i> is about granting permissions.
 * Your IAM roles need to have permissions for Amazon IVS API requests. In
 * addition, authorization is needed to view <a
 * href="https://docs.aws.amazon.com/ivs/latest/userguide/private-channels.html">Amazon
 * IVS private channels</a>. (Private channels are channels that are enabled for
 * "playback authorization.")</p> </li> </ul> <p> <b>Authentication</b> </p> <p>All
 * Amazon IVS API requests must be authenticated with a signature. The Amazon Web
 * Services Command-Line Interface (CLI) and Amazon IVS Player SDKs take care of
 * signing the underlying API calls for you. However, if your application calls the
 * Amazon IVS API directly, it’s your responsibility to sign the requests.</p>
 * <p>You generate a signature using valid Amazon Web Services credentials that
 * have permission to perform the requested action. For example, you must sign
 * PutMetadata requests with a signature generated from a user account that has the
 * <code>ivs:PutMetadata</code> permission.</p> <p>For more information:</p> <ul>
 * <li> <p>Authentication and generating signatures — See <a
 * href="https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html">Authenticating
 * Requests (Amazon Web Services Signature Version 4)</a> in the <i>Amazon Web
 * Services General Reference</i>.</p> </li> <li> <p>Managing Amazon IVS
 * permissions — See <a
 * href="https://docs.aws.amazon.com/ivs/latest/userguide/security-iam.html">Identity
 * and Access Management</a> on the Security page of the <i>Amazon IVS User
 * Guide</i>.</p> </li> </ul> <p> <b>Amazon Resource Names (ARNs)</b> </p> <p>ARNs
 * uniquely identify AWS resources. An ARN is required when you need to specify a
 * resource unambiguously across all of AWS, such as in IAM policies and API calls.
 * For more information, see <a
 * href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">Amazon
 * Resource Names</a> in the <i>AWS General Reference</i>.</p>
 */
class AWS_IVS_API IVSClient : public Aws::Client::AWSJsonClient,
                              public Aws::Client::ClientWithAsyncTemplateMethods<IVSClient>,
                              public IVSPaginationBase<IVSClient>,
                              public IVSWaiter<IVSClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();

  typedef IVSClientConfiguration ClientConfigurationType;
  typedef IVSEndpointProvider EndpointProviderType;

  /**
   * 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::IVS::IVSClientConfiguration& clientConfiguration = Aws::IVS::IVSClientConfiguration(),
            std::shared_ptr<IVSEndpointProviderBase> endpointProvider = nullptr);

  /**
   * 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, std::shared_ptr<IVSEndpointProviderBase> endpointProvider = nullptr,
            const Aws::IVS::IVSClientConfiguration& clientConfiguration = Aws::IVS::IVSClientConfiguration());

  /**
   * 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,
            std::shared_ptr<IVSEndpointProviderBase> endpointProvider = nullptr,
            const Aws::IVS::IVSClientConfiguration& clientConfiguration = Aws::IVS::IVSClientConfiguration());

  /* Legacy constructors due deprecation */
  /**
   * 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);

  /**
   * 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);

  /**
   * 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);

  /* End of legacy constructors due deprecation */
  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;

  /**
   * A Callable wrapper for BatchGetChannel that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename BatchGetChannelRequestT = Model::BatchGetChannelRequest>
  Model::BatchGetChannelOutcomeCallable BatchGetChannelCallable(const BatchGetChannelRequestT& request) const {
    return SubmitCallable(&IVSClient::BatchGetChannel, request);
  }

  /**
   * An Async wrapper for BatchGetChannel that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename BatchGetChannelRequestT = Model::BatchGetChannelRequest>
  void BatchGetChannelAsync(const BatchGetChannelRequestT& request, const BatchGetChannelResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::BatchGetChannel, request, handler, context);
  }

  /**
   * <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;

  /**
   * A Callable wrapper for BatchGetStreamKey that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename BatchGetStreamKeyRequestT = Model::BatchGetStreamKeyRequest>
  Model::BatchGetStreamKeyOutcomeCallable BatchGetStreamKeyCallable(const BatchGetStreamKeyRequestT& request) const {
    return SubmitCallable(&IVSClient::BatchGetStreamKey, request);
  }

  /**
   * An Async wrapper for BatchGetStreamKey that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename BatchGetStreamKeyRequestT = Model::BatchGetStreamKeyRequest>
  void BatchGetStreamKeyAsync(const BatchGetStreamKeyRequestT& request, const BatchGetStreamKeyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::BatchGetStreamKey, request, handler, context);
  }

  /**
   * <p>Performs <a>StartViewerSessionRevocation</a> on multiple channel ARN and
   * viewer ID pairs simultaneously.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/BatchStartViewerSessionRevocation">AWS
   * API Reference</a></p>
   */
  virtual Model::BatchStartViewerSessionRevocationOutcome BatchStartViewerSessionRevocation(
      const Model::BatchStartViewerSessionRevocationRequest& request) const;

  /**
   * A Callable wrapper for BatchStartViewerSessionRevocation that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename BatchStartViewerSessionRevocationRequestT = Model::BatchStartViewerSessionRevocationRequest>
  Model::BatchStartViewerSessionRevocationOutcomeCallable BatchStartViewerSessionRevocationCallable(
      const BatchStartViewerSessionRevocationRequestT& request) const {
    return SubmitCallable(&IVSClient::BatchStartViewerSessionRevocation, request);
  }

  /**
   * An Async wrapper for BatchStartViewerSessionRevocation that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename BatchStartViewerSessionRevocationRequestT = Model::BatchStartViewerSessionRevocationRequest>
  void BatchStartViewerSessionRevocationAsync(const BatchStartViewerSessionRevocationRequestT& request,
                                              const BatchStartViewerSessionRevocationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::BatchStartViewerSessionRevocation, request, handler, context);
  }

  /**
   * <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;

  /**
   * A Callable wrapper for CreateChannel that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename CreateChannelRequestT = Model::CreateChannelRequest>
  Model::CreateChannelOutcomeCallable CreateChannelCallable(const CreateChannelRequestT& request = {}) const {
    return SubmitCallable(&IVSClient::CreateChannel, request);
  }

  /**
   * An Async wrapper for CreateChannel that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename CreateChannelRequestT = Model::CreateChannelRequest>
  void CreateChannelAsync(const CreateChannelResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const CreateChannelRequestT& request = {}) const {
    return SubmitAsync(&IVSClient::CreateChannel, request, handler, context);
  }

  /**
   * <p>Creates a new playback restriction policy, for constraining playback by
   * countries and/or origins.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/CreatePlaybackRestrictionPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::CreatePlaybackRestrictionPolicyOutcome CreatePlaybackRestrictionPolicy(
      const Model::CreatePlaybackRestrictionPolicyRequest& request = {}) const;

  /**
   * A Callable wrapper for CreatePlaybackRestrictionPolicy that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename CreatePlaybackRestrictionPolicyRequestT = Model::CreatePlaybackRestrictionPolicyRequest>
  Model::CreatePlaybackRestrictionPolicyOutcomeCallable CreatePlaybackRestrictionPolicyCallable(
      const CreatePlaybackRestrictionPolicyRequestT& request = {}) const {
    return SubmitCallable(&IVSClient::CreatePlaybackRestrictionPolicy, request);
  }

  /**
   * An Async wrapper for CreatePlaybackRestrictionPolicy that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename CreatePlaybackRestrictionPolicyRequestT = Model::CreatePlaybackRestrictionPolicyRequest>
  void CreatePlaybackRestrictionPolicyAsync(const CreatePlaybackRestrictionPolicyResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const CreatePlaybackRestrictionPolicyRequestT& request = {}) const {
    return SubmitAsync(&IVSClient::CreatePlaybackRestrictionPolicy, request, handler, context);
  }

  /**
   * <p>Creates a new recording configuration, used to enable recording to Amazon
   * S3.</p> <p> <b>Known issue:</b> In the us-east-1 region, if you use the Amazon
   * Web Services CLI to create a recording configuration, it returns success even if
   * the S3 bucket is in a different region. In this case, the <code>state</code> of
   * the recording configuration is <code>CREATE_FAILED</code> (instead of
   * <code>ACTIVE</code>). (In other regions, the CLI correctly returns failure if
   * the bucket is in a different region.)</p> <p> <b>Workaround:</b> Ensure that
   * your S3 bucket is in the same region as the recording configuration. If you
   * create a recording configuration in a different region as your S3 bucket, delete
   * that recording configuration and create a new one with an S3 bucket from the
   * correct region.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/CreateRecordingConfiguration">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateRecordingConfigurationOutcome CreateRecordingConfiguration(
      const Model::CreateRecordingConfigurationRequest& request) const;

  /**
   * A Callable wrapper for CreateRecordingConfiguration that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename CreateRecordingConfigurationRequestT = Model::CreateRecordingConfigurationRequest>
  Model::CreateRecordingConfigurationOutcomeCallable CreateRecordingConfigurationCallable(
      const CreateRecordingConfigurationRequestT& request) const {
    return SubmitCallable(&IVSClient::CreateRecordingConfiguration, request);
  }

  /**
   * An Async wrapper for CreateRecordingConfiguration that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename CreateRecordingConfigurationRequestT = Model::CreateRecordingConfigurationRequest>
  void CreateRecordingConfigurationAsync(const CreateRecordingConfigurationRequestT& request,
                                         const CreateRecordingConfigurationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::CreateRecordingConfiguration, request, handler, context);
  }

  /**
   * <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;

  /**
   * A Callable wrapper for CreateStreamKey that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename CreateStreamKeyRequestT = Model::CreateStreamKeyRequest>
  Model::CreateStreamKeyOutcomeCallable CreateStreamKeyCallable(const CreateStreamKeyRequestT& request) const {
    return SubmitCallable(&IVSClient::CreateStreamKey, request);
  }

  /**
   * An Async wrapper for CreateStreamKey that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename CreateStreamKeyRequestT = Model::CreateStreamKeyRequest>
  void CreateStreamKeyAsync(const CreateStreamKeyRequestT& request, const CreateStreamKeyResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::CreateStreamKey, request, handler, context);
  }

  /**
   * <p>Deletes the specified channel and its associated stream keys.</p> <p>If you
   * try to delete a live channel, you will get an error (409 ConflictException). To
   * delete a channel that is live, call <a>StopStream</a>, wait for the Amazon
   * EventBridge "Stream End" event (to verify that the stream's state is no longer
   * Live), then call DeleteChannel. (See <a
   * href="https://docs.aws.amazon.com/ivs/latest/userguide/eventbridge.html"> Using
   * EventBridge with Amazon IVS</a>.) </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;

  /**
   * A Callable wrapper for DeleteChannel that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename DeleteChannelRequestT = Model::DeleteChannelRequest>
  Model::DeleteChannelOutcomeCallable DeleteChannelCallable(const DeleteChannelRequestT& request) const {
    return SubmitCallable(&IVSClient::DeleteChannel, request);
  }

  /**
   * An Async wrapper for DeleteChannel that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename DeleteChannelRequestT = Model::DeleteChannelRequest>
  void DeleteChannelAsync(const DeleteChannelRequestT& request, const DeleteChannelResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::DeleteChannel, request, handler, context);
  }

  /**
   * <p>Deletes a specified authorization key pair. This invalidates future viewer
   * tokens generated using the key pair’s <code>privateKey</code>. For more
   * information, see <a
   * href="https://docs.aws.amazon.com/ivs/latest/userguide/private-channels.html">Setting
   * Up Private Channels</a> in the <i>Amazon IVS User Guide</i>.</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;

  /**
   * A Callable wrapper for DeletePlaybackKeyPair that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeletePlaybackKeyPairRequestT = Model::DeletePlaybackKeyPairRequest>
  Model::DeletePlaybackKeyPairOutcomeCallable DeletePlaybackKeyPairCallable(const DeletePlaybackKeyPairRequestT& request) const {
    return SubmitCallable(&IVSClient::DeletePlaybackKeyPair, request);
  }

  /**
   * An Async wrapper for DeletePlaybackKeyPair that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DeletePlaybackKeyPairRequestT = Model::DeletePlaybackKeyPairRequest>
  void DeletePlaybackKeyPairAsync(const DeletePlaybackKeyPairRequestT& request, const DeletePlaybackKeyPairResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::DeletePlaybackKeyPair, request, handler, context);
  }

  /**
   * <p>Deletes the specified playback restriction policy.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/DeletePlaybackRestrictionPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::DeletePlaybackRestrictionPolicyOutcome DeletePlaybackRestrictionPolicy(
      const Model::DeletePlaybackRestrictionPolicyRequest& request) const;

  /**
   * A Callable wrapper for DeletePlaybackRestrictionPolicy that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DeletePlaybackRestrictionPolicyRequestT = Model::DeletePlaybackRestrictionPolicyRequest>
  Model::DeletePlaybackRestrictionPolicyOutcomeCallable DeletePlaybackRestrictionPolicyCallable(
      const DeletePlaybackRestrictionPolicyRequestT& request) const {
    return SubmitCallable(&IVSClient::DeletePlaybackRestrictionPolicy, request);
  }

  /**
   * An Async wrapper for DeletePlaybackRestrictionPolicy that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename DeletePlaybackRestrictionPolicyRequestT = Model::DeletePlaybackRestrictionPolicyRequest>
  void DeletePlaybackRestrictionPolicyAsync(const DeletePlaybackRestrictionPolicyRequestT& request,
                                            const DeletePlaybackRestrictionPolicyResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::DeletePlaybackRestrictionPolicy, request, handler, context);
  }

  /**
   * <p>Deletes the recording configuration for the specified ARN.</p> <p>If you try
   * to delete a recording configuration that is associated with a channel, you will
   * get an error (409 ConflictException). To avoid this, for all channels that
   * reference the recording configuration, first use <a>UpdateChannel</a> to set the
   * <code>recordingConfigurationArn</code> field to an empty string, then use
   * DeleteRecordingConfiguration.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/DeleteRecordingConfiguration">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteRecordingConfigurationOutcome DeleteRecordingConfiguration(
      const Model::DeleteRecordingConfigurationRequest& request) const;

  /**
   * A Callable wrapper for DeleteRecordingConfiguration that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DeleteRecordingConfigurationRequestT = Model::DeleteRecordingConfigurationRequest>
  Model::DeleteRecordingConfigurationOutcomeCallable DeleteRecordingConfigurationCallable(
      const DeleteRecordingConfigurationRequestT& request) const {
    return SubmitCallable(&IVSClient::DeleteRecordingConfiguration, request);
  }

  /**
   * An Async wrapper for DeleteRecordingConfiguration that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DeleteRecordingConfigurationRequestT = Model::DeleteRecordingConfigurationRequest>
  void DeleteRecordingConfigurationAsync(const DeleteRecordingConfigurationRequestT& request,
                                         const DeleteRecordingConfigurationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::DeleteRecordingConfiguration, request, handler, context);
  }

  /**
   * <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;

  /**
   * A Callable wrapper for DeleteStreamKey that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename DeleteStreamKeyRequestT = Model::DeleteStreamKeyRequest>
  Model::DeleteStreamKeyOutcomeCallable DeleteStreamKeyCallable(const DeleteStreamKeyRequestT& request) const {
    return SubmitCallable(&IVSClient::DeleteStreamKey, request);
  }

  /**
   * An Async wrapper for DeleteStreamKey that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename DeleteStreamKeyRequestT = Model::DeleteStreamKeyRequest>
  void DeleteStreamKeyAsync(const DeleteStreamKeyRequestT& request, const DeleteStreamKeyResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::DeleteStreamKey, request, handler, context);
  }

  /**
   * <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;

  /**
   * A Callable wrapper for GetChannel that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename GetChannelRequestT = Model::GetChannelRequest>
  Model::GetChannelOutcomeCallable GetChannelCallable(const GetChannelRequestT& request) const {
    return SubmitCallable(&IVSClient::GetChannel, request);
  }

  /**
   * An Async wrapper for GetChannel that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename GetChannelRequestT = Model::GetChannelRequest>
  void GetChannelAsync(const GetChannelRequestT& request, const GetChannelResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::GetChannel, request, handler, context);
  }

  /**
   * <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 private channels. For more information, see <a
   * href="https://docs.aws.amazon.com/ivs/latest/userguide/private-channels.html">Setting
   * Up Private Channels</a> in the <i>Amazon IVS User Guide</i>.</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;

  /**
   * A Callable wrapper for GetPlaybackKeyPair that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename GetPlaybackKeyPairRequestT = Model::GetPlaybackKeyPairRequest>
  Model::GetPlaybackKeyPairOutcomeCallable GetPlaybackKeyPairCallable(const GetPlaybackKeyPairRequestT& request) const {
    return SubmitCallable(&IVSClient::GetPlaybackKeyPair, request);
  }

  /**
   * An Async wrapper for GetPlaybackKeyPair that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename GetPlaybackKeyPairRequestT = Model::GetPlaybackKeyPairRequest>
  void GetPlaybackKeyPairAsync(const GetPlaybackKeyPairRequestT& request, const GetPlaybackKeyPairResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::GetPlaybackKeyPair, request, handler, context);
  }

  /**
   * <p>Gets the specified playback restriction policy.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/GetPlaybackRestrictionPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::GetPlaybackRestrictionPolicyOutcome GetPlaybackRestrictionPolicy(
      const Model::GetPlaybackRestrictionPolicyRequest& request) const;

  /**
   * A Callable wrapper for GetPlaybackRestrictionPolicy that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename GetPlaybackRestrictionPolicyRequestT = Model::GetPlaybackRestrictionPolicyRequest>
  Model::GetPlaybackRestrictionPolicyOutcomeCallable GetPlaybackRestrictionPolicyCallable(
      const GetPlaybackRestrictionPolicyRequestT& request) const {
    return SubmitCallable(&IVSClient::GetPlaybackRestrictionPolicy, request);
  }

  /**
   * An Async wrapper for GetPlaybackRestrictionPolicy that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename GetPlaybackRestrictionPolicyRequestT = Model::GetPlaybackRestrictionPolicyRequest>
  void GetPlaybackRestrictionPolicyAsync(const GetPlaybackRestrictionPolicyRequestT& request,
                                         const GetPlaybackRestrictionPolicyResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::GetPlaybackRestrictionPolicy, request, handler, context);
  }

  /**
   * <p>Gets the recording configuration for the specified ARN.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/GetRecordingConfiguration">AWS
   * API Reference</a></p>
   */
  virtual Model::GetRecordingConfigurationOutcome GetRecordingConfiguration(const Model::GetRecordingConfigurationRequest& request) const;

  /**
   * A Callable wrapper for GetRecordingConfiguration that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename GetRecordingConfigurationRequestT = Model::GetRecordingConfigurationRequest>
  Model::GetRecordingConfigurationOutcomeCallable GetRecordingConfigurationCallable(
      const GetRecordingConfigurationRequestT& request) const {
    return SubmitCallable(&IVSClient::GetRecordingConfiguration, request);
  }

  /**
   * An Async wrapper for GetRecordingConfiguration that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename GetRecordingConfigurationRequestT = Model::GetRecordingConfigurationRequest>
  void GetRecordingConfigurationAsync(const GetRecordingConfigurationRequestT& request,
                                      const GetRecordingConfigurationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::GetRecordingConfiguration, request, handler, context);
  }

  /**
   * <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;

  /**
   * A Callable wrapper for GetStream that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename GetStreamRequestT = Model::GetStreamRequest>
  Model::GetStreamOutcomeCallable GetStreamCallable(const GetStreamRequestT& request) const {
    return SubmitCallable(&IVSClient::GetStream, request);
  }

  /**
   * An Async wrapper for GetStream that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename GetStreamRequestT = Model::GetStreamRequest>
  void GetStreamAsync(const GetStreamRequestT& request, const GetStreamResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::GetStream, request, handler, context);
  }

  /**
   * <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;

  /**
   * A Callable wrapper for GetStreamKey that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename GetStreamKeyRequestT = Model::GetStreamKeyRequest>
  Model::GetStreamKeyOutcomeCallable GetStreamKeyCallable(const GetStreamKeyRequestT& request) const {
    return SubmitCallable(&IVSClient::GetStreamKey, request);
  }

  /**
   * An Async wrapper for GetStreamKey that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename GetStreamKeyRequestT = Model::GetStreamKeyRequest>
  void GetStreamKeyAsync(const GetStreamKeyRequestT& request, const GetStreamKeyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::GetStreamKey, request, handler, context);
  }

  /**
   * <p>Gets metadata on a specified stream.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/GetStreamSession">AWS
   * API Reference</a></p>
   */
  virtual Model::GetStreamSessionOutcome GetStreamSession(const Model::GetStreamSessionRequest& request) const;

  /**
   * A Callable wrapper for GetStreamSession that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename GetStreamSessionRequestT = Model::GetStreamSessionRequest>
  Model::GetStreamSessionOutcomeCallable GetStreamSessionCallable(const GetStreamSessionRequestT& request) const {
    return SubmitCallable(&IVSClient::GetStreamSession, request);
  }

  /**
   * An Async wrapper for GetStreamSession that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename GetStreamSessionRequestT = Model::GetStreamSessionRequest>
  void GetStreamSessionAsync(const GetStreamSessionRequestT& request, const GetStreamSessionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::GetStreamSession, request, handler, context);
  }

  /**
   * <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 private
   * channels. For more information, see <a
   * href="https://docs.aws.amazon.com/ivs/latest/userguide/private-channels.html">Setting
   * Up Private Channels</a> in the <i>Amazon IVS User Guide</i>.</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;

  /**
   * A Callable wrapper for ImportPlaybackKeyPair that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ImportPlaybackKeyPairRequestT = Model::ImportPlaybackKeyPairRequest>
  Model::ImportPlaybackKeyPairOutcomeCallable ImportPlaybackKeyPairCallable(const ImportPlaybackKeyPairRequestT& request) const {
    return SubmitCallable(&IVSClient::ImportPlaybackKeyPair, request);
  }

  /**
   * An Async wrapper for ImportPlaybackKeyPair that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename ImportPlaybackKeyPairRequestT = Model::ImportPlaybackKeyPairRequest>
  void ImportPlaybackKeyPairAsync(const ImportPlaybackKeyPairRequestT& request, const ImportPlaybackKeyPairResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::ImportPlaybackKeyPair, request, handler, context);
  }

  /**
   * <p>Gets summary information about all channels in your account, in the Amazon
   * Web Services region where the API request is processed. This list can be
   * filtered to match a specified name or recording-configuration ARN. Filters are
   * mutually exclusive and cannot be used together. If you try to use both filters,
   * you will get an error (409 ConflictException).</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;

  /**
   * A Callable wrapper for ListChannels that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename ListChannelsRequestT = Model::ListChannelsRequest>
  Model::ListChannelsOutcomeCallable ListChannelsCallable(const ListChannelsRequestT& request = {}) const {
    return SubmitCallable(&IVSClient::ListChannels, request);
  }

  /**
   * An Async wrapper for ListChannels that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename ListChannelsRequestT = Model::ListChannelsRequest>
  void ListChannelsAsync(const ListChannelsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListChannelsRequestT& request = {}) const {
    return SubmitAsync(&IVSClient::ListChannels, request, handler, context);
  }

  /**
   * <p>Gets summary information about playback key pairs. For more information, see
   * <a
   * href="https://docs.aws.amazon.com/ivs/latest/userguide/private-channels.html">Setting
   * Up Private Channels</a> in the <i>Amazon IVS User Guide</i>.</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;

  /**
   * A Callable wrapper for ListPlaybackKeyPairs that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListPlaybackKeyPairsRequestT = Model::ListPlaybackKeyPairsRequest>
  Model::ListPlaybackKeyPairsOutcomeCallable ListPlaybackKeyPairsCallable(const ListPlaybackKeyPairsRequestT& request = {}) const {
    return SubmitCallable(&IVSClient::ListPlaybackKeyPairs, request);
  }

  /**
   * An Async wrapper for ListPlaybackKeyPairs that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename ListPlaybackKeyPairsRequestT = Model::ListPlaybackKeyPairsRequest>
  void ListPlaybackKeyPairsAsync(const ListPlaybackKeyPairsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListPlaybackKeyPairsRequestT& request = {}) const {
    return SubmitAsync(&IVSClient::ListPlaybackKeyPairs, request, handler, context);
  }

  /**
   * <p>Gets summary information about playback restriction policies.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/ListPlaybackRestrictionPolicies">AWS
   * API Reference</a></p>
   */
  virtual Model::ListPlaybackRestrictionPoliciesOutcome ListPlaybackRestrictionPolicies(
      const Model::ListPlaybackRestrictionPoliciesRequest& request = {}) const;

  /**
   * A Callable wrapper for ListPlaybackRestrictionPolicies that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename ListPlaybackRestrictionPoliciesRequestT = Model::ListPlaybackRestrictionPoliciesRequest>
  Model::ListPlaybackRestrictionPoliciesOutcomeCallable ListPlaybackRestrictionPoliciesCallable(
      const ListPlaybackRestrictionPoliciesRequestT& request = {}) const {
    return SubmitCallable(&IVSClient::ListPlaybackRestrictionPolicies, request);
  }

  /**
   * An Async wrapper for ListPlaybackRestrictionPolicies that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename ListPlaybackRestrictionPoliciesRequestT = Model::ListPlaybackRestrictionPoliciesRequest>
  void ListPlaybackRestrictionPoliciesAsync(const ListPlaybackRestrictionPoliciesResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const ListPlaybackRestrictionPoliciesRequestT& request = {}) const {
    return SubmitAsync(&IVSClient::ListPlaybackRestrictionPolicies, request, handler, context);
  }

  /**
   * <p>Gets summary information about all recording configurations in your account,
   * in the Amazon Web Services 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/ListRecordingConfigurations">AWS
   * API Reference</a></p>
   */
  virtual Model::ListRecordingConfigurationsOutcome ListRecordingConfigurations(
      const Model::ListRecordingConfigurationsRequest& request = {}) const;

  /**
   * A Callable wrapper for ListRecordingConfigurations that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename ListRecordingConfigurationsRequestT = Model::ListRecordingConfigurationsRequest>
  Model::ListRecordingConfigurationsOutcomeCallable ListRecordingConfigurationsCallable(
      const ListRecordingConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&IVSClient::ListRecordingConfigurations, request);
  }

  /**
   * An Async wrapper for ListRecordingConfigurations that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename ListRecordingConfigurationsRequestT = Model::ListRecordingConfigurationsRequest>
  void ListRecordingConfigurationsAsync(const ListRecordingConfigurationsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const ListRecordingConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&IVSClient::ListRecordingConfigurations, request, handler, context);
  }

  /**
   * <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;

  /**
   * A Callable wrapper for ListStreamKeys that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename ListStreamKeysRequestT = Model::ListStreamKeysRequest>
  Model::ListStreamKeysOutcomeCallable ListStreamKeysCallable(const ListStreamKeysRequestT& request) const {
    return SubmitCallable(&IVSClient::ListStreamKeys, request);
  }

  /**
   * An Async wrapper for ListStreamKeys that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename ListStreamKeysRequestT = Model::ListStreamKeysRequest>
  void ListStreamKeysAsync(const ListStreamKeysRequestT& request, const ListStreamKeysResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::ListStreamKeys, request, handler, context);
  }

  /**
   * <p>Gets a summary of current and previous streams for a specified channel 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/ListStreamSessions">AWS
   * API Reference</a></p>
   */
  virtual Model::ListStreamSessionsOutcome ListStreamSessions(const Model::ListStreamSessionsRequest& request) const;

  /**
   * A Callable wrapper for ListStreamSessions that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListStreamSessionsRequestT = Model::ListStreamSessionsRequest>
  Model::ListStreamSessionsOutcomeCallable ListStreamSessionsCallable(const ListStreamSessionsRequestT& request) const {
    return SubmitCallable(&IVSClient::ListStreamSessions, request);
  }

  /**
   * An Async wrapper for ListStreamSessions that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename ListStreamSessionsRequestT = Model::ListStreamSessionsRequest>
  void ListStreamSessionsAsync(const ListStreamSessionsRequestT& request, const ListStreamSessionsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::ListStreamSessions, request, handler, context);
  }

  /**
   * <p>Gets summary information about live streams in your account, in the Amazon
   * Web Services 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;

  /**
   * A Callable wrapper for ListStreams that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename ListStreamsRequestT = Model::ListStreamsRequest>
  Model::ListStreamsOutcomeCallable ListStreamsCallable(const ListStreamsRequestT& request = {}) const {
    return SubmitCallable(&IVSClient::ListStreams, request);
  }

  /**
   * An Async wrapper for ListStreams that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename ListStreamsRequestT = Model::ListStreamsRequest>
  void ListStreamsAsync(const ListStreamsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListStreamsRequestT& request = {}) const {
    return SubmitAsync(&IVSClient::ListStreams, request, handler, context);
  }

  /**
   * <p>Gets information about Amazon Web Services 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;

  /**
   * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&IVSClient::ListTagsForResource, request);
  }

  /**
   * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::ListTagsForResource, request, handler, context);
  }

  /**
   * <p>Inserts metadata into the active stream of the specified channel. At most 5
   * requests per second per channel are allowed, each with a maximum 1 KB payload.
   * (If 5 TPS is not sufficient for your needs, we recommend batching your data into
   * a single PutMetadata call.) At most 155 requests per second per account are
   * allowed. Also see <a
   * href="https://docs.aws.amazon.com/ivs/latest/userguide/metadata.html">Embedding
   * Metadata within a Video Stream</a> in the <i>Amazon IVS User
   * Guide</i>.</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;

  /**
   * A Callable wrapper for PutMetadata that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename PutMetadataRequestT = Model::PutMetadataRequest>
  Model::PutMetadataOutcomeCallable PutMetadataCallable(const PutMetadataRequestT& request) const {
    return SubmitCallable(&IVSClient::PutMetadata, request);
  }

  /**
   * An Async wrapper for PutMetadata that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename PutMetadataRequestT = Model::PutMetadataRequest>
  void PutMetadataAsync(const PutMetadataRequestT& request, const PutMetadataResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::PutMetadata, request, handler, context);
  }

  /**
   * <p>Starts the process of revoking the viewer session associated with a specified
   * channel ARN and viewer ID. Optionally, you can provide a version to revoke
   * viewer sessions less than and including that version. For instructions on
   * associating a viewer ID with a viewer session, see <a
   * href="https://docs.aws.amazon.com/ivs/latest/userguide/private-channels.html">Setting
   * Up Private Channels</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/StartViewerSessionRevocation">AWS
   * API Reference</a></p>
   */
  virtual Model::StartViewerSessionRevocationOutcome StartViewerSessionRevocation(
      const Model::StartViewerSessionRevocationRequest& request) const;

  /**
   * A Callable wrapper for StartViewerSessionRevocation that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename StartViewerSessionRevocationRequestT = Model::StartViewerSessionRevocationRequest>
  Model::StartViewerSessionRevocationOutcomeCallable StartViewerSessionRevocationCallable(
      const StartViewerSessionRevocationRequestT& request) const {
    return SubmitCallable(&IVSClient::StartViewerSessionRevocation, request);
  }

  /**
   * An Async wrapper for StartViewerSessionRevocation that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename StartViewerSessionRevocationRequestT = Model::StartViewerSessionRevocationRequest>
  void StartViewerSessionRevocationAsync(const StartViewerSessionRevocationRequestT& request,
                                         const StartViewerSessionRevocationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::StartViewerSessionRevocation, request, handler, context);
  }

  /**
   * <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;

  /**
   * A Callable wrapper for StopStream that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename StopStreamRequestT = Model::StopStreamRequest>
  Model::StopStreamOutcomeCallable StopStreamCallable(const StopStreamRequestT& request) const {
    return SubmitCallable(&IVSClient::StopStream, request);
  }

  /**
   * An Async wrapper for StopStream that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename StopStreamRequestT = Model::StopStreamRequest>
  void StopStreamAsync(const StopStreamRequestT& request, const StopStreamResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::StopStream, request, handler, context);
  }

  /**
   * <p>Adds or updates tags for the Amazon Web Services 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;

  /**
   * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&IVSClient::TagResource, request);
  }

  /**
   * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::TagResource, request, handler, context);
  }

  /**
   * <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;

  /**
   * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&IVSClient::UntagResource, request);
  }

  /**
   * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::UntagResource, request, handler, context);
  }

  /**
   * <p>Updates a channel's configuration. Live channels cannot be updated. You must
   * stop the ongoing stream, update the channel, 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;

  /**
   * A Callable wrapper for UpdateChannel that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename UpdateChannelRequestT = Model::UpdateChannelRequest>
  Model::UpdateChannelOutcomeCallable UpdateChannelCallable(const UpdateChannelRequestT& request) const {
    return SubmitCallable(&IVSClient::UpdateChannel, request);
  }

  /**
   * An Async wrapper for UpdateChannel that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename UpdateChannelRequestT = Model::UpdateChannelRequest>
  void UpdateChannelAsync(const UpdateChannelRequestT& request, const UpdateChannelResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::UpdateChannel, request, handler, context);
  }

  /**
   * <p>Updates a specified playback restriction policy.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14/UpdatePlaybackRestrictionPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdatePlaybackRestrictionPolicyOutcome UpdatePlaybackRestrictionPolicy(
      const Model::UpdatePlaybackRestrictionPolicyRequest& request) const;

  /**
   * A Callable wrapper for UpdatePlaybackRestrictionPolicy that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename UpdatePlaybackRestrictionPolicyRequestT = Model::UpdatePlaybackRestrictionPolicyRequest>
  Model::UpdatePlaybackRestrictionPolicyOutcomeCallable UpdatePlaybackRestrictionPolicyCallable(
      const UpdatePlaybackRestrictionPolicyRequestT& request) const {
    return SubmitCallable(&IVSClient::UpdatePlaybackRestrictionPolicy, request);
  }

  /**
   * An Async wrapper for UpdatePlaybackRestrictionPolicy that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename UpdatePlaybackRestrictionPolicyRequestT = Model::UpdatePlaybackRestrictionPolicyRequest>
  void UpdatePlaybackRestrictionPolicyAsync(const UpdatePlaybackRestrictionPolicyRequestT& request,
                                            const UpdatePlaybackRestrictionPolicyResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IVSClient::UpdatePlaybackRestrictionPolicy, request, handler, context);
  }

  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<IVSEndpointProviderBase>& accessEndpointProvider();

 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<IVSClient>;
  void init(const IVSClientConfiguration& clientConfiguration);

  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, IVSError> InvokeOperationOutcome;

  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;

  IVSClientConfiguration m_clientConfiguration;
  std::shared_ptr<IVSEndpointProviderBase> m_endpointProvider;
};

}  // namespace IVS
}  // namespace Aws
