Module types 

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that Amazon Interactive Video Service RealTime can respond with.

Structs

AutoParticipantRecordingConfiguration

Object specifying a configuration for individual participant recording.

ChannelDestinationConfiguration

Object specifying a channel as a destination.

Composition

Object specifying a Composition resource.

CompositionRecordingHlsConfiguration

An object representing a configuration of HLS recordings for server-side composition.

CompositionSummary

Summary information about a Composition.

CompositionThumbnailConfiguration

An object representing a configuration of thumbnails for recorded video for a Composition.

Destination

Object specifying the status of a Destination.

DestinationConfiguration

Complex data type that defines destination-configuration objects.

DestinationDetail

Complex data type that defines destination-detail objects.

DestinationSummary

Summary information about a Destination.

EncoderConfiguration

Settings for transcoding.

EncoderConfigurationSummary

Summary information about an EncoderConfiguration.

Event

An occurrence during a stage session.

GridConfiguration

Configuration information specific to Grid layout, for server-side composition. See "Layouts" in Server-Side Composition.

IngestConfiguration

Object specifying an ingest configuration.

IngestConfigurationSummary

Summary information about an IngestConfiguration.

LayoutConfiguration

Configuration information of supported layouts for server-side composition.

Participant

Object describing a participant that has joined a stage.

ParticipantRecordingHlsConfiguration

An object representing a configuration of participant HLS recordings for individual participant recording.

ParticipantReplica

Information about the replicated destination stage for a participant.

ParticipantSummary

Summary object describing a participant that has joined a stage.

ParticipantThumbnailConfiguration

An object representing a configuration of thumbnails for recorded video from an individual participant.

ParticipantToken

Object specifying a participant token in a stage.

Important: Treat tokens as opaque; i.e., do not build functionality based on token contents. The format of tokens could change in the future.

ParticipantTokenConfiguration

Object specifying a participant token configuration in a stage.

PipConfiguration

Configuration information specific to Picture-in-Picture (PiP) layout, for server-side composition.

PublicKey

Object specifying a public key used to sign stage participant tokens.

PublicKeySummary

Summary information about a public key.

RecordingConfiguration

An object representing a configuration to record a stage stream.

S3DestinationConfiguration

A complex type that describes an S3 location where recorded videos will be stored.

S3Detail

Complex data type that defines S3Detail objects.

S3StorageConfiguration

A complex type that describes an S3 location where recorded videos will be stored.

Stage

Object specifying a stage.

StageEndpoints

Summary information about various endpoints for a stage. We recommend that you cache these values at stage creation; the values can be cached for up to 14 days.

StageSession

A stage session begins when the first participant joins a stage and ends after the last participant leaves the stage. A stage session helps with debugging stages by grouping events and participants into shorter periods of time (i.e., a session), which is helpful when stages are used over long periods of time.

StageSessionSummary

Summary information about a stage session.

StageSummary

Summary information about a stage.

StorageConfiguration

A complex type that describes a location where recorded videos will be stored.

StorageConfigurationSummary

Summary information about a storage configuration.

Video

Settings for video.

Enums

CompositionState

When writing a match expression against CompositionState, 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.

DestinationState

When writing a match expression against DestinationState, 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.

EventErrorCode

When writing a match expression against EventErrorCode, 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.

EventName

When writing a match expression against EventName, 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.

IngestConfigurationState

When writing a match expression against IngestConfigurationState, 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.

IngestProtocol

When writing a match expression against IngestProtocol, 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.

ParticipantProtocol

When writing a match expression against ParticipantProtocol, 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.

ParticipantRecordingFilterByRecordingState

When writing a match expression against ParticipantRecordingFilterByRecordingState, 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.

ParticipantRecordingMediaType

When writing a match expression against ParticipantRecordingMediaType, 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.

ParticipantRecordingState

When writing a match expression against ParticipantRecordingState, 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.

ParticipantState

When writing a match expression against ParticipantState, 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.

ParticipantTokenCapability

When writing a match expression against ParticipantTokenCapability, 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.

PipBehavior

When writing a match expression against PipBehavior, 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.

PipPosition

When writing a match expression against PipPosition, 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.

RecordingConfigurationFormat

When writing a match expression against RecordingConfigurationFormat, 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.

ReplicationState

When writing a match expression against ReplicationState, 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.

ReplicationType

When writing a match expression against ReplicationType, 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.

ThumbnailRecordingMode

When writing a match expression against ThumbnailRecordingMode, 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.

ThumbnailStorageType

When writing a match expression against ThumbnailStorageType, 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.

VideoAspectRatio

When writing a match expression against VideoAspectRatio, 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.

VideoFillMode

When writing a match expression against VideoFillMode, 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.