aws-cdk.aws-ivs-alpha 2.166.0a0__tar.gz → 2.167.1a0__tar.gz

{aws_cdk_aws_ivs_alpha-2.166.0a0/src/aws_cdk.aws_ivs_alpha.egg-info → aws_cdk_aws_ivs_alpha-2.167.1a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aws-cdk.aws-ivs-alpha
-Version: 2.166.0a0
+Version: 2.167.1a0
 Summary: The CDK Construct Library for AWS::IVS
 Home-page: https://github.com/aws/aws-cdk
 Author: Amazon Web Services
@@ -23,7 +23,7 @@ Requires-Python: ~=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: NOTICE
-Requires-Dist: aws-cdk-lib<3.0.0,>=2.166.0
+Requires-Dist: aws-cdk-lib<3.0.0,>=2.167.1
 Requires-Dist: constructs<11.0.0,>=10.0.0
 Requires-Dist: jsii<2.0.0,>=1.104.0
 Requires-Dist: publication>=0.0.3
@@ -145,3 +145,94 @@ my_channel = ivs.Channel(self, "Channel",
     authorized=True
 )
 ```
+
+## Recording Configurations
+
+An Amazon IVS Recording Configuration stores settings that specify how a channel's live streams should be recorded.
+You can configure video quality, thumbnail generation, and where recordings are stored in Amazon S3.
+
+For more information about IVS recording, see [IVS Auto-Record to Amazon S3 | Low-Latency Streaming](https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/record-to-s3.html).
+
+You can create a recording configuration:
+
+```python
+# create an S3 bucket for storing recordings
+recording_bucket = s3.Bucket(self, "RecordingBucket")
+
+# create a basic recording configuration
+recording_configuration = ivs.RecordingConfiguration(self, "RecordingConfiguration",
+    bucket=recording_bucket
+)
+```
+
+### Renditions of a Recording
+
+When you stream content to an Amazon IVS channel, auto-record-to-s3 uses the source video to generate multiple renditions.
+
+For more information, see [Discovering the Renditions of a Recording](https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/record-to-s3.html#r2s3-recording-renditions).
+
+```python
+# recording_bucket: s3.Bucket
+
+
+recording_configuration = ivs.RecordingConfiguration(self, "RecordingConfiguration",
+    bucket=recording_bucket,
+
+    # set rendition configuration
+    rendition_configuration=ivs.RenditionConfiguration.custom([ivs.Resolution.HD, ivs.Resolution.SD])
+)
+```
+
+### Thumbnail Generation
+
+You can enable or disable the recording of thumbnails for a live session and modify the interval at which thumbnails are generated for the live session.
+
+Thumbnail intervals may range from 1 second to 60 seconds; by default, thumbnail recording is enabled, at an interval of 60 seconds.
+
+For more information, see [Thumbnails](https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/record-to-s3.html#r2s3-thumbnails).
+
+```python
+# recording_bucket: s3.Bucket
+
+
+recording_configuration = ivs.RecordingConfiguration(self, "RecordingConfiguration",
+    bucket=recording_bucket,
+
+    # set thumbnail settings
+    thumbnail_configuration=ivs.ThumbnailConfiguration.interval(ivs.Resolution.HD, [ivs.Storage.LATEST, ivs.Storage.SEQUENTIAL], Duration.seconds(30))
+)
+```
+
+### Merge Fragmented Streams
+
+The `recordingReconnectWindow` property allows you to specify a window of time (in seconds) during which, if your stream is interrupted and a new stream is started, Amazon IVS tries to record to the same S3 prefix as the previous stream.
+
+In other words, if a broadcast disconnects and then reconnects within the specified interval, the multiple streams are considered a single broadcast and merged together.
+
+For more information, see [Merge Fragmented Streams](https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/record-to-s3.html#r2s3-merge-fragmented-streams).
+
+```python
+# recording_bucket: s3.Bucket
+
+
+recording_configuration = ivs.RecordingConfiguration(self, "RecordingConfiguration",
+    bucket=recording_bucket,
+
+    # set recording reconnect window
+    recording_reconnect_window=Duration.seconds(60)
+)
+```
+
+### Attaching Recording Configuration to a Channel
+
+To enable recording for a channel, specify the recording configuration when creating the channel:
+
+```python
+# recording_configuration: ivs.RecordingConfiguration
+
+
+channel = ivs.Channel(self, "Channel",
+    # set recording configuration
+    recording_configuration=recording_configuration
+)
+```

{aws_cdk_aws_ivs_alpha-2.166.0a0 → aws_cdk_aws_ivs_alpha-2.167.1a0}/README.md

@@ -114,3 +114,94 @@ my_channel = ivs.Channel(self, "Channel",
     authorized=True
 )
 ```
+
+## Recording Configurations
+
+An Amazon IVS Recording Configuration stores settings that specify how a channel's live streams should be recorded.
+You can configure video quality, thumbnail generation, and where recordings are stored in Amazon S3.
+
+For more information about IVS recording, see [IVS Auto-Record to Amazon S3 | Low-Latency Streaming](https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/record-to-s3.html).
+
+You can create a recording configuration:
+
+```python
+# create an S3 bucket for storing recordings
+recording_bucket = s3.Bucket(self, "RecordingBucket")
+
+# create a basic recording configuration
+recording_configuration = ivs.RecordingConfiguration(self, "RecordingConfiguration",
+    bucket=recording_bucket
+)
+```
+
+### Renditions of a Recording
+
+When you stream content to an Amazon IVS channel, auto-record-to-s3 uses the source video to generate multiple renditions.
+
+For more information, see [Discovering the Renditions of a Recording](https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/record-to-s3.html#r2s3-recording-renditions).
+
+```python
+# recording_bucket: s3.Bucket
+
+
+recording_configuration = ivs.RecordingConfiguration(self, "RecordingConfiguration",
+    bucket=recording_bucket,
+
+    # set rendition configuration
+    rendition_configuration=ivs.RenditionConfiguration.custom([ivs.Resolution.HD, ivs.Resolution.SD])
+)
+```
+
+### Thumbnail Generation
+
+You can enable or disable the recording of thumbnails for a live session and modify the interval at which thumbnails are generated for the live session.
+
+Thumbnail intervals may range from 1 second to 60 seconds; by default, thumbnail recording is enabled, at an interval of 60 seconds.
+
+For more information, see [Thumbnails](https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/record-to-s3.html#r2s3-thumbnails).
+
+```python
+# recording_bucket: s3.Bucket
+
+
+recording_configuration = ivs.RecordingConfiguration(self, "RecordingConfiguration",
+    bucket=recording_bucket,
+
+    # set thumbnail settings
+    thumbnail_configuration=ivs.ThumbnailConfiguration.interval(ivs.Resolution.HD, [ivs.Storage.LATEST, ivs.Storage.SEQUENTIAL], Duration.seconds(30))
+)
+```
+
+### Merge Fragmented Streams
+
+The `recordingReconnectWindow` property allows you to specify a window of time (in seconds) during which, if your stream is interrupted and a new stream is started, Amazon IVS tries to record to the same S3 prefix as the previous stream.
+
+In other words, if a broadcast disconnects and then reconnects within the specified interval, the multiple streams are considered a single broadcast and merged together.
+
+For more information, see [Merge Fragmented Streams](https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/record-to-s3.html#r2s3-merge-fragmented-streams).
+
+```python
+# recording_bucket: s3.Bucket
+
+
+recording_configuration = ivs.RecordingConfiguration(self, "RecordingConfiguration",
+    bucket=recording_bucket,
+
+    # set recording reconnect window
+    recording_reconnect_window=Duration.seconds(60)
+)
+```
+
+### Attaching Recording Configuration to a Channel
+
+To enable recording for a channel, specify the recording configuration when creating the channel:
+
+```python
+# recording_configuration: ivs.RecordingConfiguration
+
+
+channel = ivs.Channel(self, "Channel",
+    # set recording configuration
+    recording_configuration=recording_configuration
+)
+```

{aws_cdk_aws_ivs_alpha-2.166.0a0 → aws_cdk_aws_ivs_alpha-2.167.1a0}/setup.py

@@ -5,7 +5,7 @@ kwargs = json.loads(
     """
 {
     "name": "aws-cdk.aws-ivs-alpha",
-    "version": "2.166.0.a0",
+    "version": "2.167.1.a0",
     "description": "The CDK Construct Library for AWS::IVS",
     "license": "Apache-2.0",
     "url": "https://github.com/aws/aws-cdk",
@@ -26,7 +26,7 @@ kwargs = json.loads(
     ],
     "package_data": {
         "aws_cdk.aws_ivs_alpha._jsii": [
-            "aws-ivs-alpha@2.166.0-alpha.0.jsii.tgz"
+            "aws-ivs-alpha@2.167.1-alpha.0.jsii.tgz"
         ],
         "aws_cdk.aws_ivs_alpha": [
             "py.typed"
@@ -34,7 +34,7 @@ kwargs = json.loads(
     },
     "python_requires": "~=3.8",
     "install_requires": [
-        "aws-cdk-lib>=2.166.0, <3.0.0",
+        "aws-cdk-lib>=2.167.1, <3.0.0",
         "constructs>=10.0.0, <11.0.0",
         "jsii>=1.104.0, <2.0.0",
         "publication>=0.0.3",

{aws_cdk_aws_ivs_alpha-2.166.0a0 → aws_cdk_aws_ivs_alpha-2.167.1a0}/src/aws_cdk/aws_ivs_alpha/__init__.py

@@ -115,6 +115,97 @@ my_channel = ivs.Channel(self, "Channel",
     authorized=True
 )
 ```
+
+## Recording Configurations
+
+An Amazon IVS Recording Configuration stores settings that specify how a channel's live streams should be recorded.
+You can configure video quality, thumbnail generation, and where recordings are stored in Amazon S3.
+
+For more information about IVS recording, see [IVS Auto-Record to Amazon S3 | Low-Latency Streaming](https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/record-to-s3.html).
+
+You can create a recording configuration:
+
+```python
+# create an S3 bucket for storing recordings
+recording_bucket = s3.Bucket(self, "RecordingBucket")
+
+# create a basic recording configuration
+recording_configuration = ivs.RecordingConfiguration(self, "RecordingConfiguration",
+    bucket=recording_bucket
+)
+```
+
+### Renditions of a Recording
+
+When you stream content to an Amazon IVS channel, auto-record-to-s3 uses the source video to generate multiple renditions.
+
+For more information, see [Discovering the Renditions of a Recording](https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/record-to-s3.html#r2s3-recording-renditions).
+
+```python
+# recording_bucket: s3.Bucket
+
+
+recording_configuration = ivs.RecordingConfiguration(self, "RecordingConfiguration",
+    bucket=recording_bucket,
+
+    # set rendition configuration
+    rendition_configuration=ivs.RenditionConfiguration.custom([ivs.Resolution.HD, ivs.Resolution.SD])
+)
+```
+
+### Thumbnail Generation
+
+You can enable or disable the recording of thumbnails for a live session and modify the interval at which thumbnails are generated for the live session.
+
+Thumbnail intervals may range from 1 second to 60 seconds; by default, thumbnail recording is enabled, at an interval of 60 seconds.
+
+For more information, see [Thumbnails](https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/record-to-s3.html#r2s3-thumbnails).
+
+```python
+# recording_bucket: s3.Bucket
+
+
+recording_configuration = ivs.RecordingConfiguration(self, "RecordingConfiguration",
+    bucket=recording_bucket,
+
+    # set thumbnail settings
+    thumbnail_configuration=ivs.ThumbnailConfiguration.interval(ivs.Resolution.HD, [ivs.Storage.LATEST, ivs.Storage.SEQUENTIAL], Duration.seconds(30))
+)
+```
+
+### Merge Fragmented Streams
+
+The `recordingReconnectWindow` property allows you to specify a window of time (in seconds) during which, if your stream is interrupted and a new stream is started, Amazon IVS tries to record to the same S3 prefix as the previous stream.
+
+In other words, if a broadcast disconnects and then reconnects within the specified interval, the multiple streams are considered a single broadcast and merged together.
+
+For more information, see [Merge Fragmented Streams](https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/record-to-s3.html#r2s3-merge-fragmented-streams).
+
+```python
+# recording_bucket: s3.Bucket
+
+
+recording_configuration = ivs.RecordingConfiguration(self, "RecordingConfiguration",
+    bucket=recording_bucket,
+
+    # set recording reconnect window
+    recording_reconnect_window=Duration.seconds(60)
+)
+```
+
+### Attaching Recording Configuration to a Channel
+
+To enable recording for a channel, specify the recording configuration when creating the channel:
+
+```python
+# recording_configuration: ivs.RecordingConfiguration
+
+
+channel = ivs.Channel(self, "Channel",
+    # set recording configuration
+    recording_configuration=recording_configuration
+)
+```
 '''
 from pkgutil import extend_path
 __path__ = extend_path(__path__, __name__)
@@ -149,6 +240,7 @@ def check_type(argname: str, value: object, expected_type: typing.Any) -> typing
 from ._jsii import *
 
 import aws_cdk as _aws_cdk_ceddda9d
+import aws_cdk.aws_s3 as _aws_cdk_aws_s3_ceddda9d
 import constructs as _constructs_77d1e7e8
 
 
@@ -161,6 +253,7 @@ import constructs as _constructs_77d1e7e8
         "insecure_ingest": "insecureIngest",
         "latency_mode": "latencyMode",
         "preset": "preset",
+        "recording_configuration": "recordingConfiguration",
         "type": "type",
     },
 )
@@ -173,6 +266,7 @@ class ChannelProps:
         insecure_ingest: typing.Optional[builtins.bool] = None,
         latency_mode: typing.Optional["LatencyMode"] = None,
         preset: typing.Optional["Preset"] = None,
+        recording_configuration: typing.Optional["IRecordingConfiguration"] = None,
         type: typing.Optional["ChannelType"] = None,
     ) -> None:
         '''(experimental) Properties for creating a new Channel.
@@ -182,6 +276,7 @@ class ChannelProps:
         :param insecure_ingest: (experimental) Whether the channel allows insecure RTMP ingest. Default: false
         :param latency_mode: (experimental) Channel latency mode. Default: LatencyMode.LOW
         :param preset: (experimental) An optional transcode preset for the channel. Can be used for ADVANCED_HD and ADVANCED_SD channel types. When LOW or STANDARD is used, the preset will be overridden and set to none regardless of the value provided. Default: - Preset.HIGHER_BANDWIDTH_DELIVERY if channelType is ADVANCED_SD or ADVANCED_HD, none otherwise
+        :param recording_configuration: (experimental) A recording configuration for the channel. Default: - recording is disabled
         :param type: (experimental) The channel type, which determines the allowable resolution and bitrate. If you exceed the allowable resolution or bitrate, the stream will disconnect immediately Default: ChannelType.STANDARD
 
         :stability: experimental
@@ -201,6 +296,7 @@ class ChannelProps:
             check_type(argname="argument insecure_ingest", value=insecure_ingest, expected_type=type_hints["insecure_ingest"])
             check_type(argname="argument latency_mode", value=latency_mode, expected_type=type_hints["latency_mode"])
             check_type(argname="argument preset", value=preset, expected_type=type_hints["preset"])
+            check_type(argname="argument recording_configuration", value=recording_configuration, expected_type=type_hints["recording_configuration"])
             check_type(argname="argument type", value=type, expected_type=type_hints["type"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
         if authorized is not None:
@@ -213,6 +309,8 @@ class ChannelProps:
             self._values["latency_mode"] = latency_mode
         if preset is not None:
             self._values["preset"] = preset
+        if recording_configuration is not None:
+            self._values["recording_configuration"] = recording_configuration
         if type is not None:
             self._values["type"] = type
 
@@ -278,6 +376,17 @@ class ChannelProps:
         result = self._values.get("preset")
         return typing.cast(typing.Optional["Preset"], result)
 
+    @builtins.property
+    def recording_configuration(self) -> typing.Optional["IRecordingConfiguration"]:
+        '''(experimental) A recording configuration for the channel.
+
+        :default: - recording is disabled
+
+        :stability: experimental
+        '''
+        result = self._values.get("recording_configuration")
+        return typing.cast(typing.Optional["IRecordingConfiguration"], result)
+
     @builtins.property
     def type(self) -> typing.Optional["ChannelType"]:
         '''(experimental) The channel type, which determines the allowable resolution and bitrate.
@@ -469,6 +578,68 @@ class _IPlaybackKeyPairProxy(
 typing.cast(typing.Any, IPlaybackKeyPair).__jsii_proxy_class__ = lambda : _IPlaybackKeyPairProxy
 
 
+@jsii.interface(jsii_type="@aws-cdk/aws-ivs-alpha.IRecordingConfiguration")
+class IRecordingConfiguration(_aws_cdk_ceddda9d.IResource, typing_extensions.Protocol):
+    '''(experimental) Represents the IVS Recording configuration.
+
+    :stability: experimental
+    '''
+
+    @builtins.property
+    @jsii.member(jsii_name="recordingConfigurationArn")
+    def recording_configuration_arn(self) -> builtins.str:
+        '''(experimental) The ARN of the Recording configuration.
+
+        :stability: experimental
+        :attribute: true
+        '''
+        ...
+
+    @builtins.property
+    @jsii.member(jsii_name="recordingConfigurationId")
+    def recording_configuration_id(self) -> builtins.str:
+        '''(experimental) The ID of the Recording configuration.
+
+        :stability: experimental
+        :attribute: true
+        '''
+        ...
+
+
+class _IRecordingConfigurationProxy(
+    jsii.proxy_for(_aws_cdk_ceddda9d.IResource), # type: ignore[misc]
+):
+    '''(experimental) Represents the IVS Recording configuration.
+
+    :stability: experimental
+    '''
+
+    __jsii_type__: typing.ClassVar[str] = "@aws-cdk/aws-ivs-alpha.IRecordingConfiguration"
+
+    @builtins.property
+    @jsii.member(jsii_name="recordingConfigurationArn")
+    def recording_configuration_arn(self) -> builtins.str:
+        '''(experimental) The ARN of the Recording configuration.
+
+        :stability: experimental
+        :attribute: true
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "recordingConfigurationArn"))
+
+    @builtins.property
+    @jsii.member(jsii_name="recordingConfigurationId")
+    def recording_configuration_id(self) -> builtins.str:
+        '''(experimental) The ID of the Recording configuration.
+
+        :stability: experimental
+        :attribute: true
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "recordingConfigurationId"))
+
+# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
+typing.cast(typing.Any, IRecordingConfiguration).__jsii_proxy_class__ = lambda : _IRecordingConfigurationProxy
+
+
 @jsii.interface(jsii_type="@aws-cdk/aws-ivs-alpha.IStreamKey")
 class IStreamKey(_aws_cdk_ceddda9d.IResource, typing_extensions.Protocol):
     '''(experimental) Represents an IVS Stream Key.
@@ -711,6 +882,466 @@ class Preset(enum.Enum):
     '''
 
 
+@jsii.implements(IRecordingConfiguration)
+class RecordingConfiguration(
+    _aws_cdk_ceddda9d.Resource,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="@aws-cdk/aws-ivs-alpha.RecordingConfiguration",
+):
+    '''(experimental) The IVS Recording configuration.
+
+    :stability: experimental
+    :resource: AWS::IVS::RecordingConfiguration
+    :exampleMetadata: infused
+
+    Example::
+
+        # recording_bucket: s3.Bucket
+        
+        
+        recording_configuration = ivs.RecordingConfiguration(self, "RecordingConfiguration",
+            bucket=recording_bucket,
+        
+            # set rendition configuration
+            rendition_configuration=ivs.RenditionConfiguration.custom([ivs.Resolution.HD, ivs.Resolution.SD])
+        )
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        bucket: _aws_cdk_aws_s3_ceddda9d.IBucket,
+        recording_configuration_name: typing.Optional[builtins.str] = None,
+        recording_reconnect_window: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
+        rendition_configuration: typing.Optional["RenditionConfiguration"] = None,
+        thumbnail_configuration: typing.Optional["ThumbnailConfiguration"] = None,
+    ) -> None:
+        '''
+        :param scope: -
+        :param id: -
+        :param bucket: (experimental) S3 bucket where recorded videos will be stored.
+        :param recording_configuration_name: (experimental) The name of the Recording configuration. The value does not need to be unique. Default: - auto generate
+        :param recording_reconnect_window: (experimental) If a broadcast disconnects and then reconnects within the specified interval, the multiple streams will be considered a single broadcast and merged together. ``recordingReconnectWindow`` must be between 0 and 300 seconds Default: - 0 seconds (means disabled)
+        :param rendition_configuration: (experimental) A rendition configuration describes which renditions should be recorded for a stream. Default: - no rendition configuration
+        :param thumbnail_configuration: (experimental) A thumbnail configuration enables/disables the recording of thumbnails for a live session and controls the interval at which thumbnails are generated for the live session. Default: - no thumbnail configuration
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__84f7bfe030fdaeee83dd169a4320aa71fb0e576e76fac8a6fb5e799d638df503)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        props = RecordingConfigurationProps(
+            bucket=bucket,
+            recording_configuration_name=recording_configuration_name,
+            recording_reconnect_window=recording_reconnect_window,
+            rendition_configuration=rendition_configuration,
+            thumbnail_configuration=thumbnail_configuration,
+        )
+
+        jsii.create(self.__class__, self, [scope, id, props])
+
+    @jsii.member(jsii_name="fromArn")
+    @builtins.classmethod
+    def from_arn(
+        cls,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        recording_configuration_arn: builtins.str,
+    ) -> IRecordingConfiguration:
+        '''(experimental) Imports an IVS Recording Configuration from its ARN.
+
+        :param scope: -
+        :param id: -
+        :param recording_configuration_arn: -
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__5f6cbd063c6e695eed56d0c9c16dea95fe5f4b2a11e461c72cb33aa8d324e82d)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+            check_type(argname="argument recording_configuration_arn", value=recording_configuration_arn, expected_type=type_hints["recording_configuration_arn"])
+        return typing.cast(IRecordingConfiguration, jsii.sinvoke(cls, "fromArn", [scope, id, recording_configuration_arn]))
+
+    @jsii.member(jsii_name="fromRecordingConfigurationId")
+    @builtins.classmethod
+    def from_recording_configuration_id(
+        cls,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        recording_configuration_id: builtins.str,
+    ) -> IRecordingConfiguration:
+        '''(experimental) Imports an IVS Recording Configuration from attributes.
+
+        :param scope: -
+        :param id: -
+        :param recording_configuration_id: -
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__9c05eebd5485c91c16b38e6bf9c1d896abb2eee019bb8f0da1ec7fa25b69b0d8)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+            check_type(argname="argument recording_configuration_id", value=recording_configuration_id, expected_type=type_hints["recording_configuration_id"])
+        return typing.cast(IRecordingConfiguration, jsii.sinvoke(cls, "fromRecordingConfigurationId", [scope, id, recording_configuration_id]))
+
+    @builtins.property
+    @jsii.member(jsii_name="recordingConfigurationArn")
+    def recording_configuration_arn(self) -> builtins.str:
+        '''(experimental) The ARN of the Recording configuration.
+
+        :stability: experimental
+        :attribute: true
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "recordingConfigurationArn"))
+
+    @builtins.property
+    @jsii.member(jsii_name="recordingConfigurationId")
+    def recording_configuration_id(self) -> builtins.str:
+        '''(experimental) The ID of the Recording configuration.
+
+        :stability: experimental
+        :attribute: true
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "recordingConfigurationId"))
+
+
+@jsii.data_type(
+    jsii_type="@aws-cdk/aws-ivs-alpha.RecordingConfigurationProps",
+    jsii_struct_bases=[],
+    name_mapping={
+        "bucket": "bucket",
+        "recording_configuration_name": "recordingConfigurationName",
+        "recording_reconnect_window": "recordingReconnectWindow",
+        "rendition_configuration": "renditionConfiguration",
+        "thumbnail_configuration": "thumbnailConfiguration",
+    },
+)
+class RecordingConfigurationProps:
+    def __init__(
+        self,
+        *,
+        bucket: _aws_cdk_aws_s3_ceddda9d.IBucket,
+        recording_configuration_name: typing.Optional[builtins.str] = None,
+        recording_reconnect_window: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
+        rendition_configuration: typing.Optional["RenditionConfiguration"] = None,
+        thumbnail_configuration: typing.Optional["ThumbnailConfiguration"] = None,
+    ) -> None:
+        '''(experimental) Properties of the IVS Recording configuration.
+
+        :param bucket: (experimental) S3 bucket where recorded videos will be stored.
+        :param recording_configuration_name: (experimental) The name of the Recording configuration. The value does not need to be unique. Default: - auto generate
+        :param recording_reconnect_window: (experimental) If a broadcast disconnects and then reconnects within the specified interval, the multiple streams will be considered a single broadcast and merged together. ``recordingReconnectWindow`` must be between 0 and 300 seconds Default: - 0 seconds (means disabled)
+        :param rendition_configuration: (experimental) A rendition configuration describes which renditions should be recorded for a stream. Default: - no rendition configuration
+        :param thumbnail_configuration: (experimental) A thumbnail configuration enables/disables the recording of thumbnails for a live session and controls the interval at which thumbnails are generated for the live session. Default: - no thumbnail configuration
+
+        :stability: experimental
+        :exampleMetadata: infused
+
+        Example::
+
+            # recording_bucket: s3.Bucket
+            
+            
+            recording_configuration = ivs.RecordingConfiguration(self, "RecordingConfiguration",
+                bucket=recording_bucket,
+            
+                # set rendition configuration
+                rendition_configuration=ivs.RenditionConfiguration.custom([ivs.Resolution.HD, ivs.Resolution.SD])
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__21d80b5a61c717610ae7eec3eb729c41345980329354b0189415aab6624a4259)
+            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
+            check_type(argname="argument recording_configuration_name", value=recording_configuration_name, expected_type=type_hints["recording_configuration_name"])
+            check_type(argname="argument recording_reconnect_window", value=recording_reconnect_window, expected_type=type_hints["recording_reconnect_window"])
+            check_type(argname="argument rendition_configuration", value=rendition_configuration, expected_type=type_hints["rendition_configuration"])
+            check_type(argname="argument thumbnail_configuration", value=thumbnail_configuration, expected_type=type_hints["thumbnail_configuration"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "bucket": bucket,
+        }
+        if recording_configuration_name is not None:
+            self._values["recording_configuration_name"] = recording_configuration_name
+        if recording_reconnect_window is not None:
+            self._values["recording_reconnect_window"] = recording_reconnect_window
+        if rendition_configuration is not None:
+            self._values["rendition_configuration"] = rendition_configuration
+        if thumbnail_configuration is not None:
+            self._values["thumbnail_configuration"] = thumbnail_configuration
+
+    @builtins.property
+    def bucket(self) -> _aws_cdk_aws_s3_ceddda9d.IBucket:
+        '''(experimental) S3 bucket where recorded videos will be stored.
+
+        :stability: experimental
+        '''
+        result = self._values.get("bucket")
+        assert result is not None, "Required property 'bucket' is missing"
+        return typing.cast(_aws_cdk_aws_s3_ceddda9d.IBucket, result)
+
+    @builtins.property
+    def recording_configuration_name(self) -> typing.Optional[builtins.str]:
+        '''(experimental) The name of the Recording configuration.
+
+        The value does not need to be unique.
+
+        :default: - auto generate
+
+        :stability: experimental
+        '''
+        result = self._values.get("recording_configuration_name")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def recording_reconnect_window(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
+        '''(experimental) If a broadcast disconnects and then reconnects within the specified interval, the multiple streams will be considered a single broadcast and merged together.
+
+        ``recordingReconnectWindow`` must be between 0 and 300 seconds
+
+        :default: - 0 seconds (means disabled)
+
+        :stability: experimental
+        '''
+        result = self._values.get("recording_reconnect_window")
+        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)
+
+    @builtins.property
+    def rendition_configuration(self) -> typing.Optional["RenditionConfiguration"]:
+        '''(experimental) A rendition configuration describes which renditions should be recorded for a stream.
+
+        :default: - no rendition configuration
+
+        :see: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ivs-recordingconfiguration-renditionconfiguration.html
+        :stability: experimental
+        '''
+        result = self._values.get("rendition_configuration")
+        return typing.cast(typing.Optional["RenditionConfiguration"], result)
+
+    @builtins.property
+    def thumbnail_configuration(self) -> typing.Optional["ThumbnailConfiguration"]:
+        '''(experimental) A thumbnail configuration enables/disables the recording of thumbnails for a live session and controls the interval at which thumbnails are generated for the live session.
+
+        :default: - no thumbnail configuration
+
+        :see: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ivs-recordingconfiguration-thumbnailconfiguration.html
+        :stability: experimental
+        '''
+        result = self._values.get("thumbnail_configuration")
+        return typing.cast(typing.Optional["ThumbnailConfiguration"], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "RecordingConfigurationProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.enum(jsii_type="@aws-cdk/aws-ivs-alpha.RecordingMode")
+class RecordingMode(enum.Enum):
+    '''(experimental) Thumbnail recording mode.
+
+    :stability: experimental
+    '''
+
+    INTERVAL = "INTERVAL"
+    '''(experimental) Use INTERVAL to enable the generation of thumbnails for recorded video at a time interval controlled by the TargetIntervalSeconds property.
+
+    :stability: experimental
+    '''
+    DISABLED = "DISABLED"
+    '''(experimental) Use DISABLED to disable the generation of thumbnails for recorded video.
+
+    :stability: experimental
+    '''
+
+
+class RenditionConfiguration(
+    metaclass=jsii.JSIIMeta,
+    jsii_type="@aws-cdk/aws-ivs-alpha.RenditionConfiguration",
+):
+    '''(experimental) Rendition configuration for IVS Recording configuration.
+
+    :stability: experimental
+    :exampleMetadata: infused
+
+    Example::
+
+        # recording_bucket: s3.Bucket
+        
+        
+        recording_configuration = ivs.RecordingConfiguration(self, "RecordingConfiguration",
+            bucket=recording_bucket,
+        
+            # set rendition configuration
+            rendition_configuration=ivs.RenditionConfiguration.custom([ivs.Resolution.HD, ivs.Resolution.SD])
+        )
+    '''
+
+    @jsii.member(jsii_name="all")
+    @builtins.classmethod
+    def all(cls) -> "RenditionConfiguration":
+        '''(experimental) Record all available renditions.
+
+        :stability: experimental
+        '''
+        return typing.cast("RenditionConfiguration", jsii.sinvoke(cls, "all", []))
+
+    @jsii.member(jsii_name="custom")
+    @builtins.classmethod
+    def custom(
+        cls,
+        renditions: typing.Sequence["Resolution"],
+    ) -> "RenditionConfiguration":
+        '''(experimental) Record a subset of video renditions.
+
+        :param renditions: A list of which renditions are recorded for a stream.
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__72cbe17572adb3a1344760dd6061eca45611a877ad41668210371524b85d90da)
+            check_type(argname="argument renditions", value=renditions, expected_type=type_hints["renditions"])
+        return typing.cast("RenditionConfiguration", jsii.sinvoke(cls, "custom", [renditions]))
+
+    @jsii.member(jsii_name="none")
+    @builtins.classmethod
+    def none(cls) -> "RenditionConfiguration":
+        '''(experimental) Does not record any video.
+
+        :stability: experimental
+        '''
+        return typing.cast("RenditionConfiguration", jsii.sinvoke(cls, "none", []))
+
+    @builtins.property
+    @jsii.member(jsii_name="renditionSelection")
+    def rendition_selection(self) -> "RenditionSelection":
+        '''(experimental) The set of renditions are recorded for a stream.
+
+        :stability: experimental
+        '''
+        return typing.cast("RenditionSelection", jsii.get(self, "renditionSelection"))
+
+    @builtins.property
+    @jsii.member(jsii_name="renditions")
+    def renditions(self) -> typing.Optional[typing.List["Resolution"]]:
+        '''(experimental) A list of which renditions are recorded for a stream.
+
+        If you do not specify this property, no resolution is selected.
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional[typing.List["Resolution"]], jsii.get(self, "renditions"))
+
+
+@jsii.enum(jsii_type="@aws-cdk/aws-ivs-alpha.RenditionSelection")
+class RenditionSelection(enum.Enum):
+    '''(experimental) Rendition selection mode.
+
+    :stability: experimental
+    '''
+
+    ALL = "ALL"
+    '''(experimental) Record all available renditions.
+
+    :stability: experimental
+    '''
+    NONE = "NONE"
+    '''(experimental) Does not record any video.
+
+    This option is useful if you just want to record thumbnails.
+
+    :stability: experimental
+    '''
+    CUSTOM = "CUSTOM"
+    '''(experimental) Select a subset of video renditions to record.
+
+    :stability: experimental
+    '''
+
+
+@jsii.enum(jsii_type="@aws-cdk/aws-ivs-alpha.Resolution")
+class Resolution(enum.Enum):
+    '''(experimental) Resolution for rendition.
+
+    :stability: experimental
+    :exampleMetadata: infused
+
+    Example::
+
+        # recording_bucket: s3.Bucket
+        
+        
+        recording_configuration = ivs.RecordingConfiguration(self, "RecordingConfiguration",
+            bucket=recording_bucket,
+        
+            # set rendition configuration
+            rendition_configuration=ivs.RenditionConfiguration.custom([ivs.Resolution.HD, ivs.Resolution.SD])
+        )
+    '''
+
+    FULL_HD = "FULL_HD"
+    '''(experimental) Full HD (1080p).
+
+    :stability: experimental
+    '''
+    HD = "HD"
+    '''(experimental) HD (720p).
+
+    :stability: experimental
+    '''
+    SD = "SD"
+    '''(experimental) SD (480p).
+
+    :stability: experimental
+    '''
+    LOWEST_RESOLUTION = "LOWEST_RESOLUTION"
+    '''(experimental) Lowest resolution.
+
+    :stability: experimental
+    '''
+
+
+@jsii.enum(jsii_type="@aws-cdk/aws-ivs-alpha.Storage")
+class Storage(enum.Enum):
+    '''(experimental) The format in which thumbnails are recorded for a stream.
+
+    :stability: experimental
+    :exampleMetadata: infused
+
+    Example::
+
+        # recording_bucket: s3.Bucket
+        
+        
+        recording_configuration = ivs.RecordingConfiguration(self, "RecordingConfiguration",
+            bucket=recording_bucket,
+        
+            # set thumbnail settings
+            thumbnail_configuration=ivs.ThumbnailConfiguration.interval(ivs.Resolution.HD, [ivs.Storage.LATEST, ivs.Storage.SEQUENTIAL], Duration.seconds(30))
+        )
+    '''
+
+    SEQUENTIAL = "SEQUENTIAL"
+    '''(experimental) SEQUENTIAL records all generated thumbnails in a serial manner, to the media/thumbnails directory.
+
+    :stability: experimental
+    '''
+    LATEST = "LATEST"
+    '''(experimental) LATEST saves the latest thumbnail in media/thumbnails/latest/thumb.jpg and overwrites it at the interval specified by thumbnailTargetInterval.
+
+    :stability: experimental
+    '''
+
+
 @jsii.implements(IStreamKey)
 class StreamKey(
     _aws_cdk_ceddda9d.Resource,
@@ -828,6 +1459,105 @@ class StreamKeyProps:
         )
 
 
+class ThumbnailConfiguration(
+    metaclass=jsii.JSIIMeta,
+    jsii_type="@aws-cdk/aws-ivs-alpha.ThumbnailConfiguration",
+):
+    '''(experimental) Thumbnail configuration for IVS Recording configuration.
+
+    :stability: experimental
+    :exampleMetadata: infused
+
+    Example::
+
+        # recording_bucket: s3.Bucket
+        
+        
+        recording_configuration = ivs.RecordingConfiguration(self, "RecordingConfiguration",
+            bucket=recording_bucket,
+        
+            # set thumbnail settings
+            thumbnail_configuration=ivs.ThumbnailConfiguration.interval(ivs.Resolution.HD, [ivs.Storage.LATEST, ivs.Storage.SEQUENTIAL], Duration.seconds(30))
+        )
+    '''
+
+    @jsii.member(jsii_name="disable")
+    @builtins.classmethod
+    def disable(cls) -> "ThumbnailConfiguration":
+        '''(experimental) Disable the generation of thumbnails for recorded video.
+
+        :stability: experimental
+        '''
+        return typing.cast("ThumbnailConfiguration", jsii.sinvoke(cls, "disable", []))
+
+    @jsii.member(jsii_name="interval")
+    @builtins.classmethod
+    def interval(
+        cls,
+        resolution: typing.Optional[Resolution] = None,
+        storage: typing.Optional[typing.Sequence[Storage]] = None,
+        target_interval: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
+    ) -> "ThumbnailConfiguration":
+        '''(experimental) Enable the generation of thumbnails for recorded video at a time interval.
+
+        :param resolution: The desired resolution of recorded thumbnails for a stream. If you do not specify this property, same resolution as Input stream is used.
+        :param storage: The format in which thumbnails are recorded for a stream. If you do not specify this property, ``ThumbnailStorage.SEQUENTIAL`` is set.
+        :param target_interval: The targeted thumbnail-generation interval. If you do not specify this property, ``Duration.seconds(60)`` is set.
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__7613b92b71ccf7e94fae8fd523b44fd066922450801fcef8848b59ff75f9eeb2)
+            check_type(argname="argument resolution", value=resolution, expected_type=type_hints["resolution"])
+            check_type(argname="argument storage", value=storage, expected_type=type_hints["storage"])
+            check_type(argname="argument target_interval", value=target_interval, expected_type=type_hints["target_interval"])
+        return typing.cast("ThumbnailConfiguration", jsii.sinvoke(cls, "interval", [resolution, storage, target_interval]))
+
+    @builtins.property
+    @jsii.member(jsii_name="recordingMode")
+    def recording_mode(self) -> typing.Optional[RecordingMode]:
+        '''(experimental) Thumbnail recording mode.
+
+        If you do not specify this property, ``ThumbnailRecordingMode.INTERVAL`` is set.
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional[RecordingMode], jsii.get(self, "recordingMode"))
+
+    @builtins.property
+    @jsii.member(jsii_name="resolution")
+    def resolution(self) -> typing.Optional[Resolution]:
+        '''(experimental) The desired resolution of recorded thumbnails for a stream.
+
+        If you do not specify this property, same resolution as Input stream is used.
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional[Resolution], jsii.get(self, "resolution"))
+
+    @builtins.property
+    @jsii.member(jsii_name="storage")
+    def storage(self) -> typing.Optional[typing.List[Storage]]:
+        '''(experimental) The format in which thumbnails are recorded for a stream.
+
+        If you do not specify this property, ``ThumbnailStorage.SEQUENTIAL`` is set.
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional[typing.List[Storage]], jsii.get(self, "storage"))
+
+    @builtins.property
+    @jsii.member(jsii_name="targetInterval")
+    def target_interval(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
+        '''(experimental) The targeted thumbnail-generation interval.
+
+        Must be between 1 and 60 seconds. If you do not specify this property, ``Duration.seconds(60)`` is set.
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], jsii.get(self, "targetInterval"))
+
+
 @jsii.implements(IChannel)
 class Channel(
     _aws_cdk_ceddda9d.Resource,
@@ -857,6 +1587,7 @@ class Channel(
         insecure_ingest: typing.Optional[builtins.bool] = None,
         latency_mode: typing.Optional[LatencyMode] = None,
         preset: typing.Optional[Preset] = None,
+        recording_configuration: typing.Optional[IRecordingConfiguration] = None,
         type: typing.Optional[ChannelType] = None,
     ) -> None:
         '''
@@ -867,6 +1598,7 @@ class Channel(
         :param insecure_ingest: (experimental) Whether the channel allows insecure RTMP ingest. Default: false
         :param latency_mode: (experimental) Channel latency mode. Default: LatencyMode.LOW
         :param preset: (experimental) An optional transcode preset for the channel. Can be used for ADVANCED_HD and ADVANCED_SD channel types. When LOW or STANDARD is used, the preset will be overridden and set to none regardless of the value provided. Default: - Preset.HIGHER_BANDWIDTH_DELIVERY if channelType is ADVANCED_SD or ADVANCED_HD, none otherwise
+        :param recording_configuration: (experimental) A recording configuration for the channel. Default: - recording is disabled
         :param type: (experimental) The channel type, which determines the allowable resolution and bitrate. If you exceed the allowable resolution or bitrate, the stream will disconnect immediately Default: ChannelType.STANDARD
 
         :stability: experimental
@@ -881,6 +1613,7 @@ class Channel(
             insecure_ingest=insecure_ingest,
             latency_mode=latency_mode,
             preset=preset,
+            recording_configuration=recording_configuration,
             type=type,
         )
 
@@ -965,13 +1698,22 @@ __all__ = [
     "ChannelType",
     "IChannel",
     "IPlaybackKeyPair",
+    "IRecordingConfiguration",
     "IStreamKey",
     "LatencyMode",
     "PlaybackKeyPair",
     "PlaybackKeyPairProps",
     "Preset",
+    "RecordingConfiguration",
+    "RecordingConfigurationProps",
+    "RecordingMode",
+    "RenditionConfiguration",
+    "RenditionSelection",
+    "Resolution",
+    "Storage",
     "StreamKey",
     "StreamKeyProps",
+    "ThumbnailConfiguration",
 ]
 
 publication.publish()
@@ -983,6 +1725,7 @@ def _typecheckingstub__0ebf6a0e98bbd5b88d9676fbe616666a44f837cba80675eade5df1fea
     insecure_ingest: typing.Optional[builtins.bool] = None,
     latency_mode: typing.Optional[LatencyMode] = None,
     preset: typing.Optional[Preset] = None,
+    recording_configuration: typing.Optional[IRecordingConfiguration] = None,
     type: typing.Optional[ChannelType] = None,
 ) -> None:
     """Type checking stubs"""
@@ -1012,6 +1755,52 @@ def _typecheckingstub__5f26b3314acb516329ef76511a5408ac87ae783446cab3f1be9ed1d0b
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__84f7bfe030fdaeee83dd169a4320aa71fb0e576e76fac8a6fb5e799d638df503(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    bucket: _aws_cdk_aws_s3_ceddda9d.IBucket,
+    recording_configuration_name: typing.Optional[builtins.str] = None,
+    recording_reconnect_window: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
+    rendition_configuration: typing.Optional[RenditionConfiguration] = None,
+    thumbnail_configuration: typing.Optional[ThumbnailConfiguration] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__5f6cbd063c6e695eed56d0c9c16dea95fe5f4b2a11e461c72cb33aa8d324e82d(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    recording_configuration_arn: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__9c05eebd5485c91c16b38e6bf9c1d896abb2eee019bb8f0da1ec7fa25b69b0d8(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    recording_configuration_id: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__21d80b5a61c717610ae7eec3eb729c41345980329354b0189415aab6624a4259(
+    *,
+    bucket: _aws_cdk_aws_s3_ceddda9d.IBucket,
+    recording_configuration_name: typing.Optional[builtins.str] = None,
+    recording_reconnect_window: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
+    rendition_configuration: typing.Optional[RenditionConfiguration] = None,
+    thumbnail_configuration: typing.Optional[ThumbnailConfiguration] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__72cbe17572adb3a1344760dd6061eca45611a877ad41668210371524b85d90da(
+    renditions: typing.Sequence[Resolution],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__67fad0f56ffbc15680b0f651250d8bb5cf4dacb899e5c5bbf4abdcfc3ae39632(
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
@@ -1028,6 +1817,14 @@ def _typecheckingstub__10474702d05a8d909166c4d0ef1de9632d82c17ae609436e3980c1bd4
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__7613b92b71ccf7e94fae8fd523b44fd066922450801fcef8848b59ff75f9eeb2(
+    resolution: typing.Optional[Resolution] = None,
+    storage: typing.Optional[typing.Sequence[Storage]] = None,
+    target_interval: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__07139327925dc97a551bbf17c849a0f698e0c9c60d3da3f65f2b3d2bea0e0c50(
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
@@ -1037,6 +1834,7 @@ def _typecheckingstub__07139327925dc97a551bbf17c849a0f698e0c9c60d3da3f65f2b3d2be
     insecure_ingest: typing.Optional[builtins.bool] = None,
     latency_mode: typing.Optional[LatencyMode] = None,
     preset: typing.Optional[Preset] = None,
+    recording_configuration: typing.Optional[IRecordingConfiguration] = None,
     type: typing.Optional[ChannelType] = None,
 ) -> None:
     """Type checking stubs"""

{aws_cdk_aws_ivs_alpha-2.166.0a0 → aws_cdk_aws_ivs_alpha-2.167.1a0}/src/aws_cdk/aws_ivs_alpha/_jsii/__init__.py

@@ -33,9 +33,9 @@ import constructs._jsii
 
 __jsii_assembly__ = jsii.JSIIAssembly.load(
     "@aws-cdk/aws-ivs-alpha",
-    "2.166.0-alpha.0",
+    "2.167.1-alpha.0",
     __name__[0:-6],
-    "aws-ivs-alpha@2.166.0-alpha.0.jsii.tgz",
+    "aws-ivs-alpha@2.167.1-alpha.0.jsii.tgz",
 )
 
 __all__ = [

{aws_cdk_aws_ivs_alpha-2.166.0a0 → aws_cdk_aws_ivs_alpha-2.167.1a0/src/aws_cdk.aws_ivs_alpha.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aws-cdk.aws-ivs-alpha
-Version: 2.166.0a0
+Version: 2.167.1a0
 Summary: The CDK Construct Library for AWS::IVS
 Home-page: https://github.com/aws/aws-cdk
 Author: Amazon Web Services
@@ -23,7 +23,7 @@ Requires-Python: ~=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: NOTICE
-Requires-Dist: aws-cdk-lib<3.0.0,>=2.166.0
+Requires-Dist: aws-cdk-lib<3.0.0,>=2.167.1
 Requires-Dist: constructs<11.0.0,>=10.0.0
 Requires-Dist: jsii<2.0.0,>=1.104.0
 Requires-Dist: publication>=0.0.3
@@ -145,3 +145,94 @@ my_channel = ivs.Channel(self, "Channel",
     authorized=True
 )
 ```
+
+## Recording Configurations
+
+An Amazon IVS Recording Configuration stores settings that specify how a channel's live streams should be recorded.
+You can configure video quality, thumbnail generation, and where recordings are stored in Amazon S3.
+
+For more information about IVS recording, see [IVS Auto-Record to Amazon S3 | Low-Latency Streaming](https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/record-to-s3.html).
+
+You can create a recording configuration:
+
+```python
+# create an S3 bucket for storing recordings
+recording_bucket = s3.Bucket(self, "RecordingBucket")
+
+# create a basic recording configuration
+recording_configuration = ivs.RecordingConfiguration(self, "RecordingConfiguration",
+    bucket=recording_bucket
+)
+```
+
+### Renditions of a Recording
+
+When you stream content to an Amazon IVS channel, auto-record-to-s3 uses the source video to generate multiple renditions.
+
+For more information, see [Discovering the Renditions of a Recording](https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/record-to-s3.html#r2s3-recording-renditions).
+
+```python
+# recording_bucket: s3.Bucket
+
+
+recording_configuration = ivs.RecordingConfiguration(self, "RecordingConfiguration",
+    bucket=recording_bucket,
+
+    # set rendition configuration
+    rendition_configuration=ivs.RenditionConfiguration.custom([ivs.Resolution.HD, ivs.Resolution.SD])
+)
+```
+
+### Thumbnail Generation
+
+You can enable or disable the recording of thumbnails for a live session and modify the interval at which thumbnails are generated for the live session.
+
+Thumbnail intervals may range from 1 second to 60 seconds; by default, thumbnail recording is enabled, at an interval of 60 seconds.
+
+For more information, see [Thumbnails](https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/record-to-s3.html#r2s3-thumbnails).
+
+```python
+# recording_bucket: s3.Bucket
+
+
+recording_configuration = ivs.RecordingConfiguration(self, "RecordingConfiguration",
+    bucket=recording_bucket,
+
+    # set thumbnail settings
+    thumbnail_configuration=ivs.ThumbnailConfiguration.interval(ivs.Resolution.HD, [ivs.Storage.LATEST, ivs.Storage.SEQUENTIAL], Duration.seconds(30))
+)
+```
+
+### Merge Fragmented Streams
+
+The `recordingReconnectWindow` property allows you to specify a window of time (in seconds) during which, if your stream is interrupted and a new stream is started, Amazon IVS tries to record to the same S3 prefix as the previous stream.
+
+In other words, if a broadcast disconnects and then reconnects within the specified interval, the multiple streams are considered a single broadcast and merged together.
+
+For more information, see [Merge Fragmented Streams](https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/record-to-s3.html#r2s3-merge-fragmented-streams).
+
+```python
+# recording_bucket: s3.Bucket
+
+
+recording_configuration = ivs.RecordingConfiguration(self, "RecordingConfiguration",
+    bucket=recording_bucket,
+
+    # set recording reconnect window
+    recording_reconnect_window=Duration.seconds(60)
+)
+```
+
+### Attaching Recording Configuration to a Channel
+
+To enable recording for a channel, specify the recording configuration when creating the channel:
+
+```python
+# recording_configuration: ivs.RecordingConfiguration
+
+
+channel = ivs.Channel(self, "Channel",
+    # set recording configuration
+    recording_configuration=recording_configuration
+)
+```

{aws_cdk_aws_ivs_alpha-2.166.0a0 → aws_cdk_aws_ivs_alpha-2.167.1a0}/src/aws_cdk.aws_ivs_alpha.egg-info/SOURCES.txt

@@ -12,4 +12,4 @@ src/aws_cdk.aws_ivs_alpha.egg-info/top_level.txt
 src/aws_cdk/aws_ivs_alpha/__init__.py
 src/aws_cdk/aws_ivs_alpha/py.typed
 src/aws_cdk/aws_ivs_alpha/_jsii/__init__.py
-src/aws_cdk/aws_ivs_alpha/_jsii/aws-ivs-alpha@2.166.0-alpha.0.jsii.tgz
+src/aws_cdk/aws_ivs_alpha/_jsii/aws-ivs-alpha@2.167.1-alpha.0.jsii.tgz

{aws_cdk_aws_ivs_alpha-2.166.0a0 → aws_cdk_aws_ivs_alpha-2.167.1a0}/src/aws_cdk.aws_ivs_alpha.egg-info/requires.txt

@@ -1,4 +1,4 @@
-aws-cdk-lib<3.0.0,>=2.166.0
+aws-cdk-lib<3.0.0,>=2.167.1
 constructs<11.0.0,>=10.0.0
 jsii<2.0.0,>=1.104.0
 publication>=0.0.3