/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace IVS { /** *

Introduction

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.

The API is an Amazon Web Services regional * service. For a list of supported regions and Amazon IVS HTTPS service endpoints, * see the Amazon * IVS page in the Amazon Web Services General Reference.

* All API request parameters and URLs are case sensitive.

For * a summary of notable documentation changes in each release, see * Document History.

Allowed Header Values

  • * Accept: application/json

  • * Accept-Encoding: gzip, deflate

  • * Content-Type: application/json

* Resources

The following resources contain information about your * IVS live stream (see * Getting Started with Amazon IVS):

  • 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.

  • 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. * Treat the stream key like a secret, since it allows anyone to stream to the * channel.

  • 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.

  • Recording configuration — Stores * configuration related to recording a live stream and where to store the recorded * content. Multiple channels can reference the same recording configuration. See * the Recording Configuration endpoints for more information.

* Tagging

A tag is a metadata label that you assign to an * Amazon Web Services resource. A tag comprises a key and a value, * both set by you. For example, you might set a tag as topic:nature * to label a particular video category. See Tagging * Amazon Web Services Resources for more information, including restrictions * that apply to tags and "Tag naming limits and requirements"; Amazon IVS has no * service-specific constraints beyond what is documented there.

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 Access * Tags).

The Amazon IVS API has these tag-related endpoints: * TagResource, UntagResource, and ListTagsForResource. The * following resources support tagging: Channels, Stream Keys, Playback Key Pairs, * and Recording Configurations.

At most 50 tags can be applied to a * resource.

Authentication versus Authorization

Note the * differences between these concepts:

  • Authentication is * about verifying identity. You need to be authenticated to sign Amazon IVS API * requests.

  • Authorization is about granting permissions. * Your IAM roles need to have permissions for Amazon IVS API requests. In * addition, authorization is needed to view Amazon * IVS private channels. (Private channels are channels that are enabled for * "playback authorization.")

Authentication

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.

*

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 * ivs:PutMetadata permission.

For more information:

Amazon Resource Names (ARNs)

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 Amazon * Resource Names in the AWS General Reference.

Channel * Endpoints

  • CreateChannel — Creates a new channel * and an associated stream key to start streaming.

  • * GetChannel — Gets the channel configuration for the specified channel * ARN.

  • BatchGetChannel — Performs GetChannel on * multiple ARNs simultaneously.

  • ListChannels — 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 Conflict Exception).

  • UpdateChannel — * 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.

  • DeleteChannel — Deletes the specified * channel.

StreamKey Endpoints

  • * CreateStreamKey — Creates a stream key, used to initiate a stream, for * the specified channel ARN.

  • GetStreamKey — Gets stream * key information for the specified ARN.

  • * BatchGetStreamKey — Performs GetStreamKey on multiple ARNs * simultaneously.

  • ListStreamKeys — Gets summary * information about stream keys for the specified channel.

  • * DeleteStreamKey — Deletes the stream key for the specified ARN, so it can * no longer be used to stream.

Stream Endpoints

*

  • GetStream — Gets information about the active (live) stream * on a specified channel.

  • GetStreamSession — Gets * metadata on a specified stream.

  • ListStreams — Gets * summary information about live streams in your account, in the Amazon Web * Services region where the API request is processed.

  • * ListStreamSessions — 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.

  • StopStream — Disconnects the incoming RTMPS * stream for the specified channel. Can be used in conjunction with * DeleteStreamKey to prevent further streaming to a channel.

  • *

    PutMetadata — 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.

Private * Channel Endpoints

For more information, see Setting * Up Private Channels in the Amazon IVS User Guide.

  • * ImportPlaybackKeyPair — Imports the public portion of a new key pair and * returns its arn and fingerprint. The * privateKey can then be used to generate viewer authorization * tokens, to grant viewers access to private channels (channels enabled for * playback authorization).

  • GetPlaybackKeyPair — Gets a * specified playback authorization key pair and returns the arn and * fingerprint. The privateKey held by the caller can be * used to generate viewer authorization tokens, to grant viewers access to private * channels.

  • ListPlaybackKeyPairs — Gets summary * information about playback key pairs.

  • * DeletePlaybackKeyPair — Deletes a specified authorization key pair. This * invalidates future viewer tokens generated using the key pair’s * privateKey.

  • StartViewerSessionRevocation * — 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.

  • * BatchStartViewerSessionRevocation — Performs * StartViewerSessionRevocation on multiple channel ARN and viewer ID pairs * simultaneously.

RecordingConfiguration Endpoints

*

Amazon Web Services Tags * Endpoints

  • TagResource — Adds or updates tags for * the Amazon Web Services resource with the specified ARN.

  • * UntagResource — Removes tags from the resource with the specified * ARN.

  • ListTagsForResource — Gets information about * Amazon Web Services tags for the specified ARN.

*/ class AWS_IVS_API IVSClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; 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 endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * 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 endpointProvider = Aws::MakeShared(ALLOCATION_TAG), 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& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), 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& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~IVSClient(); /** *

Performs GetChannel on multiple ARNs simultaneously.

See * Also:

AWS * API Reference

*/ 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 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 void BatchGetChannelAsync(const BatchGetChannelRequestT& request, const BatchGetChannelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::BatchGetChannel, request, handler, context); } /** *

Performs GetStreamKey on multiple ARNs simultaneously.

See * Also:

AWS * API Reference

*/ 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 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 void BatchGetStreamKeyAsync(const BatchGetStreamKeyRequestT& request, const BatchGetStreamKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::BatchGetStreamKey, request, handler, context); } /** *

Performs StartViewerSessionRevocation on multiple channel ARN and * viewer ID pairs simultaneously.

See Also:

AWS * API Reference

*/ 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 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 void BatchStartViewerSessionRevocationAsync(const BatchStartViewerSessionRevocationRequestT& request, const BatchStartViewerSessionRevocationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::BatchStartViewerSessionRevocation, request, handler, context); } /** *

Creates a new channel and an associated stream key to start * streaming.

See Also:

AWS * API Reference

*/ 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 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 void CreateChannelAsync(const CreateChannelRequestT& request, const CreateChannelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::CreateChannel, request, handler, context); } /** *

Creates a new recording configuration, used to enable recording to Amazon * S3.

Known issue: 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 state of * the recording configuration is CREATE_FAILED (instead of * ACTIVE). (In other regions, the CLI correctly returns failure if * the bucket is in a different region.)

Workaround: 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.

See Also:

AWS * API Reference

*/ 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 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 void CreateRecordingConfigurationAsync(const CreateRecordingConfigurationRequestT& request, const CreateRecordingConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::CreateRecordingConfiguration, request, handler, context); } /** *

Creates a stream key, used to initiate a stream, for the specified channel * ARN.

Note that CreateChannel 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 DeleteStreamKey and then * CreateStreamKey.

See Also:

AWS * API Reference

*/ 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 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 void CreateStreamKeyAsync(const CreateStreamKeyRequestT& request, const CreateStreamKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::CreateStreamKey, request, handler, context); } /** *

Deletes the specified channel and its associated stream keys.

If you * try to delete a live channel, you will get an error (409 ConflictException). To * delete a channel that is live, call StopStream, wait for the Amazon * EventBridge "Stream End" event (to verify that the stream's state is no longer * Live), then call DeleteChannel. (See Using * EventBridge with Amazon IVS.)

See Also:

AWS * API Reference

*/ 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 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 void DeleteChannelAsync(const DeleteChannelRequestT& request, const DeleteChannelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::DeleteChannel, request, handler, context); } /** *

Deletes a specified authorization key pair. This invalidates future viewer * tokens generated using the key pair’s privateKey. For more * information, see Setting * Up Private Channels in the Amazon IVS User Guide.

See * Also:

AWS * API Reference

*/ 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 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 void DeletePlaybackKeyPairAsync(const DeletePlaybackKeyPairRequestT& request, const DeletePlaybackKeyPairResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::DeletePlaybackKeyPair, request, handler, context); } /** *

Deletes the recording configuration for the specified ARN.

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 UpdateChannel to set the * recordingConfigurationArn field to an empty string, then use * DeleteRecordingConfiguration.

See Also:

AWS * API Reference

*/ 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 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 void DeleteRecordingConfigurationAsync(const DeleteRecordingConfigurationRequestT& request, const DeleteRecordingConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::DeleteRecordingConfiguration, request, handler, context); } /** *

Deletes the stream key for the specified ARN, so it can no longer be used to * stream.

See Also:

AWS * API Reference

*/ 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 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 void DeleteStreamKeyAsync(const DeleteStreamKeyRequestT& request, const DeleteStreamKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::DeleteStreamKey, request, handler, context); } /** *

Gets the channel configuration for the specified channel ARN. See also * BatchGetChannel.

See Also:

AWS API * Reference

*/ 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 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 void GetChannelAsync(const GetChannelRequestT& request, const GetChannelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::GetChannel, request, handler, context); } /** *

Gets a specified playback authorization key pair and returns the * arn and fingerprint. The privateKey held * by the caller can be used to generate viewer authorization tokens, to grant * viewers access to private channels. For more information, see Setting * Up Private Channels in the Amazon IVS User Guide.

See * Also:

AWS * API Reference

*/ 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 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 void GetPlaybackKeyPairAsync(const GetPlaybackKeyPairRequestT& request, const GetPlaybackKeyPairResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::GetPlaybackKeyPair, request, handler, context); } /** *

Gets the recording configuration for the specified ARN.

See * Also:

AWS * API Reference

*/ 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 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 void GetRecordingConfigurationAsync(const GetRecordingConfigurationRequestT& request, const GetRecordingConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::GetRecordingConfiguration, request, handler, context); } /** *

Gets information about the active (live) stream on a specified * channel.

See Also:

AWS API * Reference

*/ 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 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 void GetStreamAsync(const GetStreamRequestT& request, const GetStreamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::GetStream, request, handler, context); } /** *

Gets stream-key information for a specified ARN.

See Also:

* AWS * API Reference

*/ 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 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 void GetStreamKeyAsync(const GetStreamKeyRequestT& request, const GetStreamKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::GetStreamKey, request, handler, context); } /** *

Gets metadata on a specified stream.

See Also:

AWS * API Reference

*/ 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 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 void GetStreamSessionAsync(const GetStreamSessionRequestT& request, const GetStreamSessionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::GetStreamSession, request, handler, context); } /** *

Imports the public portion of a new key pair and returns its arn * and fingerprint. The privateKey can then be used to * generate viewer authorization tokens, to grant viewers access to private * channels. For more information, see Setting * Up Private Channels in the Amazon IVS User Guide.

See * Also:

AWS * API Reference

*/ 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 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 void ImportPlaybackKeyPairAsync(const ImportPlaybackKeyPairRequestT& request, const ImportPlaybackKeyPairResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::ImportPlaybackKeyPair, request, handler, context); } /** *

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).

See Also:

AWS * API Reference

*/ 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 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 void ListChannelsAsync(const ListChannelsRequestT& request, const ListChannelsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::ListChannels, request, handler, context); } /** *

Gets summary information about playback key pairs. For more information, see * Setting * Up Private Channels in the Amazon IVS User Guide.

See * Also:

AWS * API Reference

*/ 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 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 void ListPlaybackKeyPairsAsync(const ListPlaybackKeyPairsRequestT& request, const ListPlaybackKeyPairsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::ListPlaybackKeyPairs, request, handler, context); } /** *

Gets summary information about all recording configurations in your account, * in the Amazon Web Services region where the API request is * processed.

See Also:

AWS * API Reference

*/ 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 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 void ListRecordingConfigurationsAsync(const ListRecordingConfigurationsRequestT& request, const ListRecordingConfigurationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::ListRecordingConfigurations, request, handler, context); } /** *

Gets summary information about stream keys for the specified * channel.

See Also:

AWS * API Reference

*/ 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 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 void ListStreamKeysAsync(const ListStreamKeysRequestT& request, const ListStreamKeysResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::ListStreamKeys, request, handler, context); } /** *

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.

See Also:

AWS * API Reference

*/ 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 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 void ListStreamSessionsAsync(const ListStreamSessionsRequestT& request, const ListStreamSessionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::ListStreamSessions, request, handler, context); } /** *

Gets summary information about live streams in your account, in the Amazon * Web Services region where the API request is processed.

See Also:

* AWS * API Reference

*/ 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 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 void ListStreamsAsync(const ListStreamsRequestT& request, const ListStreamsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::ListStreams, request, handler, context); } /** *

Gets information about Amazon Web Services tags for the specified * ARN.

See Also:

AWS * API Reference

*/ 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 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 void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::ListTagsForResource, request, handler, context); } /** *

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 Embedding * Metadata within a Video Stream in the Amazon IVS User * Guide.

See Also:

AWS API * Reference

*/ 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 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 void PutMetadataAsync(const PutMetadataRequestT& request, const PutMetadataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::PutMetadata, request, handler, context); } /** *

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 Setting * Up Private Channels.

See Also:

AWS * API Reference

*/ 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 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 void StartViewerSessionRevocationAsync(const StartViewerSessionRevocationRequestT& request, const StartViewerSessionRevocationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::StartViewerSessionRevocation, request, handler, context); } /** *

Disconnects the incoming RTMPS stream for the specified channel. Can be used * in conjunction with DeleteStreamKey to prevent further streaming to a * channel.

Many streaming client-software libraries automatically * reconnect a dropped RTMPS session, so to stop the stream permanently, you may * want to first revoke the streamKey attached to the channel.

*

See Also:

AWS API * Reference

*/ 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 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 void StopStreamAsync(const StopStreamRequestT& request, const StopStreamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::StopStream, request, handler, context); } /** *

Adds or updates tags for the Amazon Web Services resource with the specified * ARN.

See Also:

AWS API * Reference

*/ 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 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 void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::TagResource, request, handler, context); } /** *

Removes tags from the resource with the specified ARN.

See * Also:

AWS * API Reference

*/ 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 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 void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::UntagResource, request, handler, context); } /** *

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.

See Also:

AWS * API Reference

*/ 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 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 void UpdateChannelAsync(const UpdateChannelRequestT& request, const UpdateChannelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IVSClient::UpdateChannel, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const IVSClientConfiguration& clientConfiguration); IVSClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace IVS } // namespace Aws