aws-cdk-lib 2.142.1__py3-none-any.whl → 2.143.1__py3-none-any.whl

aws_cdk/aws_mediaconnect/__init__.py

@@ -2363,6 +2363,19 @@ class CfnFlow(
                 ingest_port=123,
                 max_bitrate=123,
                 max_latency=123,
+                max_sync_buffer=123,
+                media_stream_source_configurations=[mediaconnect.CfnFlow.MediaStreamSourceConfigurationProperty(
+                    encoding_name="encodingName",
+                    media_stream_name="mediaStreamName",
+        
+                    # the properties below are optional
+                    input_configurations=[mediaconnect.CfnFlow.InputConfigurationProperty(
+                        input_port=123,
+                        interface=mediaconnect.CfnFlow.InterfaceProperty(
+                            name="name"
+                        )
+                    )]
+                )],
                 min_latency=123,
                 name="name",
                 protocol="protocol",
@@ -2379,6 +2392,33 @@ class CfnFlow(
         
             # the properties below are optional
             availability_zone="availabilityZone",
+            maintenance=mediaconnect.CfnFlow.MaintenanceProperty(
+                maintenance_day="maintenanceDay",
+                maintenance_start_hour="maintenanceStartHour"
+            ),
+            media_streams=[mediaconnect.CfnFlow.MediaStreamProperty(
+                media_stream_id=123,
+                media_stream_name="mediaStreamName",
+                media_stream_type="mediaStreamType",
+        
+                # the properties below are optional
+                attributes=mediaconnect.CfnFlow.MediaStreamAttributesProperty(
+                    fmtp=mediaconnect.CfnFlow.FmtpProperty(
+                        channel_order="channelOrder",
+                        colorimetry="colorimetry",
+                        exact_framerate="exactFramerate",
+                        par="par",
+                        range="range",
+                        scan_mode="scanMode",
+                        tcs="tcs"
+                    ),
+                    lang="lang"
+                ),
+                clock_rate=123,
+                description="description",
+                fmt=123,
+                video_format="videoFormat"
+            )],
             source_failover_config=mediaconnect.CfnFlow.FailoverConfigProperty(
                 failover_mode="failoverMode",
                 recovery_window=123,
@@ -2386,7 +2426,17 @@ class CfnFlow(
                     primary_source="primarySource"
                 ),
                 state="state"
-            )
+            ),
+            vpc_interfaces=[mediaconnect.CfnFlow.VpcInterfaceProperty(
+                name="name",
+                role_arn="roleArn",
+                security_group_ids=["securityGroupIds"],
+                subnet_id="subnetId",
+        
+                # the properties below are optional
+                network_interface_ids=["networkInterfaceIds"],
+                network_interface_type="networkInterfaceType"
+            )]
         )
     '''
 
@@ -2398,7 +2448,10 @@ class CfnFlow(
         name: builtins.str,
         source: typing.Union[_IResolvable_da3f097b, typing.Union["CfnFlow.SourceProperty", typing.Dict[builtins.str, typing.Any]]],
         availability_zone: typing.Optional[builtins.str] = None,
+        maintenance: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnFlow.MaintenanceProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+        media_streams: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnFlow.MediaStreamProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
         source_failover_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnFlow.FailoverConfigProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+        vpc_interfaces: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnFlow.VpcInterfaceProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
     ) -> None:
         '''
         :param scope: Scope in which this resource is defined.
@@ -2406,7 +2459,10 @@ class CfnFlow(
         :param name: The name of the flow.
         :param source: The settings for the source that you want to use for the new flow.
         :param availability_zone: The Availability Zone that you want to create the flow in. These options are limited to the Availability Zones within the current AWS Region.
+        :param maintenance: The maintenance settings you want to use for the flow.
+        :param media_streams: The media streams associated with the flow. You can associate any of these media streams with sources and outputs on the flow.
         :param source_failover_config: The settings for source failover.
+        :param vpc_interfaces: The VPC interfaces that you added to this flow.
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__3568a95be2a886825b3db731f10e2fdea8be142c554d1e2055d7e22f5e6a3991)
@@ -2416,7 +2472,10 @@ class CfnFlow(
             name=name,
             source=source,
             availability_zone=availability_zone,
+            maintenance=maintenance,
+            media_streams=media_streams,
             source_failover_config=source_failover_config,
+            vpc_interfaces=vpc_interfaces,
         )
 
         jsii.create(self.__class__, self, [scope, id, props])
@@ -2451,6 +2510,15 @@ class CfnFlow(
         '''The CloudFormation resource type name for this resource class.'''
         return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))
 
