Module types 

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that Amazon Chime SDK Media Pipelines can respond with.

Structs

ActiveSpeakerOnlyConfiguration

Defines the configuration for an ActiveSpeakerOnly video tile.

AmazonTranscribeCallAnalyticsProcessorConfiguration

A structure that contains the configuration settings for an Amazon Transcribe call analytics processor.

AmazonTranscribeProcessorConfiguration

A structure that contains the configuration settings for an Amazon Transcribe processor.

Calls to this API must include a LanguageCode, IdentifyLanguage, or IdentifyMultipleLanguages parameter. If you include more than one of those parameters, your transcription job fails.

ArtifactsConcatenationConfiguration

The configuration for the artifacts concatenation.

ArtifactsConfiguration

The configuration for the artifacts.

AudioArtifactsConfiguration

The audio artifact configuration object.

AudioConcatenationConfiguration

The audio artifact concatenation configuration object.

ChannelDefinition

Defines an audio channel in a Kinesis video stream.

ChimeSdkMeetingConcatenationConfiguration

The configuration object of the Amazon Chime SDK meeting concatenation for a specified media pipeline.

ChimeSdkMeetingConfiguration

The configuration object of the Amazon Chime SDK meeting for a specified media pipeline. SourceType must be ChimeSdkMeeting.

ChimeSdkMeetingLiveConnectorConfiguration

The media pipeline's configuration object.

CompositedVideoArtifactsConfiguration

Specifies the configuration for compositing video artifacts.

CompositedVideoConcatenationConfiguration

The composited video configuration object for a specified media pipeline. SourceType must be ChimeSdkMeeting.

ConcatenationSink

The data sink of the configuration object.

ConcatenationSource

The source type and media pipeline configuration settings in a configuration object.

ContentArtifactsConfiguration

The content artifact object.

ContentConcatenationConfiguration

The composited content configuration object for a specified media pipeline.

DataChannelConcatenationConfiguration

The content configuration object's data channel.

FragmentSelector

Describes the timestamp range and timestamp origin of a range of fragments.

Only fragments with a start timestamp greater than or equal to the given start time and less than or equal to the end time are returned. For example, say a stream contains fragments with the following start timestamps:

• 00:00:00

• 00:00:02

• 00:00:04

• 00:00:06

A fragment selector range with a start time of 00:00:01 and end time of 00:00:04 would return the fragments with start times of 00:00:02 and 00:00:04.

GridViewConfiguration

Specifies the type of grid layout.

HorizontalLayoutConfiguration

Defines the configuration settings for the horizontal layout.

IssueDetectionConfiguration

A structure that contains the configuration settings for an issue detection task.

KeywordMatchConfiguration

A structure that contains the settings for a keyword match task.

KinesisDataStreamSinkConfiguration

A structure that contains the configuration settings for a Kinesis Data Stream sink.

KinesisVideoStreamConfiguration

The configuration of an Kinesis video stream.

If a meeting uses an opt-in Region as its MediaRegion, the KVS stream must be in that same Region. For example, if a meeting uses the af-south-1 Region, the KVS stream must also be in af-south-1. However, if the meeting uses a Region that AWS turns on by default, the KVS stream can be in any available Region, including an opt-in Region. For example, if the meeting uses ca-central-1, the KVS stream can be in eu-west-2, us-east-1, af-south-1, or any other Region that the Amazon Chime SDK supports.

To learn which AWS Region a meeting uses, call the GetMeeting API and use the MediaRegion parameter from the response.

For more information about opt-in Regions, refer to Available Regions in the Amazon Chime SDK Developer Guide, and Specify which AWS Regions your account can use, in the AWS Account Management Reference Guide.

KinesisVideoStreamConfigurationUpdate

The updated Kinesis video stream configuration object.

KinesisVideoStreamPoolConfiguration

The video stream pool configuration object.

KinesisVideoStreamPoolSummary

A summary of the Kinesis video stream pool.

KinesisVideoStreamRecordingSourceRuntimeConfiguration

A structure that contains the runtime settings for recording a Kinesis video stream.

KinesisVideoStreamSourceRuntimeConfiguration