+    @builtins.property
+    @jsii.member(jsii_name="attrEgressIp")
+    def attr_egress_ip(self) -> builtins.str:
+        '''The outgoing IP address that MediaConnect uses to send video from the flow.
+
+        :cloudformationAttribute: EgressIp
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "attrEgressIp"))
+
     @builtins.property
     @jsii.member(jsii_name="attrFlowArn")
     def attr_flow_arn(self) -> builtins.str:
@@ -2547,6 +2615,42 @@ class CfnFlow(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "availabilityZone", value)
 
+    @builtins.property
+    @jsii.member(jsii_name="maintenance")
+    def maintenance(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnFlow.MaintenanceProperty"]]:
+        '''The maintenance settings you want to use for the flow.'''
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnFlow.MaintenanceProperty"]], jsii.get(self, "maintenance"))
+
+    @maintenance.setter
+    def maintenance(
+        self,
+        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnFlow.MaintenanceProperty"]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__ddd188e9c2d5f8f194cf0b4c16e8b355b0ebcec43d953e6b0c8b77128e640aab)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "maintenance", value)
+
+    @builtins.property
+    @jsii.member(jsii_name="mediaStreams")
+    def media_streams(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnFlow.MediaStreamProperty"]]]]:
+        '''The media streams associated with the flow.'''
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnFlow.MediaStreamProperty"]]]], jsii.get(self, "mediaStreams"))
+
+    @media_streams.setter
+    def media_streams(
+        self,
+        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnFlow.MediaStreamProperty"]]]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__c580931c160d15b8c0f43f0fe96dc390b640ae81cbc1900b00f369aaa3c3f6e4)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "mediaStreams", value)
+
     @builtins.property
     @jsii.member(jsii_name="sourceFailoverConfig")
     def source_failover_config(
@@ -2565,6 +2669,24 @@ class CfnFlow(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "sourceFailoverConfig", value)
 
+    @builtins.property
+    @jsii.member(jsii_name="vpcInterfaces")
+    def vpc_interfaces(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnFlow.VpcInterfaceProperty"]]]]:
+        '''The VPC interfaces that you added to this flow.'''
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnFlow.VpcInterfaceProperty"]]]], jsii.get(self, "vpcInterfaces"))
+
+    @vpc_interfaces.setter
+    def vpc_interfaces(
+        self,
+        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnFlow.VpcInterfaceProperty"]]]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__7e75424871a1b67422fa8fe727bf0720abe8ea217c131244844ca71d14e25f4d)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "vpcInterfaces", value)
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_mediaconnect.CfnFlow.EncryptionProperty",
         jsii_struct_bases=[],
@@ -2886,6 +3008,161 @@ class CfnFlow(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_mediaconnect.CfnFlow.FmtpProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "channel_order": "channelOrder",
+            "colorimetry": "colorimetry",
+            "exact_framerate": "exactFramerate",
+            "par": "par",
+            "range": "range",
+            "scan_mode": "scanMode",
+            "tcs": "tcs",
+        },
+    )
+    class FmtpProperty:
+        def __init__(
+            self,
+            *,
+            channel_order: typing.Optional[builtins.str] = None,
+            colorimetry: typing.Optional[builtins.str] = None,
+            exact_framerate: typing.Optional[builtins.str] = None,
+            par: typing.Optional[builtins.str] = None,
+            range: typing.Optional[builtins.str] = None,
+            scan_mode: typing.Optional[builtins.str] = None,
+            tcs: typing.Optional[builtins.str] = None,
+        ) -> None:
+            '''A set of parameters that define the media stream.
+
+            :param channel_order: The format of the audio channel.
+            :param colorimetry: The format used for the representation of color.
+            :param exact_framerate: The frame rate for the video stream, in frames/second. For example: 60000/1001.
+            :param par: The pixel aspect ratio (PAR) of the video.
+            :param range: The encoding range of the video.
+            :param scan_mode: The type of compression that was used to smooth the video’s appearance.
+            :param tcs: The transfer characteristic system (TCS) that is used in the video.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-fmtp.html
+            :exampleMetadata: fixture=_generated
+
+            Example::
+
+                # The code below shows an example of how to instantiate this type.
+                # The values are placeholders you should change.
+                from aws_cdk import aws_mediaconnect as mediaconnect
+                
+                fmtp_property = mediaconnect.CfnFlow.FmtpProperty(
+                    channel_order="channelOrder",
+                    colorimetry="colorimetry",
+                    exact_framerate="exactFramerate",
+                    par="par",
+                    range="range",
+                    scan_mode="scanMode",
+                    tcs="tcs"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__2c34da6d27a4d46f87384739bd6ec7bcc9bf7866bb051703aa63a4b21e8b38dc)
+                check_type(argname="argument channel_order", value=channel_order, expected_type=type_hints["channel_order"])
+                check_type(argname="argument colorimetry", value=colorimetry, expected_type=type_hints["colorimetry"])
+                check_type(argname="argument exact_framerate", value=exact_framerate, expected_type=type_hints["exact_framerate"])
+                check_type(argname="argument par", value=par, expected_type=type_hints["par"])
+                check_type(argname="argument range", value=range, expected_type=type_hints["range"])
+                check_type(argname="argument scan_mode", value=scan_mode, expected_type=type_hints["scan_mode"])
+                check_type(argname="argument tcs", value=tcs, expected_type=type_hints["tcs"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if channel_order is not None:
+                self._values["channel_order"] = channel_order
+            if colorimetry is not None:
+                self._values["colorimetry"] = colorimetry
+            if exact_framerate is not None:
+                self._values["exact_framerate"] = exact_framerate
+            if par is not None:
+                self._values["par"] = par
+            if range is not None:
+                self._values["range"] = range
+            if scan_mode is not None:
+                self._values["scan_mode"] = scan_mode
+            if tcs is not None:
+                self._values["tcs"] = tcs
+
+        @builtins.property
+        def channel_order(self) -> typing.Optional[builtins.str]:
+            '''The format of the audio channel.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-fmtp.html#cfn-mediaconnect-flow-fmtp-channelorder
+            '''
+            result = self._values.get("channel_order")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def colorimetry(self) -> typing.Optional[builtins.str]:
+            '''The format used for the representation of color.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-fmtp.html#cfn-mediaconnect-flow-fmtp-colorimetry
+            '''
+            result = self._values.get("colorimetry")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def exact_framerate(self) -> typing.Optional[builtins.str]:
+            '''The frame rate for the video stream, in frames/second.
+
+            For example: 60000/1001.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-fmtp.html#cfn-mediaconnect-flow-fmtp-exactframerate
+            '''
+            result = self._values.get("exact_framerate")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def par(self) -> typing.Optional[builtins.str]:
+            '''The pixel aspect ratio (PAR) of the video.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-fmtp.html#cfn-mediaconnect-flow-fmtp-par
+            '''
+            result = self._values.get("par")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def range(self) -> typing.Optional[builtins.str]:
+            '''The encoding range of the video.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-fmtp.html#cfn-mediaconnect-flow-fmtp-range
+            '''
+            result = self._values.get("range")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def scan_mode(self) -> typing.Optional[builtins.str]:
+            '''The type of compression that was used to smooth the video’s appearance.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-fmtp.html#cfn-mediaconnect-flow-fmtp-scanmode
+            '''
+            result = self._values.get("scan_mode")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def tcs(self) -> typing.Optional[builtins.str]:
+            '''The transfer characteristic system (TCS) that is used in the video.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-fmtp.html#cfn-mediaconnect-flow-fmtp-tcs
+            '''
+            result = self._values.get("tcs")
+            return typing.cast(typing.Optional[builtins.str], 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 "FmtpProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_mediaconnect.CfnFlow.GatewayBridgeSourceProperty",
         jsii_struct_bases=[],
@@ -2919,41 +3196,628 @@ class CfnFlow(
                     bridge_arn="bridgeArn",
                 
                     # the properties below are optional
-                    vpc_interface_attachment=mediaconnect.CfnFlow.VpcInterfaceAttachmentProperty(
-                        vpc_interface_name="vpcInterfaceName"
-                    )
+                    vpc_interface_attachment=mediaconnect.CfnFlow.VpcInterfaceAttachmentProperty(
+                        vpc_interface_name="vpcInterfaceName"
+                    )
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__00bf15dc37f493c33d6b2109cfa6283d2bb14bdc23b0ae4fd75a67ca60084ea8)
+                check_type(argname="argument bridge_arn", value=bridge_arn, expected_type=type_hints["bridge_arn"])
+                check_type(argname="argument vpc_interface_attachment", value=vpc_interface_attachment, expected_type=type_hints["vpc_interface_attachment"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "bridge_arn": bridge_arn,
+            }
+            if vpc_interface_attachment is not None:
+                self._values["vpc_interface_attachment"] = vpc_interface_attachment
+
+        @builtins.property
+        def bridge_arn(self) -> builtins.str:
+            '''The ARN of the bridge feeding this flow.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-gatewaybridgesource.html#cfn-mediaconnect-flow-gatewaybridgesource-bridgearn
+            '''
+            result = self._values.get("bridge_arn")
+            assert result is not None, "Required property 'bridge_arn' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def vpc_interface_attachment(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnFlow.VpcInterfaceAttachmentProperty"]]:
+            '''The name of the VPC interface attachment to use for this bridge source.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-gatewaybridgesource.html#cfn-mediaconnect-flow-gatewaybridgesource-vpcinterfaceattachment
+            '''
+            result = self._values.get("vpc_interface_attachment")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnFlow.VpcInterfaceAttachmentProperty"]], 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 "GatewayBridgeSourceProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_mediaconnect.CfnFlow.InputConfigurationProperty",
+        jsii_struct_bases=[],
+        name_mapping={"input_port": "inputPort", "interface": "interface"},
+    )
+    class InputConfigurationProperty:
+        def __init__(
+            self,
+            *,
+            input_port: jsii.Number,
+            interface: typing.Union[_IResolvable_da3f097b, typing.Union["CfnFlow.InterfaceProperty", typing.Dict[builtins.str, typing.Any]]],
+        ) -> None:
+            '''The transport parameters associated with an incoming media stream.
+
+            :param input_port: The port that the flow listens on for an incoming media stream.
+            :param interface: The VPC interface where the media stream comes in from.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-inputconfiguration.html
+            :exampleMetadata: fixture=_generated
+
+            Example::
+
+                # The code below shows an example of how to instantiate this type.
+                # The values are placeholders you should change.
+                from aws_cdk import aws_mediaconnect as mediaconnect
+                
+                input_configuration_property = mediaconnect.CfnFlow.InputConfigurationProperty(
+                    input_port=123,
+                    interface=mediaconnect.CfnFlow.InterfaceProperty(
+                        name="name"
+                    )
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__fbb4a04e87ed2fedc67d03bbbab23670facee0c55014d0c5d234881ded41ec58)
+                check_type(argname="argument input_port", value=input_port, expected_type=type_hints["input_port"])
+                check_type(argname="argument interface", value=interface, expected_type=type_hints["interface"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "input_port": input_port,
+                "interface": interface,
+            }
+
+        @builtins.property
+        def input_port(self) -> jsii.Number:
+            '''The port that the flow listens on for an incoming media stream.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-inputconfiguration.html#cfn-mediaconnect-flow-inputconfiguration-inputport
+            '''
+            result = self._values.get("input_port")
+            assert result is not None, "Required property 'input_port' is missing"
+            return typing.cast(jsii.Number, result)
+
+        @builtins.property
+        def interface(
+            self,
+        ) -> typing.Union[_IResolvable_da3f097b, "CfnFlow.InterfaceProperty"]:
+            '''The VPC interface where the media stream comes in from.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-inputconfiguration.html#cfn-mediaconnect-flow-inputconfiguration-interface
+            '''
+            result = self._values.get("interface")
+            assert result is not None, "Required property 'interface' is missing"
+            return typing.cast(typing.Union[_IResolvable_da3f097b, "CfnFlow.InterfaceProperty"], 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 "InputConfigurationProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_mediaconnect.CfnFlow.InterfaceProperty",
+        jsii_struct_bases=[],
+        name_mapping={"name": "name"},
+    )
+    class InterfaceProperty:
+        def __init__(self, *, name: builtins.str) -> None:
+            '''The VPC interface that you want to use for the media stream associated with the output.
+
+            :param name: The name of the VPC interface that you want to use for the media stream associated with the output.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-interface.html
+            :exampleMetadata: fixture=_generated
+
+            Example::
+
+                # The code below shows an example of how to instantiate this type.
+                # The values are placeholders you should change.
+                from aws_cdk import aws_mediaconnect as mediaconnect
+                
+                interface_property = mediaconnect.CfnFlow.InterfaceProperty(
+                    name="name"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__0ca0a6498a5e542f31081d78420cae2b37457c94dbd68dcead2dc4af50843b27)
+                check_type(argname="argument name", value=name, expected_type=type_hints["name"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "name": name,
+            }
+
+        @builtins.property
+        def name(self) -> builtins.str:
+            '''The name of the VPC interface that you want to use for the media stream associated with the output.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-interface.html#cfn-mediaconnect-flow-interface-name
+            '''
+            result = self._values.get("name")
+            assert result is not None, "Required property 'name' is missing"
+            return typing.cast(builtins.str, 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 "InterfaceProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_mediaconnect.CfnFlow.MaintenanceProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "maintenance_day": "maintenanceDay",
+            "maintenance_start_hour": "maintenanceStartHour",
+        },
+    )
+    class MaintenanceProperty:
+        def __init__(
+            self,
+            *,
+            maintenance_day: builtins.str,
+            maintenance_start_hour: builtins.str,
+        ) -> None:
+            '''The maintenance setting of a flow.
+
+            MediaConnect routinely performs maintenance on underlying systems for security, reliability, and operational performance. The maintenance activities include actions such as patching the operating system, updating drivers, or installing software and patches.
+
+            You can select the day and time that maintenance events occur. This is called a maintenance window and is used every time a maintenance event is required. To change the day and time, you can edit the maintenance window using ``MaintenanceDay`` and ``MaintenanceStartHour`` .
+
+            :param maintenance_day: A day of a week when the maintenance will happen. Use Monday/Tuesday/Wednesday/Thursday/Friday/Saturday/Sunday.
+            :param maintenance_start_hour: UTC time when the maintenance will happen. Use 24-hour HH:MM format. Minutes must be 00. Example: 13:00. The default value is 02:00.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-maintenance.html
+            :exampleMetadata: fixture=_generated
+
+            Example::
+
+                # The code below shows an example of how to instantiate this type.
+                # The values are placeholders you should change.
+                from aws_cdk import aws_mediaconnect as mediaconnect
+                
+                maintenance_property = mediaconnect.CfnFlow.MaintenanceProperty(
+                    maintenance_day="maintenanceDay",
+                    maintenance_start_hour="maintenanceStartHour"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__57efc1d88b4fa5a6e6df4c17678237b4420bf63b5cd14e340198e67ed5a1ee60)
+                check_type(argname="argument maintenance_day", value=maintenance_day, expected_type=type_hints["maintenance_day"])
+                check_type(argname="argument maintenance_start_hour", value=maintenance_start_hour, expected_type=type_hints["maintenance_start_hour"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "maintenance_day": maintenance_day,
+                "maintenance_start_hour": maintenance_start_hour,
+            }
+
+        @builtins.property
+        def maintenance_day(self) -> builtins.str:
+            '''A day of a week when the maintenance will happen.
+
+            Use Monday/Tuesday/Wednesday/Thursday/Friday/Saturday/Sunday.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-maintenance.html#cfn-mediaconnect-flow-maintenance-maintenanceday
+            '''
+            result = self._values.get("maintenance_day")
+            assert result is not None, "Required property 'maintenance_day' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def maintenance_start_hour(self) -> builtins.str:
+            '''UTC time when the maintenance will happen.
+
+            Use 24-hour HH:MM format. Minutes must be 00. Example: 13:00. The default value is 02:00.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-maintenance.html#cfn-mediaconnect-flow-maintenance-maintenancestarthour
+            '''
+            result = self._values.get("maintenance_start_hour")
+            assert result is not None, "Required property 'maintenance_start_hour' is missing"
+            return typing.cast(builtins.str, 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 "MaintenanceProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_mediaconnect.CfnFlow.MediaStreamAttributesProperty",
+        jsii_struct_bases=[],
+        name_mapping={"fmtp": "fmtp", "lang": "lang"},
+    )
+    class MediaStreamAttributesProperty:
+        def __init__(
+            self,
+            *,
+            fmtp: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnFlow.FmtpProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            lang: typing.Optional[builtins.str] = None,
+        ) -> None:
+            '''Attributes that are related to the media stream.
+
+            :param fmtp: A set of parameters that define the media stream.
+            :param lang: The audio language, in a format that is recognized by the receiver.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-mediastreamattributes.html
+            :exampleMetadata: fixture=_generated
+
+            Example::
+
+                # The code below shows an example of how to instantiate this type.
+                # The values are placeholders you should change.
+                from aws_cdk import aws_mediaconnect as mediaconnect
+                
+                media_stream_attributes_property = mediaconnect.CfnFlow.MediaStreamAttributesProperty(
+                    fmtp=mediaconnect.CfnFlow.FmtpProperty(
+                        channel_order="channelOrder",
+                        colorimetry="colorimetry",
+                        exact_framerate="exactFramerate",
+                        par="par",
+                        range="range",
+                        scan_mode="scanMode",
+                        tcs="tcs"
+                    ),
+                    lang="lang"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__98c9c952274e74dd38a0129bccf9e3c8688c812151f95c826ce99e20158cfe87)
+                check_type(argname="argument fmtp", value=fmtp, expected_type=type_hints["fmtp"])
+                check_type(argname="argument lang", value=lang, expected_type=type_hints["lang"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if fmtp is not None:
+                self._values["fmtp"] = fmtp
+            if lang is not None:
+                self._values["lang"] = lang
+
+        @builtins.property
+        def fmtp(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnFlow.FmtpProperty"]]:
+            '''A set of parameters that define the media stream.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-mediastreamattributes.html#cfn-mediaconnect-flow-mediastreamattributes-fmtp
+            '''
+            result = self._values.get("fmtp")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnFlow.FmtpProperty"]], result)
+
+        @builtins.property
+        def lang(self) -> typing.Optional[builtins.str]:
+            '''The audio language, in a format that is recognized by the receiver.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-mediastreamattributes.html#cfn-mediaconnect-flow-mediastreamattributes-lang
+            '''
+            result = self._values.get("lang")
+            return typing.cast(typing.Optional[builtins.str], 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 "MediaStreamAttributesProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_mediaconnect.CfnFlow.MediaStreamProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "media_stream_id": "mediaStreamId",
+            "media_stream_name": "mediaStreamName",
+            "media_stream_type": "mediaStreamType",
+            "attributes": "attributes",
+            "clock_rate": "clockRate",
+            "description": "description",
+            "fmt": "fmt",
+            "video_format": "videoFormat",
+        },
+    )
+    class MediaStreamProperty:
+        def __init__(
+            self,
+            *,
+            media_stream_id: jsii.Number,
+            media_stream_name: builtins.str,
+            media_stream_type: builtins.str,
+            attributes: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnFlow.MediaStreamAttributesProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            clock_rate: typing.Optional[jsii.Number] = None,
+            description: typing.Optional[builtins.str] = None,
+            fmt: typing.Optional[jsii.Number] = None,
+            video_format: typing.Optional[builtins.str] = None,
+        ) -> None:
+            '''A single track or stream of media that contains video, audio, or ancillary data.
+
+            After you add a media stream to a flow, you can associate it with sources and outputs on that flow, as long as they use the CDI protocol or the ST 2110 JPEG XS protocol. Each source or output can consist of one or many media streams.
+
+            :param media_stream_id: A unique identifier for the media stream.
+            :param media_stream_name: A name that helps you distinguish one media stream from another.
+            :param media_stream_type: The type of media stream.
+            :param attributes: Attributes that are related to the media stream.
+            :param clock_rate: The sample rate for the stream. This value in measured in kHz.
+            :param description: A description that can help you quickly identify what your media stream is used for.
+            :param fmt: The format type number (sometimes referred to as RTP payload type) of the media stream. MediaConnect assigns this value to the media stream. For ST 2110 JPEG XS outputs, you need to provide this value to the receiver.
+            :param video_format: The resolution of the video.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-mediastream.html
+            :exampleMetadata: fixture=_generated
+
+            Example::
+
+                # The code below shows an example of how to instantiate this type.
+                # The values are placeholders you should change.
+                from aws_cdk import aws_mediaconnect as mediaconnect
+                
+                media_stream_property = mediaconnect.CfnFlow.MediaStreamProperty(
+                    media_stream_id=123,
+                    media_stream_name="mediaStreamName",
+                    media_stream_type="mediaStreamType",
+                
+                    # the properties below are optional
+                    attributes=mediaconnect.CfnFlow.MediaStreamAttributesProperty(
+                        fmtp=mediaconnect.CfnFlow.FmtpProperty(
+                            channel_order="channelOrder",
+                            colorimetry="colorimetry",
+                            exact_framerate="exactFramerate",
+                            par="par",
+                            range="range",
+                            scan_mode="scanMode",
+                            tcs="tcs"
+                        ),
+                        lang="lang"
+                    ),
+                    clock_rate=123,
+                    description="description",
+                    fmt=123,
+                    video_format="videoFormat"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__bc935e241ba7a00b3f70633b9ca54a5bca516c17065e6c6d8eeb7ab2523359be)
+                check_type(argname="argument media_stream_id", value=media_stream_id, expected_type=type_hints["media_stream_id"])
+                check_type(argname="argument media_stream_name", value=media_stream_name, expected_type=type_hints["media_stream_name"])
+                check_type(argname="argument media_stream_type", value=media_stream_type, expected_type=type_hints["media_stream_type"])
+                check_type(argname="argument attributes", value=attributes, expected_type=type_hints["attributes"])
+                check_type(argname="argument clock_rate", value=clock_rate, expected_type=type_hints["clock_rate"])
+                check_type(argname="argument description", value=description, expected_type=type_hints["description"])
+                check_type(argname="argument fmt", value=fmt, expected_type=type_hints["fmt"])
+                check_type(argname="argument video_format", value=video_format, expected_type=type_hints["video_format"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "media_stream_id": media_stream_id,
+                "media_stream_name": media_stream_name,
+                "media_stream_type": media_stream_type,
+            }
+            if attributes is not None:
+                self._values["attributes"] = attributes
+            if clock_rate is not None:
+                self._values["clock_rate"] = clock_rate
+            if description is not None:
+                self._values["description"] = description
+            if fmt is not None:
+                self._values["fmt"] = fmt
+            if video_format is not None:
+                self._values["video_format"] = video_format
+
+        @builtins.property
+        def media_stream_id(self) -> jsii.Number:
+            '''A unique identifier for the media stream.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-mediastream.html#cfn-mediaconnect-flow-mediastream-mediastreamid
+            '''
+            result = self._values.get("media_stream_id")
+            assert result is not None, "Required property 'media_stream_id' is missing"
+            return typing.cast(jsii.Number, result)
+
+        @builtins.property
+        def media_stream_name(self) -> builtins.str:
+            '''A name that helps you distinguish one media stream from another.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-mediastream.html#cfn-mediaconnect-flow-mediastream-mediastreamname
+            '''
+            result = self._values.get("media_stream_name")
+            assert result is not None, "Required property 'media_stream_name' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def media_stream_type(self) -> builtins.str:
+            '''The type of media stream.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-mediastream.html#cfn-mediaconnect-flow-mediastream-mediastreamtype
+            '''
+            result = self._values.get("media_stream_type")
+            assert result is not None, "Required property 'media_stream_type' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def attributes(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnFlow.MediaStreamAttributesProperty"]]:
+            '''Attributes that are related to the media stream.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-mediastream.html#cfn-mediaconnect-flow-mediastream-attributes
+            '''
+            result = self._values.get("attributes")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnFlow.MediaStreamAttributesProperty"]], result)
+
+        @builtins.property
+        def clock_rate(self) -> typing.Optional[jsii.Number]:
+            '''The sample rate for the stream.
+
+            This value in measured in kHz.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-mediastream.html#cfn-mediaconnect-flow-mediastream-clockrate
+            '''
+            result = self._values.get("clock_rate")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def description(self) -> typing.Optional[builtins.str]:
+            '''A description that can help you quickly identify what your media stream is used for.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-mediastream.html#cfn-mediaconnect-flow-mediastream-description
+            '''
+            result = self._values.get("description")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def fmt(self) -> typing.Optional[jsii.Number]:
+            '''The format type number (sometimes referred to as RTP payload type) of the media stream.
+
+            MediaConnect assigns this value to the media stream. For ST 2110 JPEG XS outputs, you need to provide this value to the receiver.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-mediastream.html#cfn-mediaconnect-flow-mediastream-fmt
+            '''
+            result = self._values.get("fmt")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def video_format(self) -> typing.Optional[builtins.str]:
+            '''The resolution of the video.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-mediastream.html#cfn-mediaconnect-flow-mediastream-videoformat
+            '''
+            result = self._values.get("video_format")
+            return typing.cast(typing.Optional[builtins.str], 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 "MediaStreamProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_mediaconnect.CfnFlow.MediaStreamSourceConfigurationProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "encoding_name": "encodingName",
+            "media_stream_name": "mediaStreamName",
+            "input_configurations": "inputConfigurations",
+        },
+    )
+    class MediaStreamSourceConfigurationProperty:
+        def __init__(
+            self,
+            *,
+            encoding_name: builtins.str,
+            media_stream_name: builtins.str,
+            input_configurations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnFlow.InputConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
+        ) -> None:
+            '''The media stream that is associated with the source, and the parameters for that association.
+
+            :param encoding_name: The format that was used to encode the data. For ancillary data streams, set the encoding name to ``smpte291`` . For audio streams, set the encoding name to ``pcm`` . For video, 2110 streams, set the encoding name to ``raw`` . For video, JPEG XS streams, set the encoding name to ``jxsv`` .
+            :param media_stream_name: A name that helps you distinguish one media stream from another.
+            :param input_configurations: The media streams that you want to associate with the source.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-mediastreamsourceconfiguration.html
+            :exampleMetadata: fixture=_generated
+
+            Example::
+
+                # The code below shows an example of how to instantiate this type.
+                # The values are placeholders you should change.
+                from aws_cdk import aws_mediaconnect as mediaconnect
+                
+                media_stream_source_configuration_property = mediaconnect.CfnFlow.MediaStreamSourceConfigurationProperty(
+                    encoding_name="encodingName",
+                    media_stream_name="mediaStreamName",
+                
+                    # the properties below are optional
+                    input_configurations=[mediaconnect.CfnFlow.InputConfigurationProperty(
+                        input_port=123,
+                        interface=mediaconnect.CfnFlow.InterfaceProperty(
+                            name="name"
+                        )
+                    )]
                 )
             '''
             if __debug__:
-                type_hints = typing.get_type_hints(_typecheckingstub__00bf15dc37f493c33d6b2109cfa6283d2bb14bdc23b0ae4fd75a67ca60084ea8)
-                check_type(argname="argument bridge_arn", value=bridge_arn, expected_type=type_hints["bridge_arn"])
-                check_type(argname="argument vpc_interface_attachment", value=vpc_interface_attachment, expected_type=type_hints["vpc_interface_attachment"])
+                type_hints = typing.get_type_hints(_typecheckingstub__c288224888dcd985ea78c20d06801a00405d4260bf960e8dbcac65f3e669aa4f)
+                check_type(argname="argument encoding_name", value=encoding_name, expected_type=type_hints["encoding_name"])
+                check_type(argname="argument media_stream_name", value=media_stream_name, expected_type=type_hints["media_stream_name"])
+                check_type(argname="argument input_configurations", value=input_configurations, expected_type=type_hints["input_configurations"])
             self._values: typing.Dict[builtins.str, typing.Any] = {
-                "bridge_arn": bridge_arn,
+                "encoding_name": encoding_name,
+                "media_stream_name": media_stream_name,
             }
-            if vpc_interface_attachment is not None:
-                self._values["vpc_interface_attachment"] = vpc_interface_attachment
+            if input_configurations is not None:
+                self._values["input_configurations"] = input_configurations
 
         @builtins.property
-        def bridge_arn(self) -> builtins.str:
-            '''The ARN of the bridge feeding this flow.
+        def encoding_name(self) -> builtins.str:
+            '''The format that was used to encode the data.
 
-            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-gatewaybridgesource.html#cfn-mediaconnect-flow-gatewaybridgesource-bridgearn
+            For ancillary data streams, set the encoding name to ``smpte291`` .
+
+            For audio streams, set the encoding name to ``pcm`` .
+
+            For video, 2110 streams, set the encoding name to ``raw`` .
+
+            For video, JPEG XS streams, set the encoding name to ``jxsv`` .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-mediastreamsourceconfiguration.html#cfn-mediaconnect-flow-mediastreamsourceconfiguration-encodingname
             '''
-            result = self._values.get("bridge_arn")
-            assert result is not None, "Required property 'bridge_arn' is missing"
+            result = self._values.get("encoding_name")
+            assert result is not None, "Required property 'encoding_name' is missing"
             return typing.cast(builtins.str, result)
 
         @builtins.property
-        def vpc_interface_attachment(
+        def media_stream_name(self) -> builtins.str:
+            '''A name that helps you distinguish one media stream from another.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-mediastreamsourceconfiguration.html#cfn-mediaconnect-flow-mediastreamsourceconfiguration-mediastreamname
+            '''
+            result = self._values.get("media_stream_name")
+            assert result is not None, "Required property 'media_stream_name' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def input_configurations(
             self,
-        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnFlow.VpcInterfaceAttachmentProperty"]]:
-            '''The name of the VPC interface attachment to use for this bridge source.
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnFlow.InputConfigurationProperty"]]]]:
+            '''The media streams that you want to associate with the source.
 
-            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-gatewaybridgesource.html#cfn-mediaconnect-flow-gatewaybridgesource-vpcinterfaceattachment
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-mediastreamsourceconfiguration.html#cfn-mediaconnect-flow-mediastreamsourceconfiguration-inputconfigurations
             '''
-            result = self._values.get("vpc_interface_attachment")
-            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnFlow.VpcInterfaceAttachmentProperty"]], result)
+            result = self._values.get("input_configurations")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnFlow.InputConfigurationProperty"]]]], result)
 
         def __eq__(self, rhs: typing.Any) -> builtins.bool:
             return isinstance(rhs, self.__class__) and rhs._values == self._values
@@ -2962,7 +3826,7 @@ class CfnFlow(
             return not (rhs == self)
 
         def __repr__(self) -> str:
-            return "GatewayBridgeSourceProperty(%s)" % ", ".join(
+            return "MediaStreamSourceConfigurationProperty(%s)" % ", ".join(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
@@ -3032,6 +3896,8 @@ class CfnFlow(
             "ingest_port": "ingestPort",
             "max_bitrate": "maxBitrate",
             "max_latency": "maxLatency",
+            "max_sync_buffer": "maxSyncBuffer",
+            "media_stream_source_configurations": "mediaStreamSourceConfigurations",
             "min_latency": "minLatency",
             "name": "name",
             "protocol": "protocol",
@@ -3058,6 +3924,8 @@ class CfnFlow(
             ingest_port: typing.Optional[jsii.Number] = None,
             max_bitrate: typing.Optional[jsii.Number] = None,
             max_latency: typing.Optional[jsii.Number] = None,
+            max_sync_buffer: typing.Optional[jsii.Number] = None,
+            media_stream_source_configurations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnFlow.MediaStreamSourceConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
             min_latency: typing.Optional[jsii.Number] = None,
             name: typing.Optional[builtins.str] = None,
             protocol: typing.Optional[builtins.str] = None,
@@ -3087,6 +3955,8 @@ class CfnFlow(
             :param ingest_port: The port that the flow listens on for incoming content. If the protocol of the source is Zixi, the port must be set to 2088.
             :param max_bitrate: The maximum bitrate for RIST, RTP, and RTP-FEC streams.
             :param max_latency: The maximum latency in milliseconds for a RIST or Zixi-based source. Default: - 2000
+            :param max_sync_buffer: The size of the buffer (in milliseconds) to use to sync incoming source data.
+            :param media_stream_source_configurations: The media stream that is associated with the source, and the parameters for that association.
             :param min_latency: The minimum latency in milliseconds for SRT-based streams. In streams that use the SRT protocol, this value that you set on your MediaConnect source or output represents the minimal potential latency of that connection. The latency of the stream is set to the highest number between the sender’s minimum latency and the receiver’s minimum latency. Default: - 2000
             :param name: The name of the source.
             :param protocol: The protocol that is used by the source. AWS CloudFormation does not currently support CDI or ST 2110 JPEG XS source protocols.
@@ -3137,6 +4007,19 @@ class CfnFlow(
                     ingest_port=123,
                     max_bitrate=123,
                     max_latency=123,
+                    max_sync_buffer=123,
+                    media_stream_source_configurations=[mediaconnect.CfnFlow.MediaStreamSourceConfigurationProperty(
+                        encoding_name="encodingName",
+                        media_stream_name="mediaStreamName",
+                
+                        # the properties below are optional
+                        input_configurations=[mediaconnect.CfnFlow.InputConfigurationProperty(
+                            input_port=123,
+                            interface=mediaconnect.CfnFlow.InterfaceProperty(
+                                name="name"
+                            )
+                        )]
+                    )],
                     min_latency=123,
                     name="name",
                     protocol="protocol",
@@ -3161,6 +4044,8 @@ class CfnFlow(
                 check_type(argname="argument ingest_port", value=ingest_port, expected_type=type_hints["ingest_port"])
                 check_type(argname="argument max_bitrate", value=max_bitrate, expected_type=type_hints["max_bitrate"])
                 check_type(argname="argument max_latency", value=max_latency, expected_type=type_hints["max_latency"])
+                check_type(argname="argument max_sync_buffer", value=max_sync_buffer, expected_type=type_hints["max_sync_buffer"])
+                check_type(argname="argument media_stream_source_configurations", value=media_stream_source_configurations, expected_type=type_hints["media_stream_source_configurations"])
                 check_type(argname="argument min_latency", value=min_latency, expected_type=type_hints["min_latency"])
                 check_type(argname="argument name", value=name, expected_type=type_hints["name"])
                 check_type(argname="argument protocol", value=protocol, expected_type=type_hints["protocol"])
@@ -3190,6 +4075,10 @@ class CfnFlow(
                 self._values["max_bitrate"] = max_bitrate
             if max_latency is not None:
                 self._values["max_latency"] = max_latency
+            if max_sync_buffer is not None:
+                self._values["max_sync_buffer"] = max_sync_buffer
+            if media_stream_source_configurations is not None:
+                self._values["media_stream_source_configurations"] = media_stream_source_configurations
             if min_latency is not None:
                 self._values["min_latency"] = min_latency
             if name is not None:
@@ -3299,6 +4188,26 @@ class CfnFlow(
             result = self._values.get("max_latency")
             return typing.cast(typing.Optional[jsii.Number], result)
 
+        @builtins.property
+        def max_sync_buffer(self) -> typing.Optional[jsii.Number]:
+            '''The size of the buffer (in milliseconds) to use to sync incoming source data.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-source.html#cfn-mediaconnect-flow-source-maxsyncbuffer
+            '''
+            result = self._values.get("max_sync_buffer")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def media_stream_source_configurations(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnFlow.MediaStreamSourceConfigurationProperty"]]]]:
+            '''The media stream that is associated with the source, and the parameters for that association.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-source.html#cfn-mediaconnect-flow-source-mediastreamsourceconfigurations
+            '''
+            result = self._values.get("media_stream_source_configurations")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnFlow.MediaStreamSourceConfigurationProperty"]]]], result)
+
         @builtins.property
         def min_latency(self) -> typing.Optional[jsii.Number]:
             '''The minimum latency in milliseconds for SRT-based streams.
@@ -3485,6 +4394,152 @@ class CfnFlow(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_mediaconnect.CfnFlow.VpcInterfaceProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "name": "name",
+            "role_arn": "roleArn",
+            "security_group_ids": "securityGroupIds",
+            "subnet_id": "subnetId",
+            "network_interface_ids": "networkInterfaceIds",
+            "network_interface_type": "networkInterfaceType",
+        },
+    )
+    class VpcInterfaceProperty:
+        def __init__(
+            self,
+            *,
+            name: builtins.str,
+            role_arn: builtins.str,
+            security_group_ids: typing.Sequence[builtins.str],
+            subnet_id: builtins.str,
+            network_interface_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
+            network_interface_type: typing.Optional[builtins.str] = None,
+        ) -> None:
+            '''The details of a VPC interface.
+
+            :param name: The name for the VPC interface. This name must be unique within the flow.
+            :param role_arn: The ARN of the IAM role that you created when you set up MediaConnect as a trusted service.
+            :param security_group_ids: A virtual firewall to control inbound and outbound traffic.
+            :param subnet_id: The subnet IDs that you specified for your VPC interface. A subnet ID is a range of IP addresses in your VPC. When you create your VPC, you specify a range of IPv4 addresses for the VPC in the form of a Classless Inter-Domain Routing (CIDR) block; for example, 10.0.0.0/16. This is the primary CIDR block for your VPC. When you create a subnet for your VPC, you specify the CIDR block for the subnet, which is a subset of the VPC CIDR block. The subnets that you use across all VPC interfaces on the flow must be in the same Availability Zone as the flow.
+            :param network_interface_ids: The IDs of the network interfaces that MediaConnect created in your account.
+            :param network_interface_type: The type of network interface.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-vpcinterface.html
+            :exampleMetadata: fixture=_generated
+
+            Example::
+
+                # The code below shows an example of how to instantiate this type.
+                # The values are placeholders you should change.
+                from aws_cdk import aws_mediaconnect as mediaconnect
+                
+                vpc_interface_property = mediaconnect.CfnFlow.VpcInterfaceProperty(
+                    name="name",
+                    role_arn="roleArn",
+                    security_group_ids=["securityGroupIds"],
+                    subnet_id="subnetId",
+                
+                    # the properties below are optional
+                    network_interface_ids=["networkInterfaceIds"],
+                    network_interface_type="networkInterfaceType"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__d976d1dab1b395c0026dcc2152c4dd635ae54d817a1f10c4d8f2725ac4862ad4)
+                check_type(argname="argument name", value=name, expected_type=type_hints["name"])
+                check_type(argname="argument role_arn", value=role_arn, expected_type=type_hints["role_arn"])
+                check_type(argname="argument security_group_ids", value=security_group_ids, expected_type=type_hints["security_group_ids"])
+                check_type(argname="argument subnet_id", value=subnet_id, expected_type=type_hints["subnet_id"])
+                check_type(argname="argument network_interface_ids", value=network_interface_ids, expected_type=type_hints["network_interface_ids"])
+                check_type(argname="argument network_interface_type", value=network_interface_type, expected_type=type_hints["network_interface_type"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "name": name,
+                "role_arn": role_arn,
+                "security_group_ids": security_group_ids,
+                "subnet_id": subnet_id,
+            }
+            if network_interface_ids is not None:
+                self._values["network_interface_ids"] = network_interface_ids
+            if network_interface_type is not None:
+                self._values["network_interface_type"] = network_interface_type
+
+        @builtins.property
+        def name(self) -> builtins.str:
+            '''The name for the VPC interface.
+
+            This name must be unique within the flow.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-vpcinterface.html#cfn-mediaconnect-flow-vpcinterface-name
+            '''
+            result = self._values.get("name")
+            assert result is not None, "Required property 'name' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def role_arn(self) -> builtins.str:
+            '''The ARN of the IAM role that you created when you set up MediaConnect as a trusted service.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-vpcinterface.html#cfn-mediaconnect-flow-vpcinterface-rolearn
+            '''
+            result = self._values.get("role_arn")
+            assert result is not None, "Required property 'role_arn' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def security_group_ids(self) -> typing.List[builtins.str]:
+            '''A virtual firewall to control inbound and outbound traffic.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-vpcinterface.html#cfn-mediaconnect-flow-vpcinterface-securitygroupids
+            '''
+            result = self._values.get("security_group_ids")
+            assert result is not None, "Required property 'security_group_ids' is missing"
+            return typing.cast(typing.List[builtins.str], result)
+
+        @builtins.property
+        def subnet_id(self) -> builtins.str:
+            '''The subnet IDs that you specified for your VPC interface.
+
+            A subnet ID is a range of IP addresses in your VPC. When you create your VPC, you specify a range of IPv4 addresses for the VPC in the form of a Classless Inter-Domain Routing (CIDR) block; for example, 10.0.0.0/16. This is the primary CIDR block for your VPC. When you create a subnet for your VPC, you specify the CIDR block for the subnet, which is a subset of the VPC CIDR block.
+
+            The subnets that you use across all VPC interfaces on the flow must be in the same Availability Zone as the flow.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-vpcinterface.html#cfn-mediaconnect-flow-vpcinterface-subnetid
+            '''
+            result = self._values.get("subnet_id")
+            assert result is not None, "Required property 'subnet_id' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def network_interface_ids(self) -> typing.Optional[typing.List[builtins.str]]:
+            '''The IDs of the network interfaces that MediaConnect created in your account.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-vpcinterface.html#cfn-mediaconnect-flow-vpcinterface-networkinterfaceids
+            '''
+            result = self._values.get("network_interface_ids")
+            return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+        @builtins.property
+        def network_interface_type(self) -> typing.Optional[builtins.str]:
+            '''The type of network interface.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flow-vpcinterface.html#cfn-mediaconnect-flow-vpcinterface-networkinterfacetype
+            '''
+            result = self._values.get("network_interface_type")
+            return typing.cast(typing.Optional[builtins.str], 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 "VpcInterfaceProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
 
 @jsii.implements(_IInspectable_c2943556)
 class CfnFlowEntitlement(
@@ -4137,6 +5192,25 @@ class CfnFlowOutput(
                 key_type="keyType"
             ),
             max_latency=123,
+            media_stream_output_configurations=[mediaconnect.CfnFlowOutput.MediaStreamOutputConfigurationProperty(
+                encoding_name="encodingName",
+                media_stream_name="mediaStreamName",
+        
+                # the properties below are optional
+                destination_configurations=[mediaconnect.CfnFlowOutput.DestinationConfigurationProperty(
+                    destination_ip="destinationIp",
+                    destination_port=123,
+                    interface=mediaconnect.CfnFlowOutput.InterfaceProperty(
+                        name="name"
+                    )
+                )],
+                encoding_parameters=mediaconnect.CfnFlowOutput.EncodingParametersProperty(
+                    compression_factor=123,
+        
+                    # the properties below are optional
+                    encoder_profile="encoderProfile"
+                )
+            )],
             min_latency=123,
             name="name",
             port=123,
@@ -4161,6 +5235,7 @@ class CfnFlowOutput(
         destination: typing.Optional[builtins.str] = None,
         encryption: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnFlowOutput.EncryptionProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         max_latency: typing.Optional[jsii.Number] = None,
+        media_stream_output_configurations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnFlowOutput.MediaStreamOutputConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
         min_latency: typing.Optional[jsii.Number] = None,
         name: typing.Optional[builtins.str] = None,
         port: typing.Optional[jsii.Number] = None,
@@ -4179,6 +5254,7 @@ class CfnFlowOutput(
         :param destination: The IP address where you want to send the output.
         :param encryption: The encryption credentials that you want to use for the output.
         :param max_latency: The maximum latency in milliseconds. This parameter applies only to RIST-based, Zixi-based, and Fujitsu-based streams.
+        :param media_stream_output_configurations: The definition for each media stream that is associated with the output.
         :param min_latency: The minimum latency in milliseconds for SRT-based streams. In streams that use the SRT protocol, this value that you set on your MediaConnect source or output represents the minimal potential latency of that connection. The latency of the stream is set to the highest number between the sender’s minimum latency and the receiver’s minimum latency.
         :param name: The name of the output. This value must be unique within the current flow.
         :param port: The port to use when MediaConnect distributes content to the output.
@@ -4199,6 +5275,7 @@ class CfnFlowOutput(
             destination=destination,
             encryption=encryption,
             max_latency=max_latency,
+            media_stream_output_configurations=media_stream_output_configurations,
             min_latency=min_latency,
             name=name,
             port=port,
@@ -4353,6 +5430,24 @@ class CfnFlowOutput(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "maxLatency", value)
 
+    @builtins.property
+    @jsii.member(jsii_name="mediaStreamOutputConfigurations")
+    def media_stream_output_configurations(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnFlowOutput.MediaStreamOutputConfigurationProperty"]]]]:
+        '''The definition for each media stream that is associated with the output.'''
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnFlowOutput.MediaStreamOutputConfigurationProperty"]]]], jsii.get(self, "mediaStreamOutputConfigurations"))
+
+    @media_stream_output_configurations.setter
+    def media_stream_output_configurations(
+        self,
+        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnFlowOutput.MediaStreamOutputConfigurationProperty"]]]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__c99ca24b6208e72328e18819b003e97cbf14fb0f94304256c59924c6e02ae32d)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "mediaStreamOutputConfigurations", value)
+
     @builtins.property
     @jsii.member(jsii_name="minLatency")
     def min_latency(self) -> typing.Optional[jsii.Number]:
@@ -4431,23 +5526,203 @@ class CfnFlowOutput(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "streamId", value)
 
-    @builtins.property
-    @jsii.member(jsii_name="vpcInterfaceAttachment")
-    def vpc_interface_attachment(
-        self,
-    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnFlowOutput.VpcInterfaceAttachmentProperty"]]:
-        '''The VPC interface that you want to send your output to.'''
-        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnFlowOutput.VpcInterfaceAttachmentProperty"]], jsii.get(self, "vpcInterfaceAttachment"))
+    @builtins.property
+    @jsii.member(jsii_name="vpcInterfaceAttachment")
+    def vpc_interface_attachment(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnFlowOutput.VpcInterfaceAttachmentProperty"]]:
+        '''The VPC interface that you want to send your output to.'''
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnFlowOutput.VpcInterfaceAttachmentProperty"]], jsii.get(self, "vpcInterfaceAttachment"))
+
+    @vpc_interface_attachment.setter
+    def vpc_interface_attachment(
+        self,
+        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnFlowOutput.VpcInterfaceAttachmentProperty"]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__65a3e058407bcf8bd6fa065c9fd3cd66a1c54e7edb3b48af25c7893fd72db21d)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "vpcInterfaceAttachment", value)
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_mediaconnect.CfnFlowOutput.DestinationConfigurationProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "destination_ip": "destinationIp",
+            "destination_port": "destinationPort",
+            "interface": "interface",
+        },
+    )
+    class DestinationConfigurationProperty:
+        def __init__(
+            self,
+            *,
+            destination_ip: builtins.str,
+            destination_port: jsii.Number,
+            interface: typing.Union[_IResolvable_da3f097b, typing.Union["CfnFlowOutput.InterfaceProperty", typing.Dict[builtins.str, typing.Any]]],
+        ) -> None:
+            '''The definition of a media stream that is associated with the output.
+
+            :param destination_ip: The IP address where contents of the media stream will be sent.
+            :param destination_port: The port to use when the content of the media stream is distributed to the output.
+            :param interface: The VPC interface that is used for the media stream associated with the output.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flowoutput-destinationconfiguration.html
+            :exampleMetadata: fixture=_generated
+
+            Example::
+
+                # The code below shows an example of how to instantiate this type.
+                # The values are placeholders you should change.
+                from aws_cdk import aws_mediaconnect as mediaconnect
+                
+                destination_configuration_property = mediaconnect.CfnFlowOutput.DestinationConfigurationProperty(
+                    destination_ip="destinationIp",
+                    destination_port=123,
+                    interface=mediaconnect.CfnFlowOutput.InterfaceProperty(
+                        name="name"
+                    )
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__8b62fc10e1fb76cee67ab63dde918a0006c11ce38e8af823e4d2f2770e4d5765)
+                check_type(argname="argument destination_ip", value=destination_ip, expected_type=type_hints["destination_ip"])
+                check_type(argname="argument destination_port", value=destination_port, expected_type=type_hints["destination_port"])
+                check_type(argname="argument interface", value=interface, expected_type=type_hints["interface"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "destination_ip": destination_ip,
+                "destination_port": destination_port,
+                "interface": interface,
+            }
+
+        @builtins.property
+        def destination_ip(self) -> builtins.str:
+            '''The IP address where contents of the media stream will be sent.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flowoutput-destinationconfiguration.html#cfn-mediaconnect-flowoutput-destinationconfiguration-destinationip
+            '''
+            result = self._values.get("destination_ip")
+            assert result is not None, "Required property 'destination_ip' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def destination_port(self) -> jsii.Number:
+            '''The port to use when the content of the media stream is distributed to the output.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flowoutput-destinationconfiguration.html#cfn-mediaconnect-flowoutput-destinationconfiguration-destinationport
+            '''
+            result = self._values.get("destination_port")
+            assert result is not None, "Required property 'destination_port' is missing"
+            return typing.cast(jsii.Number, result)
+
+        @builtins.property
+        def interface(
+            self,
+        ) -> typing.Union[_IResolvable_da3f097b, "CfnFlowOutput.InterfaceProperty"]:
+            '''The VPC interface that is used for the media stream associated with the output.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flowoutput-destinationconfiguration.html#cfn-mediaconnect-flowoutput-destinationconfiguration-interface
+            '''
+            result = self._values.get("interface")
+            assert result is not None, "Required property 'interface' is missing"
+            return typing.cast(typing.Union[_IResolvable_da3f097b, "CfnFlowOutput.InterfaceProperty"], 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 "DestinationConfigurationProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_mediaconnect.CfnFlowOutput.EncodingParametersProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "compression_factor": "compressionFactor",
+            "encoder_profile": "encoderProfile",
+        },
+    )
+    class EncodingParametersProperty:
+        def __init__(
+            self,
+            *,
+            compression_factor: jsii.Number,
+            encoder_profile: typing.Optional[builtins.str] = None,
+        ) -> None:
+            '''A collection of parameters that determine how MediaConnect will convert the content.
+
+            These fields only apply to outputs on flows that have a CDI source.
+
+            :param compression_factor: A value that is used to calculate compression for an output. The bitrate of the output is calculated as follows: Output bitrate = (1 / compressionFactor) * (source bitrate) This property only applies to outputs that use the ST 2110 JPEG XS protocol, with a flow source that uses the CDI protocol. Valid values are in the range of 3.0 to 10.0, inclusive.
+            :param encoder_profile: A setting on the encoder that drives compression settings. This property only applies to video media streams associated with outputs that use the ST 2110 JPEG XS protocol, with a flow source that uses the CDI protocol.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flowoutput-encodingparameters.html
+            :exampleMetadata: fixture=_generated
+
+            Example::
+
+                # The code below shows an example of how to instantiate this type.
+                # The values are placeholders you should change.
+                from aws_cdk import aws_mediaconnect as mediaconnect
+                
+                encoding_parameters_property = mediaconnect.CfnFlowOutput.EncodingParametersProperty(
+                    compression_factor=123,
+                
+                    # the properties below are optional
+                    encoder_profile="encoderProfile"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__d7e858c0a050e7b9bf4f84c7f6034ad1cf704a2a9a2b07a5b472d598f1b62d5f)
+                check_type(argname="argument compression_factor", value=compression_factor, expected_type=type_hints["compression_factor"])
+                check_type(argname="argument encoder_profile", value=encoder_profile, expected_type=type_hints["encoder_profile"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "compression_factor": compression_factor,
+            }
+            if encoder_profile is not None:
+                self._values["encoder_profile"] = encoder_profile
+
+        @builtins.property
+        def compression_factor(self) -> jsii.Number:
+            '''A value that is used to calculate compression for an output.
+
+            The bitrate of the output is calculated as follows:
+
+            Output bitrate = (1 / compressionFactor) * (source bitrate)
+
+            This property only applies to outputs that use the ST 2110 JPEG XS protocol, with a flow source that uses the CDI protocol. Valid values are in the range of 3.0 to 10.0, inclusive.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flowoutput-encodingparameters.html#cfn-mediaconnect-flowoutput-encodingparameters-compressionfactor
+            '''
+            result = self._values.get("compression_factor")
+            assert result is not None, "Required property 'compression_factor' is missing"
+            return typing.cast(jsii.Number, result)
+
+        @builtins.property
+        def encoder_profile(self) -> typing.Optional[builtins.str]:
+            '''A setting on the encoder that drives compression settings.
+
+            This property only applies to video media streams associated with outputs that use the ST 2110 JPEG XS protocol, with a flow source that uses the CDI protocol.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flowoutput-encodingparameters.html#cfn-mediaconnect-flowoutput-encodingparameters-encoderprofile
+            '''
+            result = self._values.get("encoder_profile")
+            return typing.cast(typing.Optional[builtins.str], 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)
 
-    @vpc_interface_attachment.setter
-    def vpc_interface_attachment(
-        self,
-        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnFlowOutput.VpcInterfaceAttachmentProperty"]],
-    ) -> None:
-        if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__65a3e058407bcf8bd6fa065c9fd3cd66a1c54e7edb3b48af25c7893fd72db21d)
-            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "vpcInterfaceAttachment", value)
+        def __repr__(self) -> str:
+            return "EncodingParametersProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
 
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_mediaconnect.CfnFlowOutput.EncryptionProperty",
@@ -4563,6 +5838,191 @@ class CfnFlowOutput(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_mediaconnect.CfnFlowOutput.InterfaceProperty",
+        jsii_struct_bases=[],
+        name_mapping={"name": "name"},
+    )
+    class InterfaceProperty:
+        def __init__(self, *, name: builtins.str) -> None:
+            '''The VPC interface that you want to use for the media stream associated with the output.
+
+            :param name: The name of the VPC interface that you want to use for the media stream associated with the output.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flowoutput-interface.html
+            :exampleMetadata: fixture=_generated
+
+            Example::
+
+                # The code below shows an example of how to instantiate this type.
+                # The values are placeholders you should change.
+                from aws_cdk import aws_mediaconnect as mediaconnect
+                
+                interface_property = mediaconnect.CfnFlowOutput.InterfaceProperty(
+                    name="name"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__5cc7770548eb391a3e7796f01956da0a9add137c57ab671911bb6c1a675e3dcd)
+                check_type(argname="argument name", value=name, expected_type=type_hints["name"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "name": name,
+            }
+
+        @builtins.property
+        def name(self) -> builtins.str:
+            '''The name of the VPC interface that you want to use for the media stream associated with the output.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flowoutput-interface.html#cfn-mediaconnect-flowoutput-interface-name
+            '''
+            result = self._values.get("name")
+            assert result is not None, "Required property 'name' is missing"
+            return typing.cast(builtins.str, 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 "InterfaceProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_mediaconnect.CfnFlowOutput.MediaStreamOutputConfigurationProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "encoding_name": "encodingName",
+            "media_stream_name": "mediaStreamName",
+            "destination_configurations": "destinationConfigurations",
+            "encoding_parameters": "encodingParameters",
+        },
+    )
+    class MediaStreamOutputConfigurationProperty:
+        def __init__(
+            self,
+            *,
+            encoding_name: builtins.str,
+            media_stream_name: builtins.str,
+            destination_configurations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnFlowOutput.DestinationConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
+            encoding_parameters: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnFlowOutput.EncodingParametersProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+        ) -> None:
+            '''The media stream that is associated with the output, and the parameters for that association.
+
+            :param encoding_name: The format that will be used to encode the data. For ancillary data streams, set the encoding name to ``smpte291`` . For audio streams, set the encoding name to ``pcm`` . For video streams on sources or outputs that use the CDI protocol, set the encoding name to ``raw`` . For video streams on sources or outputs that use the ST 2110 JPEG XS protocol, set the encoding name to ``jxsv`` .
+            :param media_stream_name: A name that helps you distinguish one media stream from another.
+            :param destination_configurations: The media streams that you want to associate with the output.
+            :param encoding_parameters: A collection of parameters that determine how MediaConnect will convert the content. These fields only apply to outputs on flows that have a CDI source.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flowoutput-mediastreamoutputconfiguration.html
+            :exampleMetadata: fixture=_generated
+
+            Example::
+
+                # The code below shows an example of how to instantiate this type.
+                # The values are placeholders you should change.
+                from aws_cdk import aws_mediaconnect as mediaconnect
+                
+                media_stream_output_configuration_property = mediaconnect.CfnFlowOutput.MediaStreamOutputConfigurationProperty(
+                    encoding_name="encodingName",
+                    media_stream_name="mediaStreamName",
+                
+                    # the properties below are optional
+                    destination_configurations=[mediaconnect.CfnFlowOutput.DestinationConfigurationProperty(
+                        destination_ip="destinationIp",
+                        destination_port=123,
+                        interface=mediaconnect.CfnFlowOutput.InterfaceProperty(
+                            name="name"
+                        )
+                    )],
+                    encoding_parameters=mediaconnect.CfnFlowOutput.EncodingParametersProperty(
+                        compression_factor=123,
+                
+                        # the properties below are optional
+                        encoder_profile="encoderProfile"
+                    )
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__faa5e437983e66807a96f2eedebbdd774906faf99c35e9c25ec0ff0f66c49af3)
+                check_type(argname="argument encoding_name", value=encoding_name, expected_type=type_hints["encoding_name"])
+                check_type(argname="argument media_stream_name", value=media_stream_name, expected_type=type_hints["media_stream_name"])
+                check_type(argname="argument destination_configurations", value=destination_configurations, expected_type=type_hints["destination_configurations"])
+                check_type(argname="argument encoding_parameters", value=encoding_parameters, expected_type=type_hints["encoding_parameters"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "encoding_name": encoding_name,
+                "media_stream_name": media_stream_name,
+            }
+            if destination_configurations is not None:
+                self._values["destination_configurations"] = destination_configurations
+            if encoding_parameters is not None:
+                self._values["encoding_parameters"] = encoding_parameters
+
+        @builtins.property
+        def encoding_name(self) -> builtins.str:
+            '''The format that will be used to encode the data.
+
+            For ancillary data streams, set the encoding name to ``smpte291`` .
+
+            For audio streams, set the encoding name to ``pcm`` .
+
+            For video streams on sources or outputs that use the CDI protocol, set the encoding name to ``raw`` .
+
+            For video streams on sources or outputs that use the ST 2110 JPEG XS protocol, set the encoding name to ``jxsv`` .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flowoutput-mediastreamoutputconfiguration.html#cfn-mediaconnect-flowoutput-mediastreamoutputconfiguration-encodingname
+            '''
+            result = self._values.get("encoding_name")
+            assert result is not None, "Required property 'encoding_name' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def media_stream_name(self) -> builtins.str:
+            '''A name that helps you distinguish one media stream from another.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flowoutput-mediastreamoutputconfiguration.html#cfn-mediaconnect-flowoutput-mediastreamoutputconfiguration-mediastreamname
+            '''
+            result = self._values.get("media_stream_name")
+            assert result is not None, "Required property 'media_stream_name' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def destination_configurations(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnFlowOutput.DestinationConfigurationProperty"]]]]:
+            '''The media streams that you want to associate with the output.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flowoutput-mediastreamoutputconfiguration.html#cfn-mediaconnect-flowoutput-mediastreamoutputconfiguration-destinationconfigurations
+            '''
+            result = self._values.get("destination_configurations")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnFlowOutput.DestinationConfigurationProperty"]]]], result)
+
+        @builtins.property
+        def encoding_parameters(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnFlowOutput.EncodingParametersProperty"]]:
+            '''A collection of parameters that determine how MediaConnect will convert the content.
+
+            These fields only apply to outputs on flows that have a CDI source.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-mediaconnect-flowoutput-mediastreamoutputconfiguration.html#cfn-mediaconnect-flowoutput-mediastreamoutputconfiguration-encodingparameters
+            '''
+            result = self._values.get("encoding_parameters")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnFlowOutput.EncodingParametersProperty"]], 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 "MediaStreamOutputConfigurationProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_mediaconnect.CfnFlowOutput.VpcInterfaceAttachmentProperty",
         jsii_struct_bases=[],
@@ -4630,6 +6090,7 @@ class CfnFlowOutput(
         "destination": "destination",
         "encryption": "encryption",
         "max_latency": "maxLatency",
+        "media_stream_output_configurations": "mediaStreamOutputConfigurations",
         "min_latency": "minLatency",
         "name": "name",
         "port": "port",
@@ -4650,6 +6111,7 @@ class CfnFlowOutputProps:
         destination: typing.Optional[builtins.str] = None,
         encryption: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlowOutput.EncryptionProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
         max_latency: typing.Optional[jsii.Number] = None,
+        media_stream_output_configurations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlowOutput.MediaStreamOutputConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
         min_latency: typing.Optional[jsii.Number] = None,
         name: typing.Optional[builtins.str] = None,
         port: typing.Optional[jsii.Number] = None,
@@ -4667,6 +6129,7 @@ class CfnFlowOutputProps:
         :param destination: The IP address where you want to send the output.
         :param encryption: The encryption credentials that you want to use for the output.
         :param max_latency: The maximum latency in milliseconds. This parameter applies only to RIST-based, Zixi-based, and Fujitsu-based streams.
+        :param media_stream_output_configurations: The definition for each media stream that is associated with the output.
         :param min_latency: The minimum latency in milliseconds for SRT-based streams. In streams that use the SRT protocol, this value that you set on your MediaConnect source or output represents the minimal potential latency of that connection. The latency of the stream is set to the highest number between the sender’s minimum latency and the receiver’s minimum latency.
         :param name: The name of the output. This value must be unique within the current flow.
         :param port: The port to use when MediaConnect distributes content to the output.
@@ -4701,6 +6164,25 @@ class CfnFlowOutputProps:
                     key_type="keyType"
                 ),
                 max_latency=123,
+                media_stream_output_configurations=[mediaconnect.CfnFlowOutput.MediaStreamOutputConfigurationProperty(
+                    encoding_name="encodingName",
+                    media_stream_name="mediaStreamName",
+            
+                    # the properties below are optional
+                    destination_configurations=[mediaconnect.CfnFlowOutput.DestinationConfigurationProperty(
+                        destination_ip="destinationIp",
+                        destination_port=123,
+                        interface=mediaconnect.CfnFlowOutput.InterfaceProperty(
+                            name="name"
+                        )
+                    )],
+                    encoding_parameters=mediaconnect.CfnFlowOutput.EncodingParametersProperty(
+                        compression_factor=123,
+            
+                        # the properties below are optional
+                        encoder_profile="encoderProfile"
+                    )
+                )],
                 min_latency=123,
                 name="name",
                 port=123,
@@ -4721,6 +6203,7 @@ class CfnFlowOutputProps:
             check_type(argname="argument destination", value=destination, expected_type=type_hints["destination"])
             check_type(argname="argument encryption", value=encryption, expected_type=type_hints["encryption"])
             check_type(argname="argument max_latency", value=max_latency, expected_type=type_hints["max_latency"])
+            check_type(argname="argument media_stream_output_configurations", value=media_stream_output_configurations, expected_type=type_hints["media_stream_output_configurations"])
             check_type(argname="argument min_latency", value=min_latency, expected_type=type_hints["min_latency"])
             check_type(argname="argument name", value=name, expected_type=type_hints["name"])
             check_type(argname="argument port", value=port, expected_type=type_hints["port"])
@@ -4742,6 +6225,8 @@ class CfnFlowOutputProps:
             self._values["encryption"] = encryption
         if max_latency is not None:
             self._values["max_latency"] = max_latency
+        if media_stream_output_configurations is not None:
+            self._values["media_stream_output_configurations"] = media_stream_output_configurations
         if min_latency is not None:
             self._values["min_latency"] = min_latency
         if name is not None:
@@ -4830,6 +6315,17 @@ class CfnFlowOutputProps:
         result = self._values.get("max_latency")
         return typing.cast(typing.Optional[jsii.Number], result)
 
+    @builtins.property
+    def media_stream_output_configurations(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnFlowOutput.MediaStreamOutputConfigurationProperty]]]]:
+        '''The definition for each media stream that is associated with the output.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-mediaconnect-flowoutput.html#cfn-mediaconnect-flowoutput-mediastreamoutputconfigurations
+        '''
+        result = self._values.get("media_stream_output_configurations")
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnFlowOutput.MediaStreamOutputConfigurationProperty]]]], result)
+
     @builtins.property
     def min_latency(self) -> typing.Optional[jsii.Number]:
         '''The minimum latency in milliseconds for SRT-based streams.
@@ -4922,7 +6418,10 @@ class CfnFlowOutputProps:
         "name": "name",
         "source": "source",
         "availability_zone": "availabilityZone",
+        "maintenance": "maintenance",
+        "media_streams": "mediaStreams",
         "source_failover_config": "sourceFailoverConfig",
+        "vpc_interfaces": "vpcInterfaces",
     },
 )
 class CfnFlowProps:
@@ -4932,14 +6431,20 @@ class CfnFlowProps:
         name: builtins.str,
         source: typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlow.SourceProperty, typing.Dict[builtins.str, typing.Any]]],
         availability_zone: typing.Optional[builtins.str] = None,