The runtime configuration settings for the Kinesis video stream source.

KinesisVideoStreamSourceTaskConfiguration

The task configuration settings for the Kinesis video stream source.

LambdaFunctionSinkConfiguration

A structure that contains the configuration settings for an AWS Lambda function's data sink.

LiveConnectorRtmpConfiguration

The media pipeline's RTMP configuration object.

LiveConnectorSinkConfiguration

The media pipeline's sink configuration settings.

LiveConnectorSourceConfiguration

The data source configuration object of a streaming media pipeline.

MediaCapturePipeline

A media pipeline object consisting of an ID, source type, source ARN, a sink type, a sink ARN, and a configuration object.

MediaCapturePipelineSourceConfiguration

The source configuration object of a media capture pipeline.

MediaCapturePipelineSummary

The summary data of a media capture pipeline.

MediaConcatenationPipeline

Concatenates audio and video data from one or more data streams.

MediaInsightsPipeline

A media pipeline that streams call analytics data.

MediaInsightsPipelineConfiguration

A structure that contains the configuration settings for a media insights pipeline.

MediaInsightsPipelineConfigurationElement

An element in a media insights pipeline configuration.

MediaInsightsPipelineConfigurationSummary

A summary of the media insights pipeline configuration.

MediaInsightsPipelineElementStatus

The status of the pipeline element.

MediaLiveConnectorPipeline

The connector pipeline.

MediaPipeline

A pipeline consisting of a media capture, media concatenation, or live-streaming pipeline.

MediaPipelineSummary

The summary of the media pipeline.

MediaStreamPipeline

Structure that contains the settings for a media stream pipeline.

MediaStreamSink

Structure that contains the settings for a media stream sink.

MediaStreamSource

Structure that contains the settings for media stream sources.

MeetingEventsConcatenationConfiguration

The configuration object for an event concatenation pipeline.

PostCallAnalyticsSettings

Allows you to specify additional settings for your Call Analytics post-call request, including output locations for your redacted transcript, which IAM role to use, and which encryption key to use.

DataAccessRoleArn and OutputLocation are required fields.

PostCallAnalyticsSettings provides the same insights as a Call Analytics post-call transcription. For more information, refer to Post-call analytics with real-time transcriptions in the Amazon Transcribe Developer Guide.

PresenterOnlyConfiguration

Defines the configuration for a presenter-only video tile.

RealTimeAlertConfiguration

A structure that contains the configuration settings for real-time alerts.

RealTimeAlertRule

Specifies the words or phrases that trigger an alert.

RecordingStreamConfiguration

A structure that holds the settings for recording media.

S3BucketSinkConfiguration

The configuration settings for the S3 bucket.

S3RecordingSinkConfiguration

The structure that holds the settings for transmitting media to the Amazon S3 bucket. These values are used as defaults if S3RecordingSinkRuntimeConfiguration is not specified.

S3RecordingSinkRuntimeConfiguration

A structure that holds the settings for transmitting media files to the Amazon S3 bucket. If specified, the settings in this structure override any settings in S3RecordingSinkConfiguration.

SelectedVideoStreams

The video streams for a specified media pipeline. The total number of video streams can't exceed 25.

SentimentConfiguration

A structure that contains the configuration settings for a sentiment analysis task.

SnsTopicSinkConfiguration

The configuration settings for the SNS topic sink.

SourceConfiguration

Source configuration for a specified media pipeline.

SpeakerSearchTask

A representation of an asynchronous request to perform speaker search analysis on a media insights pipeline.

SqsQueueSinkConfiguration

The configuration settings for the SQS sink.

SseAwsKeyManagementParams

Contains server side encryption parameters to be used by media capture pipeline. The parameters can also be used by media concatenation pipeline taking media capture pipeline as a media source.

StreamChannelDefinition

Defines a streaming channel.

StreamConfiguration

The configuration settings for a stream.

Tag

A key/value pair that grants users access to meeting resources.

TimestampRange

The range of timestamps to return.

TranscriptionMessagesConcatenationConfiguration

The configuration object for concatenating transcription messages.

VerticalLayoutConfiguration