+        maintenance: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlow.MaintenanceProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+        media_streams: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlow.MediaStreamProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
         source_failover_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlow.FailoverConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+        vpc_interfaces: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlow.VpcInterfaceProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     ) -> None:
         '''Properties for defining a ``CfnFlow``.
 
         :param name: The name of the flow.
         :param source: The settings for the source that you want to use for the new flow.
         :param availability_zone: The Availability Zone that you want to create the flow in. These options are limited to the Availability Zones within the current AWS Region.
+        :param maintenance: The maintenance settings you want to use for the flow.
+        :param media_streams: The media streams associated with the flow. You can associate any of these media streams with sources and outputs on the flow.
         :param source_failover_config: The settings for source failover.
+        :param vpc_interfaces: The VPC interfaces that you added to this flow.
 
         :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-mediaconnect-flow.html
         :exampleMetadata: fixture=_generated
@@ -4980,6 +6485,19 @@ class CfnFlowProps:
                     ingest_port=123,
                     max_bitrate=123,
                     max_latency=123,
+                    max_sync_buffer=123,
+                    media_stream_source_configurations=[mediaconnect.CfnFlow.MediaStreamSourceConfigurationProperty(
+                        encoding_name="encodingName",
+                        media_stream_name="mediaStreamName",
+            
+                        # the properties below are optional
+                        input_configurations=[mediaconnect.CfnFlow.InputConfigurationProperty(
+                            input_port=123,
+                            interface=mediaconnect.CfnFlow.InterfaceProperty(
+                                name="name"
+                            )
+                        )]
+                    )],
                     min_latency=123,
                     name="name",
                     protocol="protocol",
@@ -4996,6 +6514,33 @@ class CfnFlowProps:
             
                 # the properties below are optional
                 availability_zone="availabilityZone",
+                maintenance=mediaconnect.CfnFlow.MaintenanceProperty(
+                    maintenance_day="maintenanceDay",
+                    maintenance_start_hour="maintenanceStartHour"
+                ),
+                media_streams=[mediaconnect.CfnFlow.MediaStreamProperty(
+                    media_stream_id=123,
+                    media_stream_name="mediaStreamName",
+                    media_stream_type="mediaStreamType",
+            
+                    # the properties below are optional
+                    attributes=mediaconnect.CfnFlow.MediaStreamAttributesProperty(
+                        fmtp=mediaconnect.CfnFlow.FmtpProperty(
+                            channel_order="channelOrder",
+                            colorimetry="colorimetry",
+                            exact_framerate="exactFramerate",
+                            par="par",
+                            range="range",
+                            scan_mode="scanMode",
+                            tcs="tcs"
+                        ),
+                        lang="lang"
+                    ),
+                    clock_rate=123,
+                    description="description",
+                    fmt=123,
+                    video_format="videoFormat"
+                )],
                 source_failover_config=mediaconnect.CfnFlow.FailoverConfigProperty(
                     failover_mode="failoverMode",
                     recovery_window=123,
@@ -5003,7 +6548,17 @@ class CfnFlowProps:
                         primary_source="primarySource"
                     ),
                     state="state"
-                )
+                ),
+                vpc_interfaces=[mediaconnect.CfnFlow.VpcInterfaceProperty(
+                    name="name",
+                    role_arn="roleArn",
+                    security_group_ids=["securityGroupIds"],
+                    subnet_id="subnetId",
+            
+                    # the properties below are optional
+                    network_interface_ids=["networkInterfaceIds"],
+                    network_interface_type="networkInterfaceType"
+                )]
             )
         '''
         if __debug__:
@@ -5011,15 +6566,24 @@ class CfnFlowProps:
             check_type(argname="argument name", value=name, expected_type=type_hints["name"])
             check_type(argname="argument source", value=source, expected_type=type_hints["source"])
             check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
+            check_type(argname="argument maintenance", value=maintenance, expected_type=type_hints["maintenance"])
+            check_type(argname="argument media_streams", value=media_streams, expected_type=type_hints["media_streams"])
             check_type(argname="argument source_failover_config", value=source_failover_config, expected_type=type_hints["source_failover_config"])
+            check_type(argname="argument vpc_interfaces", value=vpc_interfaces, expected_type=type_hints["vpc_interfaces"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "name": name,
             "source": source,
         }
         if availability_zone is not None:
             self._values["availability_zone"] = availability_zone
+        if maintenance is not None:
+            self._values["maintenance"] = maintenance
+        if media_streams is not None:
+            self._values["media_streams"] = media_streams
         if source_failover_config is not None:
             self._values["source_failover_config"] = source_failover_config
+        if vpc_interfaces is not None:
+            self._values["vpc_interfaces"] = vpc_interfaces
 
     @builtins.property
     def name(self) -> builtins.str:
@@ -5052,6 +6616,30 @@ class CfnFlowProps:
         result = self._values.get("availability_zone")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def maintenance(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnFlow.MaintenanceProperty]]:
+        '''The maintenance settings you want to use for the flow.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-mediaconnect-flow.html#cfn-mediaconnect-flow-maintenance
+        '''
+        result = self._values.get("maintenance")
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnFlow.MaintenanceProperty]], result)
+
+    @builtins.property
+    def media_streams(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnFlow.MediaStreamProperty]]]]:
+        '''The media streams associated with the flow.
+
+        You can associate any of these media streams with sources and outputs on the flow.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-mediaconnect-flow.html#cfn-mediaconnect-flow-mediastreams
+        '''
+        result = self._values.get("media_streams")
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnFlow.MediaStreamProperty]]]], result)
+
     @builtins.property
     def source_failover_config(
         self,
@@ -5063,6 +6651,17 @@ class CfnFlowProps:
         result = self._values.get("source_failover_config")
         return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnFlow.FailoverConfigProperty]], result)
 
+    @builtins.property
+    def vpc_interfaces(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnFlow.VpcInterfaceProperty]]]]:
+        '''The VPC interfaces that you added to this flow.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-mediaconnect-flow.html#cfn-mediaconnect-flow-vpcinterfaces
+        '''
+        result = self._values.get("vpc_interfaces")
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnFlow.VpcInterfaceProperty]]]], result)
+
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -6255,6 +7854,10 @@ class CfnFlowVpcInterface(
     - Use CloudFormation to create a VPC interface to add to this flow. This can also be done as part of the previous step.
     - After CloudFormation has created the flow and the VPC interface, update the source to point to the VPC interface that you created.
 
+    .. epigraph::
+
+       The previous steps must be undone before the CloudFormation stack can be deleted. Because the source is manually updated in step 3, CloudFormation is not aware of this change. The source must be returned to a standard source before CloudFormation stack deletion.
+
     :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-mediaconnect-flowvpcinterface.html
     :cloudformationResource: AWS::MediaConnect::FlowVpcInterface
     :exampleMetadata: fixture=_generated
@@ -7216,7 +8819,10 @@ def _typecheckingstub__3568a95be2a886825b3db731f10e2fdea8be142c554d1e2055d7e22f5
     name: builtins.str,
     source: typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlow.SourceProperty, typing.Dict[builtins.str, typing.Any]]],
     availability_zone: typing.Optional[builtins.str] = None,