Defines the configuration settings for a vertical layout.

VideoArtifactsConfiguration

The video artifact configuration object.

VideoAttribute

Defines the settings for a video tile.

VideoConcatenationConfiguration

The configuration object of a video concatenation pipeline.

VoiceAnalyticsProcessorConfiguration

The configuration settings for a voice analytics processor.

VoiceEnhancementSinkConfiguration

A static structure that contains the configuration data for a VoiceEnhancementSinkConfiguration element.

VoiceToneAnalysisTask

A representation of an asynchronous request to perform voice tone analysis on a media insights pipeline.

Enums

ActiveSpeakerPosition

When writing a match expression against ActiveSpeakerPosition, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ArtifactsConcatenationState

When writing a match expression against ArtifactsConcatenationState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ArtifactsState

When writing a match expression against ArtifactsState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AudioArtifactsConcatenationState

When writing a match expression against AudioArtifactsConcatenationState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AudioChannelsOption

When writing a match expression against AudioChannelsOption, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AudioMuxType

When writing a match expression against AudioMuxType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

BorderColor

When writing a match expression against BorderColor, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

CallAnalyticsLanguageCode

When writing a match expression against CallAnalyticsLanguageCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

CanvasOrientation

When writing a match expression against CanvasOrientation, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ConcatenationSinkType

When writing a match expression against ConcatenationSinkType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ConcatenationSourceType

When writing a match expression against ConcatenationSourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ContentMuxType

When writing a match expression against ContentMuxType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ContentRedactionOutput

When writing a match expression against ContentRedactionOutput, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ContentShareLayoutOption

When writing a match expression against ContentShareLayoutOption, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ContentType

When writing a match expression against ContentType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ErrorCode

When writing a match expression against ErrorCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

FragmentSelectorType

When writing a match expression against FragmentSelectorType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

HighlightColor

When writing a match expression against HighlightColor, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

HorizontalTilePosition

When writing a match expression against HorizontalTilePosition, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KinesisVideoStreamPoolStatus

When writing a match expression against KinesisVideoStreamPoolStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LayoutOption

When writing a match expression against LayoutOption, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LiveConnectorMuxType

When writing a match expression against LiveConnectorMuxType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LiveConnectorSinkType

When writing a match expression against LiveConnectorSinkType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LiveConnectorSourceType

When writing a match expression against LiveConnectorSourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MediaEncoding

When writing a match expression against MediaEncoding, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MediaInsightsPipelineConfigurationElementType

When writing a match expression against MediaInsightsPipelineConfigurationElementType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MediaPipelineElementStatus

When writing a match expression against MediaPipelineElementStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MediaPipelineSinkType

When writing a match expression against MediaPipelineSinkType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MediaPipelineSourceType

When writing a match expression against MediaPipelineSourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MediaPipelineStatus

When writing a match expression against MediaPipelineStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MediaPipelineStatusUpdate

When writing a match expression against MediaPipelineStatusUpdate, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MediaPipelineTaskStatus

When writing a match expression against MediaPipelineTaskStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MediaStreamPipelineSinkType

When writing a match expression against MediaStreamPipelineSinkType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MediaStreamType

When writing a match expression against MediaStreamType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PartialResultsStability

When writing a match expression against PartialResultsStability, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ParticipantRole

When writing a match expression against ParticipantRole, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PresenterPosition

When writing a match expression against PresenterPosition, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RealTimeAlertRuleType

When writing a match expression against RealTimeAlertRuleType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RecordingFileFormat

When writing a match expression against RecordingFileFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ResolutionOption

When writing a match expression against ResolutionOption, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SentimentType

When writing a match expression against SentimentType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TileOrder

When writing a match expression against TileOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

VerticalTilePosition

When writing a match expression against VerticalTilePosition, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

VideoMuxType

When writing a match expression against VideoMuxType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

VocabularyFilterMethod

When writing a match expression against VocabularyFilterMethod, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

VoiceAnalyticsConfigurationStatus

When writing a match expression against VoiceAnalyticsConfigurationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

VoiceAnalyticsLanguageCode

When writing a match expression against VoiceAnalyticsLanguageCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.