+    maintenance: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlow.MaintenanceProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    media_streams: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlow.MediaStreamProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     source_failover_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlow.FailoverConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    vpc_interfaces: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlow.VpcInterfaceProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -7251,12 +8857,30 @@ def _typecheckingstub__843065332a6d7586586605a6ec8a2bd932a36dd6774052d60e5f9fd8e
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__ddd188e9c2d5f8f194cf0b4c16e8b355b0ebcec43d953e6b0c8b77128e640aab(
+    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnFlow.MaintenanceProperty]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__c580931c160d15b8c0f43f0fe96dc390b640ae81cbc1900b00f369aaa3c3f6e4(
+    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnFlow.MediaStreamProperty]]]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__9d7deae7edf526ef9a6af2e16b592ef198ecb0cc777d1c7d97f392933ad97ef6(
     value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnFlow.FailoverConfigProperty]],
 ) -> None:
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__7e75424871a1b67422fa8fe727bf0720abe8ea217c131244844ca71d14e25f4d(
+    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnFlow.VpcInterfaceProperty]]]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__023b62e8b380bcfa878c2a07568bc0d0f9912919827c329972ee2130250892b3(
     *,
     role_arn: builtins.str,
@@ -7282,6 +8906,19 @@ def _typecheckingstub__60d936fe41cb44293e591fd7a9b89da19bc9fc2509d0dacf4ad7a22a5
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__2c34da6d27a4d46f87384739bd6ec7bcc9bf7866bb051703aa63a4b21e8b38dc(
+    *,
+    channel_order: typing.Optional[builtins.str] = None,
+    colorimetry: typing.Optional[builtins.str] = None,
+    exact_framerate: typing.Optional[builtins.str] = None,
+    par: typing.Optional[builtins.str] = None,
+    range: typing.Optional[builtins.str] = None,
+    scan_mode: typing.Optional[builtins.str] = None,
+    tcs: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__00bf15dc37f493c33d6b2109cfa6283d2bb14bdc23b0ae4fd75a67ca60084ea8(
     *,
     bridge_arn: builtins.str,
@@ -7290,6 +8927,60 @@ def _typecheckingstub__00bf15dc37f493c33d6b2109cfa6283d2bb14bdc23b0ae4fd75a67ca6
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__fbb4a04e87ed2fedc67d03bbbab23670facee0c55014d0c5d234881ded41ec58(
+    *,
+    input_port: jsii.Number,
+    interface: typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlow.InterfaceProperty, typing.Dict[builtins.str, typing.Any]]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__0ca0a6498a5e542f31081d78420cae2b37457c94dbd68dcead2dc4af50843b27(
+    *,
+    name: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__57efc1d88b4fa5a6e6df4c17678237b4420bf63b5cd14e340198e67ed5a1ee60(
+    *,
+    maintenance_day: builtins.str,
+    maintenance_start_hour: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__98c9c952274e74dd38a0129bccf9e3c8688c812151f95c826ce99e20158cfe87(
+    *,
+    fmtp: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlow.FmtpProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    lang: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__bc935e241ba7a00b3f70633b9ca54a5bca516c17065e6c6d8eeb7ab2523359be(
+    *,
+    media_stream_id: jsii.Number,
+    media_stream_name: builtins.str,
+    media_stream_type: builtins.str,
+    attributes: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlow.MediaStreamAttributesProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    clock_rate: typing.Optional[jsii.Number] = None,
+    description: typing.Optional[builtins.str] = None,
+    fmt: typing.Optional[jsii.Number] = None,
+    video_format: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__c288224888dcd985ea78c20d06801a00405d4260bf960e8dbcac65f3e669aa4f(
+    *,
+    encoding_name: builtins.str,
+    media_stream_name: builtins.str,
+    input_configurations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlow.InputConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__a502d8c706596e3abd881dc963357d969893e22e8d25e78085445e09c58ac78b(
     *,
     primary_source: builtins.str,
@@ -7307,6 +8998,8 @@ def _typecheckingstub__0c35ebd36bb52715c021bc299f222a377254ec8a3bd90d9c933fbefca
     ingest_port: typing.Optional[jsii.Number] = None,
     max_bitrate: typing.Optional[jsii.Number] = None,
     max_latency: typing.Optional[jsii.Number] = None,
+    max_sync_buffer: typing.Optional[jsii.Number] = None,
+    media_stream_source_configurations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlow.MediaStreamSourceConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     min_latency: typing.Optional[jsii.Number] = None,
     name: typing.Optional[builtins.str] = None,
     protocol: typing.Optional[builtins.str] = None,
@@ -7330,6 +9023,18 @@ def _typecheckingstub__866ca963188936c1dd8965fb722dc7f781261eab36e78ecdb20a9d41b
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__d976d1dab1b395c0026dcc2152c4dd635ae54d817a1f10c4d8f2725ac4862ad4(
+    *,
+    name: builtins.str,
+    role_arn: builtins.str,
+    security_group_ids: typing.Sequence[builtins.str],
+    subnet_id: builtins.str,
+    network_interface_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
+    network_interface_type: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__17ecd85086df3a96cb74577c3e3a831ea91a89b617bcd18f7684fd357569ebd4(
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
@@ -7438,6 +9143,7 @@ def _typecheckingstub__50a855342b002f2aaf180af2a85e45ce23346b4a5b582c00ee1a8474e
     destination: typing.Optional[builtins.str] = None,
     encryption: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlowOutput.EncryptionProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     max_latency: typing.Optional[jsii.Number] = None,
+    media_stream_output_configurations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlowOutput.MediaStreamOutputConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     min_latency: typing.Optional[jsii.Number] = None,
     name: typing.Optional[builtins.str] = None,
     port: typing.Optional[jsii.Number] = None,
@@ -7503,6 +9209,12 @@ def _typecheckingstub__9801fdc6b598fc4f2e913edc8984f374a7594553b0a1ef32ea0fa7be0
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__c99ca24b6208e72328e18819b003e97cbf14fb0f94304256c59924c6e02ae32d(
+    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnFlowOutput.MediaStreamOutputConfigurationProperty]]]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__ddb7401a37f3ff6ff7dc25a56db1a28806074c96fc3f42a6bd90cc4feab9b693(
     value: typing.Optional[jsii.Number],
 ) -> None:
@@ -7545,6 +9257,23 @@ def _typecheckingstub__65a3e058407bcf8bd6fa065c9fd3cd66a1c54e7edb3b48af25c7893fd
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__8b62fc10e1fb76cee67ab63dde918a0006c11ce38e8af823e4d2f2770e4d5765(
+    *,
+    destination_ip: builtins.str,
+    destination_port: jsii.Number,
+    interface: typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlowOutput.InterfaceProperty, typing.Dict[builtins.str, typing.Any]]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__d7e858c0a050e7b9bf4f84c7f6034ad1cf704a2a9a2b07a5b472d598f1b62d5f(
+    *,
+    compression_factor: jsii.Number,
+    encoder_profile: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__12ea6e5693abf5b0e777cf50bd86212ef7db4809c0713169b65c0d055bed2f19(
     *,
     role_arn: builtins.str,
@@ -7555,6 +9284,23 @@ def _typecheckingstub__12ea6e5693abf5b0e777cf50bd86212ef7db4809c0713169b65c0d055
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__5cc7770548eb391a3e7796f01956da0a9add137c57ab671911bb6c1a675e3dcd(
+    *,
+    name: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__faa5e437983e66807a96f2eedebbdd774906faf99c35e9c25ec0ff0f66c49af3(
+    *,
+    encoding_name: builtins.str,
+    media_stream_name: builtins.str,
+    destination_configurations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlowOutput.DestinationConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+    encoding_parameters: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlowOutput.EncodingParametersProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__7072f99adeda4341a6581cacf2975b777cc5b063364d5416156250ca7f1e5619(
     *,
     vpc_interface_name: typing.Optional[builtins.str] = None,
@@ -7571,6 +9317,7 @@ def _typecheckingstub__90cee4cbdefa91956af92950bb2bfd2da4fa4f982f439596444cda525
     destination: typing.Optional[builtins.str] = None,
     encryption: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlowOutput.EncryptionProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     max_latency: typing.Optional[jsii.Number] = None,
+    media_stream_output_configurations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlowOutput.MediaStreamOutputConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     min_latency: typing.Optional[jsii.Number] = None,
     name: typing.Optional[builtins.str] = None,
     port: typing.Optional[jsii.Number] = None,
@@ -7587,7 +9334,10 @@ def _typecheckingstub__32a16a7697723a7ef816aaa9d297ca08cd44085f922995184f8bfdfde
     name: builtins.str,
     source: typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlow.SourceProperty, typing.Dict[builtins.str, typing.Any]]],
     availability_zone: typing.Optional[builtins.str] = None,
+    maintenance: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlow.MaintenanceProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    media_streams: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlow.MediaStreamProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     source_failover_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlow.FailoverConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    vpc_interfaces: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFlow.VpcInterfaceProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
 ) -> None:
     """Type checking stubs"""
     pass