pulumi-aws-native 1.38.0a1761284362__py3-none-any.whl → 1.39.0a1762409198__py3-none-any.whl

pulumi_aws_native/mediapackagev2/_enums.py

@@ -21,6 +21,8 @@ __all__ = [
     'OriginEndpointDashUtcTimingMode',
     'OriginEndpointDrmSystem',
     'OriginEndpointEndpointErrorCondition',
+    'OriginEndpointIsmEncryptionMethod',
+    'OriginEndpointMssManifestLayout',
     'OriginEndpointPresetSpeke20Audio',
     'OriginEndpointPresetSpeke20Video',
     'OriginEndpointScteFilter',
@@ -43,6 +45,7 @@ class OriginEndpointAdMarkerDash(_builtins.str, Enum):
 @pulumi.type_token("aws-native:mediapackagev2:OriginEndpointAdMarkerHls")
 class OriginEndpointAdMarkerHls(_builtins.str, Enum):
     DATERANGE = "DATERANGE"
+    SCTE35_ENHANCED = "SCTE35_ENHANCED"
 
 
 @pulumi.type_token("aws-native:mediapackagev2:OriginEndpointCmafEncryptionMethod")
@@ -55,6 +58,7 @@ class OriginEndpointCmafEncryptionMethod(_builtins.str, Enum):
 class OriginEndpointContainerType(_builtins.str, Enum):
     TS = "TS"
     CMAF = "CMAF"
+    ISM = "ISM"
 
 
 @pulumi.type_token("aws-native:mediapackagev2:OriginEndpointDashCompactness")
@@ -119,6 +123,17 @@ class OriginEndpointEndpointErrorCondition(_builtins.str, Enum):
     SLATE_INPUT = "SLATE_INPUT"
 
 
+@pulumi.type_token("aws-native:mediapackagev2:OriginEndpointIsmEncryptionMethod")
+class OriginEndpointIsmEncryptionMethod(_builtins.str, Enum):
+    CENC = "CENC"
+
+
+@pulumi.type_token("aws-native:mediapackagev2:OriginEndpointMssManifestLayout")
+class OriginEndpointMssManifestLayout(_builtins.str, Enum):
+    FULL = "FULL"
+    COMPACT = "COMPACT"
+
+
 @pulumi.type_token("aws-native:mediapackagev2:OriginEndpointPresetSpeke20Audio")
 class OriginEndpointPresetSpeke20Audio(_builtins.str, Enum):
     PRESET_AUDIO1 = "PRESET_AUDIO_1"

pulumi_aws_native/mediapackagev2/_inputs.py

@@ -52,6 +52,8 @@ __all__ = [
     'OriginEndpointHlsManifestConfigurationArgsDict',
     'OriginEndpointLowLatencyHlsManifestConfigurationArgs',
     'OriginEndpointLowLatencyHlsManifestConfigurationArgsDict',
+    'OriginEndpointMssManifestConfigurationArgs',
+    'OriginEndpointMssManifestConfigurationArgsDict',
     'OriginEndpointPolicyCdnAuthConfigurationArgs',
     'OriginEndpointPolicyCdnAuthConfigurationArgsDict',
     'OriginEndpointScteDashArgs',
@@ -1192,6 +1194,10 @@ if not MYPY:
         """
         The encryption method to use.
         """
+        ism_encryption_method: NotRequired[pulumi.Input['OriginEndpointIsmEncryptionMethod']]
+        """
+        The encryption method used for Microsoft Smooth Streaming (MSS) content. This specifies how the MSS segments are encrypted to protect the content during delivery to client players.
+        """
         ts_encryption_method: NotRequired[pulumi.Input['OriginEndpointTsEncryptionMethod']]
         """
         The encryption method to use.
@@ -1203,14 +1209,18 @@ elif False:
 class OriginEndpointEncryptionMethodArgs:
     def __init__(__self__, *,
                  cmaf_encryption_method: Optional[pulumi.Input['OriginEndpointCmafEncryptionMethod']] = None,
+                 ism_encryption_method: Optional[pulumi.Input['OriginEndpointIsmEncryptionMethod']] = None,
                  ts_encryption_method: Optional[pulumi.Input['OriginEndpointTsEncryptionMethod']] = None):
         """
         <p>The encryption type.</p>
         :param pulumi.Input['OriginEndpointCmafEncryptionMethod'] cmaf_encryption_method: The encryption method to use.
+        :param pulumi.Input['OriginEndpointIsmEncryptionMethod'] ism_encryption_method: The encryption method used for Microsoft Smooth Streaming (MSS) content. This specifies how the MSS segments are encrypted to protect the content during delivery to client players.
         :param pulumi.Input['OriginEndpointTsEncryptionMethod'] ts_encryption_method: The encryption method to use.
         """
         if cmaf_encryption_method is not None:
             pulumi.set(__self__, "cmaf_encryption_method", cmaf_encryption_method)
+        if ism_encryption_method is not None:
+            pulumi.set(__self__, "ism_encryption_method", ism_encryption_method)
         if ts_encryption_method is not None:
             pulumi.set(__self__, "ts_encryption_method", ts_encryption_method)
 
@@ -1226,6 +1236,18 @@ class OriginEndpointEncryptionMethodArgs:
     def cmaf_encryption_method(self, value: Optional[pulumi.Input['OriginEndpointCmafEncryptionMethod']]):
         pulumi.set(self, "cmaf_encryption_method", value)
 
+    @_builtins.property
+    @pulumi.getter(name="ismEncryptionMethod")
+    def ism_encryption_method(self) -> Optional[pulumi.Input['OriginEndpointIsmEncryptionMethod']]:
+        """
+        The encryption method used for Microsoft Smooth Streaming (MSS) content. This specifies how the MSS segments are encrypted to protect the content during delivery to client players.
+        """
+        return pulumi.get(self, "ism_encryption_method")
+
+    @ism_encryption_method.setter
+    def ism_encryption_method(self, value: Optional[pulumi.Input['OriginEndpointIsmEncryptionMethod']]):
+        pulumi.set(self, "ism_encryption_method", value)
+
     @_builtins.property
     @pulumi.getter(name="tsEncryptionMethod")
     def ts_encryption_method(self) -> Optional[pulumi.Input['OriginEndpointTsEncryptionMethod']]:
@@ -1895,6 +1917,87 @@ class OriginEndpointLowLatencyHlsManifestConfigurationArgs:
         pulumi.set(self, "url_encode_child_manifest", value)
 
 
+if not MYPY:
+    class OriginEndpointMssManifestConfigurationArgsDict(TypedDict):
+        """
+        <p>Configuration details for a Microsoft Smooth Streaming (MSS) manifest associated with an origin endpoint. This includes all the settings and properties that define how the MSS content is packaged and delivered.</p>
+        """
+        manifest_name: pulumi.Input[_builtins.str]
+        """
+        <p>The name of the MSS manifest. This name is appended to the origin endpoint URL to create the unique path for accessing this specific MSS manifest.</p>
+        """
+        filter_configuration: NotRequired[pulumi.Input['OriginEndpointFilterConfigurationArgsDict']]
+        manifest_layout: NotRequired[pulumi.Input['OriginEndpointMssManifestLayout']]
+        manifest_window_seconds: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        <p>The duration (in seconds) of the manifest window. This represents the total amount of content available in the manifest at any given time.</p>
+        """
+elif False:
+    OriginEndpointMssManifestConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class OriginEndpointMssManifestConfigurationArgs:
+    def __init__(__self__, *,
+                 manifest_name: pulumi.Input[_builtins.str],
+                 filter_configuration: Optional[pulumi.Input['OriginEndpointFilterConfigurationArgs']] = None,
+                 manifest_layout: Optional[pulumi.Input['OriginEndpointMssManifestLayout']] = None,
+                 manifest_window_seconds: Optional[pulumi.Input[_builtins.int]] = None):
+        """
+        <p>Configuration details for a Microsoft Smooth Streaming (MSS) manifest associated with an origin endpoint. This includes all the settings and properties that define how the MSS content is packaged and delivered.</p>
+        :param pulumi.Input[_builtins.str] manifest_name: <p>The name of the MSS manifest. This name is appended to the origin endpoint URL to create the unique path for accessing this specific MSS manifest.</p>
+        :param pulumi.Input[_builtins.int] manifest_window_seconds: <p>The duration (in seconds) of the manifest window. This represents the total amount of content available in the manifest at any given time.</p>
+        """
+        pulumi.set(__self__, "manifest_name", manifest_name)
+        if filter_configuration is not None:
+            pulumi.set(__self__, "filter_configuration", filter_configuration)
+        if manifest_layout is not None:
+            pulumi.set(__self__, "manifest_layout", manifest_layout)
+        if manifest_window_seconds is not None:
+            pulumi.set(__self__, "manifest_window_seconds", manifest_window_seconds)
+
+    @_builtins.property
+    @pulumi.getter(name="manifestName")
+    def manifest_name(self) -> pulumi.Input[_builtins.str]:
+        """
+        <p>The name of the MSS manifest. This name is appended to the origin endpoint URL to create the unique path for accessing this specific MSS manifest.</p>
+        """
+        return pulumi.get(self, "manifest_name")
+
+    @manifest_name.setter
+    def manifest_name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "manifest_name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="filterConfiguration")
+    def filter_configuration(self) -> Optional[pulumi.Input['OriginEndpointFilterConfigurationArgs']]:
+        return pulumi.get(self, "filter_configuration")
+
+    @filter_configuration.setter
+    def filter_configuration(self, value: Optional[pulumi.Input['OriginEndpointFilterConfigurationArgs']]):
+        pulumi.set(self, "filter_configuration", value)
+
+    @_builtins.property
+    @pulumi.getter(name="manifestLayout")
+    def manifest_layout(self) -> Optional[pulumi.Input['OriginEndpointMssManifestLayout']]:
+        return pulumi.get(self, "manifest_layout")
+
+    @manifest_layout.setter
+    def manifest_layout(self, value: Optional[pulumi.Input['OriginEndpointMssManifestLayout']]):
+        pulumi.set(self, "manifest_layout", value)
+
+    @_builtins.property
+    @pulumi.getter(name="manifestWindowSeconds")
+    def manifest_window_seconds(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        <p>The duration (in seconds) of the manifest window. This represents the total amount of content available in the manifest at any given time.</p>
+        """
+        return pulumi.get(self, "manifest_window_seconds")
+
+    @manifest_window_seconds.setter
+    def manifest_window_seconds(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "manifest_window_seconds", value)
+
+
 if not MYPY:
     class OriginEndpointPolicyCdnAuthConfigurationArgsDict(TypedDict):
         cdn_identifier_secret_arns: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]

pulumi_aws_native/mediapackagev2/get_origin_endpoint.py

@@ -26,7 +26,7 @@ __all__ = [
 
 @pulumi.output_type
 class GetOriginEndpointResult:
-    def __init__(__self__, arn=None, container_type=None, created_at=None, dash_manifest_urls=None, dash_manifests=None, description=None, force_endpoint_error_configuration=None, hls_manifest_urls=None, hls_manifests=None, low_latency_hls_manifest_urls=None, low_latency_hls_manifests=None, modified_at=None, segment=None, startover_window_seconds=None, tags=None):
+    def __init__(__self__, arn=None, container_type=None, created_at=None, dash_manifest_urls=None, dash_manifests=None, description=None, force_endpoint_error_configuration=None, hls_manifest_urls=None, hls_manifests=None, low_latency_hls_manifest_urls=None, low_latency_hls_manifests=None, modified_at=None, mss_manifest_urls=None, mss_manifests=None, segment=None, startover_window_seconds=None, tags=None):
         if arn and not isinstance(arn, str):
             raise TypeError("Expected argument 'arn' to be a str")
         pulumi.set(__self__, "arn", arn)
@@ -63,6 +63,12 @@ class GetOriginEndpointResult:
         if modified_at and not isinstance(modified_at, str):
             raise TypeError("Expected argument 'modified_at' to be a str")
         pulumi.set(__self__, "modified_at", modified_at)
+        if mss_manifest_urls and not isinstance(mss_manifest_urls, list):
+            raise TypeError("Expected argument 'mss_manifest_urls' to be a list")
+        pulumi.set(__self__, "mss_manifest_urls", mss_manifest_urls)
+        if mss_manifests and not isinstance(mss_manifests, list):
+            raise TypeError("Expected argument 'mss_manifests' to be a list")
+        pulumi.set(__self__, "mss_manifests", mss_manifests)
         if segment and not isinstance(segment, dict):
             raise TypeError("Expected argument 'segment' to be a dict")
         pulumi.set(__self__, "segment", segment)
@@ -169,6 +175,19 @@ class GetOriginEndpointResult:
         """
         return pulumi.get(self, "modified_at")
 
+    @_builtins.property
+    @pulumi.getter(name="mssManifestUrls")
+    def mss_manifest_urls(self) -> Optional[Sequence[_builtins.str]]:
+        return pulumi.get(self, "mss_manifest_urls")
+
+    @_builtins.property
+    @pulumi.getter(name="mssManifests")
+    def mss_manifests(self) -> Optional[Sequence['outputs.OriginEndpointMssManifestConfiguration']]:
+        """
+        <p>The Microsoft Smooth Streaming (MSS) manifest configurations associated with this origin endpoint.</p>
+        """
+        return pulumi.get(self, "mss_manifests")
+
     @_builtins.property
     @pulumi.getter
     def segment(self) -> Optional['outputs.OriginEndpointSegment']:
@@ -212,6 +231,8 @@ class AwaitableGetOriginEndpointResult(GetOriginEndpointResult):
             low_latency_hls_manifest_urls=self.low_latency_hls_manifest_urls,
             low_latency_hls_manifests=self.low_latency_hls_manifests,
             modified_at=self.modified_at,
+            mss_manifest_urls=self.mss_manifest_urls,
+            mss_manifests=self.mss_manifests,
             segment=self.segment,
             startover_window_seconds=self.startover_window_seconds,
             tags=self.tags)
@@ -243,6 +264,8 @@ def get_origin_endpoint(arn: Optional[_builtins.str] = None,
         low_latency_hls_manifest_urls=pulumi.get(__ret__, 'low_latency_hls_manifest_urls'),
         low_latency_hls_manifests=pulumi.get(__ret__, 'low_latency_hls_manifests'),
         modified_at=pulumi.get(__ret__, 'modified_at'),
+        mss_manifest_urls=pulumi.get(__ret__, 'mss_manifest_urls'),
+        mss_manifests=pulumi.get(__ret__, 'mss_manifests'),
         segment=pulumi.get(__ret__, 'segment'),
         startover_window_seconds=pulumi.get(__ret__, 'startover_window_seconds'),
         tags=pulumi.get(__ret__, 'tags'))
@@ -271,6 +294,8 @@ def get_origin_endpoint_output(arn: Optional[pulumi.Input[_builtins.str]] = None
         low_latency_hls_manifest_urls=pulumi.get(__response__, 'low_latency_hls_manifest_urls'),
         low_latency_hls_manifests=pulumi.get(__response__, 'low_latency_hls_manifests'),
         modified_at=pulumi.get(__response__, 'modified_at'),
+        mss_manifest_urls=pulumi.get(__response__, 'mss_manifest_urls'),
+        mss_manifests=pulumi.get(__response__, 'mss_manifests'),
         segment=pulumi.get(__response__, 'segment'),
         startover_window_seconds=pulumi.get(__response__, 'startover_window_seconds'),
         tags=pulumi.get(__response__, 'tags')))

pulumi_aws_native/mediapackagev2/origin_endpoint.py

@@ -32,6 +32,7 @@ class OriginEndpointArgs:
                  force_endpoint_error_configuration: Optional[pulumi.Input['OriginEndpointForceEndpointErrorConfigurationArgs']] = None,
                  hls_manifests: Optional[pulumi.Input[Sequence[pulumi.Input['OriginEndpointHlsManifestConfigurationArgs']]]] = None,
                  low_latency_hls_manifests: Optional[pulumi.Input[Sequence[pulumi.Input['OriginEndpointLowLatencyHlsManifestConfigurationArgs']]]] = None,
+                 mss_manifests: Optional[pulumi.Input[Sequence[pulumi.Input['OriginEndpointMssManifestConfigurationArgs']]]] = None,
                  origin_endpoint_name: Optional[pulumi.Input[_builtins.str]] = None,
                  segment: Optional[pulumi.Input['OriginEndpointSegmentArgs']] = None,
                  startover_window_seconds: Optional[pulumi.Input[_builtins.int]] = None,
@@ -46,6 +47,7 @@ class OriginEndpointArgs:
         :param pulumi.Input['OriginEndpointForceEndpointErrorConfigurationArgs'] force_endpoint_error_configuration: The failover settings for the endpoint.
         :param pulumi.Input[Sequence[pulumi.Input['OriginEndpointHlsManifestConfigurationArgs']]] hls_manifests: <p>An HTTP live streaming (HLS) manifest configuration.</p>
         :param pulumi.Input[Sequence[pulumi.Input['OriginEndpointLowLatencyHlsManifestConfigurationArgs']]] low_latency_hls_manifests: <p>A low-latency HLS manifest configuration.</p>
+        :param pulumi.Input[Sequence[pulumi.Input['OriginEndpointMssManifestConfigurationArgs']]] mss_manifests: <p>The Microsoft Smooth Streaming (MSS) manifest configurations associated with this origin endpoint.</p>
         :param pulumi.Input[_builtins.str] origin_endpoint_name: The name of the origin endpoint associated with the origin endpoint configuration.
         :param pulumi.Input['OriginEndpointSegmentArgs'] segment: The segment associated with the origin endpoint.
         :param pulumi.Input[_builtins.int] startover_window_seconds: <p>The size of the window (in seconds) to create a window of the live stream that's available for on-demand viewing. Viewers can start-over or catch-up on content that falls within the window. The maximum startover window is 1,209,600 seconds (14 days).</p>
@@ -64,6 +66,8 @@ class OriginEndpointArgs:
             pulumi.set(__self__, "hls_manifests", hls_manifests)
         if low_latency_hls_manifests is not None:
             pulumi.set(__self__, "low_latency_hls_manifests", low_latency_hls_manifests)
+        if mss_manifests is not None:
+            pulumi.set(__self__, "mss_manifests", mss_manifests)
         if origin_endpoint_name is not None:
             pulumi.set(__self__, "origin_endpoint_name", origin_endpoint_name)
         if segment is not None:
@@ -169,6 +173,18 @@ class OriginEndpointArgs:
     def low_latency_hls_manifests(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OriginEndpointLowLatencyHlsManifestConfigurationArgs']]]]):
         pulumi.set(self, "low_latency_hls_manifests", value)
 
+    @_builtins.property
+    @pulumi.getter(name="mssManifests")
+    def mss_manifests(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OriginEndpointMssManifestConfigurationArgs']]]]:
+        """
+        <p>The Microsoft Smooth Streaming (MSS) manifest configurations associated with this origin endpoint.</p>
+        """
+        return pulumi.get(self, "mss_manifests")
+
+    @mss_manifests.setter
+    def mss_manifests(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OriginEndpointMssManifestConfigurationArgs']]]]):
+        pulumi.set(self, "mss_manifests", value)
+
     @_builtins.property
     @pulumi.getter(name="originEndpointName")
     def origin_endpoint_name(self) -> Optional[pulumi.Input[_builtins.str]]:
@@ -232,6 +248,7 @@ class OriginEndpoint(pulumi.CustomResource):
                  force_endpoint_error_configuration: Optional[pulumi.Input[Union['OriginEndpointForceEndpointErrorConfigurationArgs', 'OriginEndpointForceEndpointErrorConfigurationArgsDict']]] = None,
                  hls_manifests: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OriginEndpointHlsManifestConfigurationArgs', 'OriginEndpointHlsManifestConfigurationArgsDict']]]]] = None,
                  low_latency_hls_manifests: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OriginEndpointLowLatencyHlsManifestConfigurationArgs', 'OriginEndpointLowLatencyHlsManifestConfigurationArgsDict']]]]] = None,
+                 mss_manifests: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OriginEndpointMssManifestConfigurationArgs', 'OriginEndpointMssManifestConfigurationArgsDict']]]]] = None,
                  origin_endpoint_name: Optional[pulumi.Input[_builtins.str]] = None,
                  segment: Optional[pulumi.Input[Union['OriginEndpointSegmentArgs', 'OriginEndpointSegmentArgsDict']]] = None,
                  startover_window_seconds: Optional[pulumi.Input[_builtins.int]] = None,
@@ -250,6 +267,7 @@ class OriginEndpoint(pulumi.CustomResource):
         :param pulumi.Input[Union['OriginEndpointForceEndpointErrorConfigurationArgs', 'OriginEndpointForceEndpointErrorConfigurationArgsDict']] force_endpoint_error_configuration: The failover settings for the endpoint.
         :param pulumi.Input[Sequence[pulumi.Input[Union['OriginEndpointHlsManifestConfigurationArgs', 'OriginEndpointHlsManifestConfigurationArgsDict']]]] hls_manifests: <p>An HTTP live streaming (HLS) manifest configuration.</p>
         :param pulumi.Input[Sequence[pulumi.Input[Union['OriginEndpointLowLatencyHlsManifestConfigurationArgs', 'OriginEndpointLowLatencyHlsManifestConfigurationArgsDict']]]] low_latency_hls_manifests: <p>A low-latency HLS manifest configuration.</p>
+        :param pulumi.Input[Sequence[pulumi.Input[Union['OriginEndpointMssManifestConfigurationArgs', 'OriginEndpointMssManifestConfigurationArgsDict']]]] mss_manifests: <p>The Microsoft Smooth Streaming (MSS) manifest configurations associated with this origin endpoint.</p>
         :param pulumi.Input[_builtins.str] origin_endpoint_name: The name of the origin endpoint associated with the origin endpoint configuration.
         :param pulumi.Input[Union['OriginEndpointSegmentArgs', 'OriginEndpointSegmentArgsDict']] segment: The segment associated with the origin endpoint.
         :param pulumi.Input[_builtins.int] startover_window_seconds: <p>The size of the window (in seconds) to create a window of the live stream that's available for on-demand viewing. Viewers can start-over or catch-up on content that falls within the window. The maximum startover window is 1,209,600 seconds (14 days).</p>
@@ -287,6 +305,7 @@ class OriginEndpoint(pulumi.CustomResource):
                  force_endpoint_error_configuration: Optional[pulumi.Input[Union['OriginEndpointForceEndpointErrorConfigurationArgs', 'OriginEndpointForceEndpointErrorConfigurationArgsDict']]] = None,
                  hls_manifests: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OriginEndpointHlsManifestConfigurationArgs', 'OriginEndpointHlsManifestConfigurationArgsDict']]]]] = None,
                  low_latency_hls_manifests: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OriginEndpointLowLatencyHlsManifestConfigurationArgs', 'OriginEndpointLowLatencyHlsManifestConfigurationArgsDict']]]]] = None,
+                 mss_manifests: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OriginEndpointMssManifestConfigurationArgs', 'OriginEndpointMssManifestConfigurationArgsDict']]]]] = None,
                  origin_endpoint_name: Optional[pulumi.Input[_builtins.str]] = None,
                  segment: Optional[pulumi.Input[Union['OriginEndpointSegmentArgs', 'OriginEndpointSegmentArgsDict']]] = None,
                  startover_window_seconds: Optional[pulumi.Input[_builtins.int]] = None,
@@ -314,6 +333,7 @@ class OriginEndpoint(pulumi.CustomResource):
             __props__.__dict__["force_endpoint_error_configuration"] = force_endpoint_error_configuration
             __props__.__dict__["hls_manifests"] = hls_manifests
             __props__.__dict__["low_latency_hls_manifests"] = low_latency_hls_manifests
+            __props__.__dict__["mss_manifests"] = mss_manifests
             __props__.__dict__["origin_endpoint_name"] = origin_endpoint_name
             __props__.__dict__["segment"] = segment
             __props__.__dict__["startover_window_seconds"] = startover_window_seconds
@@ -324,6 +344,7 @@ class OriginEndpoint(pulumi.CustomResource):
             __props__.__dict__["hls_manifest_urls"] = None
             __props__.__dict__["low_latency_hls_manifest_urls"] = None
             __props__.__dict__["modified_at"] = None
+            __props__.__dict__["mss_manifest_urls"] = None
         replace_on_changes = pulumi.ResourceOptions(replace_on_changes=["channelGroupName", "channelName", "originEndpointName"])
         opts = pulumi.ResourceOptions.merge(opts, replace_on_changes)
         super(OriginEndpoint, __self__).__init__(
@@ -362,6 +383,8 @@ class OriginEndpoint(pulumi.CustomResource):
         __props__.__dict__["low_latency_hls_manifest_urls"] = None
         __props__.__dict__["low_latency_hls_manifests"] = None
         __props__.__dict__["modified_at"] = None
+        __props__.__dict__["mss_manifest_urls"] = None
+        __props__.__dict__["mss_manifests"] = None
         __props__.__dict__["origin_endpoint_name"] = None
         __props__.__dict__["segment"] = None
         __props__.__dict__["startover_window_seconds"] = None
@@ -480,6 +503,19 @@ class OriginEndpoint(pulumi.CustomResource):
         """
         return pulumi.get(self, "modified_at")
 
+    @_builtins.property
+    @pulumi.getter(name="mssManifestUrls")
+    def mss_manifest_urls(self) -> pulumi.Output[Sequence[_builtins.str]]:
+        return pulumi.get(self, "mss_manifest_urls")
+
+    @_builtins.property
+    @pulumi.getter(name="mssManifests")
+    def mss_manifests(self) -> pulumi.Output[Optional[Sequence['outputs.OriginEndpointMssManifestConfiguration']]]:
+        """
+        <p>The Microsoft Smooth Streaming (MSS) manifest configurations associated with this origin endpoint.</p>
+        """
+        return pulumi.get(self, "mss_manifests")
+
     @_builtins.property
     @pulumi.getter(name="originEndpointName")
     def origin_endpoint_name(self) -> pulumi.Output[_builtins.str]:

pulumi_aws_native/mediapackagev2/outputs.py

@@ -36,6 +36,7 @@ __all__ = [
     'OriginEndpointForceEndpointErrorConfiguration',
     'OriginEndpointHlsManifestConfiguration',
     'OriginEndpointLowLatencyHlsManifestConfiguration',
+    'OriginEndpointMssManifestConfiguration',
     'OriginEndpointPolicyCdnAuthConfiguration',
     'OriginEndpointScte',
     'OriginEndpointScteDash',
@@ -1120,6 +1121,8 @@ class OriginEndpointEncryptionMethod(dict):
         suggest = None
         if key == "cmafEncryptionMethod":
             suggest = "cmaf_encryption_method"
+        elif key == "ismEncryptionMethod":
+            suggest = "ism_encryption_method"
         elif key == "tsEncryptionMethod":
             suggest = "ts_encryption_method"
 
@@ -1136,14 +1139,18 @@ class OriginEndpointEncryptionMethod(dict):
 
     def __init__(__self__, *,
                  cmaf_encryption_method: Optional['OriginEndpointCmafEncryptionMethod'] = None,
+                 ism_encryption_method: Optional['OriginEndpointIsmEncryptionMethod'] = None,
                  ts_encryption_method: Optional['OriginEndpointTsEncryptionMethod'] = None):
         """
         <p>The encryption type.</p>
         :param 'OriginEndpointCmafEncryptionMethod' cmaf_encryption_method: The encryption method to use.
+        :param 'OriginEndpointIsmEncryptionMethod' ism_encryption_method: The encryption method used for Microsoft Smooth Streaming (MSS) content. This specifies how the MSS segments are encrypted to protect the content during delivery to client players.
         :param 'OriginEndpointTsEncryptionMethod' ts_encryption_method: The encryption method to use.
         """
         if cmaf_encryption_method is not None:
             pulumi.set(__self__, "cmaf_encryption_method", cmaf_encryption_method)
+        if ism_encryption_method is not None:
+            pulumi.set(__self__, "ism_encryption_method", ism_encryption_method)
         if ts_encryption_method is not None:
             pulumi.set(__self__, "ts_encryption_method", ts_encryption_method)
 
@@ -1155,6 +1162,14 @@ class OriginEndpointEncryptionMethod(dict):
         """
         return pulumi.get(self, "cmaf_encryption_method")
 
+    @_builtins.property
+    @pulumi.getter(name="ismEncryptionMethod")
+    def ism_encryption_method(self) -> Optional['OriginEndpointIsmEncryptionMethod']:
+        """
+        The encryption method used for Microsoft Smooth Streaming (MSS) content. This specifies how the MSS segments are encrypted to protect the content during delivery to client players.
+        """
+        return pulumi.get(self, "ism_encryption_method")
+
     @_builtins.property
     @pulumi.getter(name="tsEncryptionMethod")
     def ts_encryption_method(self) -> Optional['OriginEndpointTsEncryptionMethod']:
@@ -1594,6 +1609,79 @@ class OriginEndpointLowLatencyHlsManifestConfiguration(dict):
         return pulumi.get(self, "url_encode_child_manifest")
 
 
+@pulumi.output_type
+class OriginEndpointMssManifestConfiguration(dict):
+    """
+    <p>Configuration details for a Microsoft Smooth Streaming (MSS) manifest associated with an origin endpoint. This includes all the settings and properties that define how the MSS content is packaged and delivered.</p>
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "manifestName":
+            suggest = "manifest_name"
+        elif key == "filterConfiguration":
+            suggest = "filter_configuration"
+        elif key == "manifestLayout":
+            suggest = "manifest_layout"
+        elif key == "manifestWindowSeconds":
+            suggest = "manifest_window_seconds"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in OriginEndpointMssManifestConfiguration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        OriginEndpointMssManifestConfiguration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        OriginEndpointMssManifestConfiguration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 manifest_name: _builtins.str,
+                 filter_configuration: Optional['outputs.OriginEndpointFilterConfiguration'] = None,
+                 manifest_layout: Optional['OriginEndpointMssManifestLayout'] = None,
+                 manifest_window_seconds: Optional[_builtins.int] = None):
+        """
+        <p>Configuration details for a Microsoft Smooth Streaming (MSS) manifest associated with an origin endpoint. This includes all the settings and properties that define how the MSS content is packaged and delivered.</p>
+        :param _builtins.str manifest_name: <p>The name of the MSS manifest. This name is appended to the origin endpoint URL to create the unique path for accessing this specific MSS manifest.</p>
+        :param _builtins.int manifest_window_seconds: <p>The duration (in seconds) of the manifest window. This represents the total amount of content available in the manifest at any given time.</p>
+        """
+        pulumi.set(__self__, "manifest_name", manifest_name)
+        if filter_configuration is not None:
+            pulumi.set(__self__, "filter_configuration", filter_configuration)
+        if manifest_layout is not None:
+            pulumi.set(__self__, "manifest_layout", manifest_layout)
+        if manifest_window_seconds is not None:
+            pulumi.set(__self__, "manifest_window_seconds", manifest_window_seconds)
+
+    @_builtins.property
+    @pulumi.getter(name="manifestName")
+    def manifest_name(self) -> _builtins.str:
+        """
+        <p>The name of the MSS manifest. This name is appended to the origin endpoint URL to create the unique path for accessing this specific MSS manifest.</p>
+        """
+        return pulumi.get(self, "manifest_name")
+
+    @_builtins.property
+    @pulumi.getter(name="filterConfiguration")
+    def filter_configuration(self) -> Optional['outputs.OriginEndpointFilterConfiguration']:
+        return pulumi.get(self, "filter_configuration")
+
+    @_builtins.property
+    @pulumi.getter(name="manifestLayout")
+    def manifest_layout(self) -> Optional['OriginEndpointMssManifestLayout']:
+        return pulumi.get(self, "manifest_layout")
+
+    @_builtins.property
+    @pulumi.getter(name="manifestWindowSeconds")
+    def manifest_window_seconds(self) -> Optional[_builtins.int]:
+        """
+        <p>The duration (in seconds) of the manifest window. This represents the total amount of content available in the manifest at any given time.</p>
+        """
+        return pulumi.get(self, "manifest_window_seconds")
+
+
 @pulumi.output_type
 class OriginEndpointPolicyCdnAuthConfiguration(dict):
     @staticmethod

pulumi_aws_native/neptune/db_instance.py

@@ -31,6 +31,7 @@ class DbInstanceArgs:
                  db_snapshot_identifier: Optional[pulumi.Input[_builtins.str]] = None,
                  db_subnet_group_name: Optional[pulumi.Input[_builtins.str]] = None,
                  preferred_maintenance_window: Optional[pulumi.Input[_builtins.str]] = None,
+                 publicly_accessible: Optional[pulumi.Input[_builtins.bool]] = None,
                  tags: Optional[pulumi.Input[Sequence[pulumi.Input['_root_inputs.TagArgs']]]] = None):
         """
         The set of arguments for constructing a DbInstance resource.
@@ -52,6 +53,7 @@ class DbInstanceArgs:
                `AWS::Neptune::DBCluster` does support restoring from snapshots.
         :param pulumi.Input[_builtins.str] db_subnet_group_name: A DB subnet group to associate with the DB instance. If you update this value, the new subnet group must be a subnet group in a new virtual private cloud (VPC).
         :param pulumi.Input[_builtins.str] preferred_maintenance_window: Specifies the weekly time range during which system maintenance can occur, in Universal Coordinated Time (UTC).
+        :param pulumi.Input[_builtins.bool] publicly_accessible: Indicates that public accessibility is enabled. This should be enabled in combination with IAM Auth enabled on the DBCluster
         :param pulumi.Input[Sequence[pulumi.Input['_root_inputs.TagArgs']]] tags: An arbitrary set of tags (key-value pairs) for this DB instance.
         """
         pulumi.set(__self__, "db_instance_class", db_instance_class)
@@ -73,6 +75,8 @@ class DbInstanceArgs:
             pulumi.set(__self__, "db_subnet_group_name", db_subnet_group_name)
         if preferred_maintenance_window is not None:
             pulumi.set(__self__, "preferred_maintenance_window", preferred_maintenance_window)
+        if publicly_accessible is not None:
+            pulumi.set(__self__, "publicly_accessible", publicly_accessible)
         if tags is not None:
             pulumi.set(__self__, "tags", tags)
 
@@ -204,6 +208,18 @@ class DbInstanceArgs:
     def preferred_maintenance_window(self, value: Optional[pulumi.Input[_builtins.str]]):
         pulumi.set(self, "preferred_maintenance_window", value)
 
+    @_builtins.property
+    @pulumi.getter(name="publiclyAccessible")
+    def publicly_accessible(self) -> Optional[pulumi.Input[_builtins.bool]]:
+        """
+        Indicates that public accessibility is enabled. This should be enabled in combination with IAM Auth enabled on the DBCluster
+        """
+        return pulumi.get(self, "publicly_accessible")
+
+    @publicly_accessible.setter
+    def publicly_accessible(self, value: Optional[pulumi.Input[_builtins.bool]]):
+        pulumi.set(self, "publicly_accessible", value)
+
     @_builtins.property
     @pulumi.getter
     def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['_root_inputs.TagArgs']]]]:
@@ -233,6 +249,7 @@ class DbInstance(pulumi.CustomResource):
                  db_snapshot_identifier: Optional[pulumi.Input[_builtins.str]] = None,
                  db_subnet_group_name: Optional[pulumi.Input[_builtins.str]] = None,
                  preferred_maintenance_window: Optional[pulumi.Input[_builtins.str]] = None,
+                 publicly_accessible: Optional[pulumi.Input[_builtins.bool]] = None,
                  tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['_root_inputs.TagArgs', '_root_inputs.TagArgsDict']]]]] = None,
                  __props__=None):
         """
@@ -258,6 +275,7 @@ class DbInstance(pulumi.CustomResource):
                `AWS::Neptune::DBCluster` does support restoring from snapshots.
         :param pulumi.Input[_builtins.str] db_subnet_group_name: A DB subnet group to associate with the DB instance. If you update this value, the new subnet group must be a subnet group in a new virtual private cloud (VPC).
         :param pulumi.Input[_builtins.str] preferred_maintenance_window: Specifies the weekly time range during which system maintenance can occur, in Universal Coordinated Time (UTC).
+        :param pulumi.Input[_builtins.bool] publicly_accessible: Indicates that public accessibility is enabled. This should be enabled in combination with IAM Auth enabled on the DBCluster
         :param pulumi.Input[Sequence[pulumi.Input[Union['_root_inputs.TagArgs', '_root_inputs.TagArgsDict']]]] tags: An arbitrary set of tags (key-value pairs) for this DB instance.
         """
         ...
@@ -294,6 +312,7 @@ class DbInstance(pulumi.CustomResource):
                  db_snapshot_identifier: Optional[pulumi.Input[_builtins.str]] = None,
                  db_subnet_group_name: Optional[pulumi.Input[_builtins.str]] = None,
                  preferred_maintenance_window: Optional[pulumi.Input[_builtins.str]] = None,
+                 publicly_accessible: Optional[pulumi.Input[_builtins.bool]] = None,
                  tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['_root_inputs.TagArgs', '_root_inputs.TagArgsDict']]]]] = None,
                  __props__=None):
         opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
@@ -316,6 +335,7 @@ class DbInstance(pulumi.CustomResource):
             __props__.__dict__["db_snapshot_identifier"] = db_snapshot_identifier
             __props__.__dict__["db_subnet_group_name"] = db_subnet_group_name
             __props__.__dict__["preferred_maintenance_window"] = preferred_maintenance_window
+            __props__.__dict__["publicly_accessible"] = publicly_accessible
             __props__.__dict__["tags"] = tags
             __props__.__dict__["endpoint"] = None
             __props__.__dict__["port"] = None
@@ -355,6 +375,7 @@ class DbInstance(pulumi.CustomResource):
         __props__.__dict__["endpoint"] = None
         __props__.__dict__["port"] = None
         __props__.__dict__["preferred_maintenance_window"] = None
+        __props__.__dict__["publicly_accessible"] = None
         __props__.__dict__["tags"] = None
         return DbInstance(resource_name, opts=opts, __props__=__props__)
 
@@ -462,6 +483,14 @@ class DbInstance(pulumi.CustomResource):
         """
         return pulumi.get(self, "preferred_maintenance_window")
 
+    @_builtins.property
+    @pulumi.getter(name="publiclyAccessible")
+    def publicly_accessible(self) -> pulumi.Output[Optional[_builtins.bool]]:
+        """
+        Indicates that public accessibility is enabled. This should be enabled in combination with IAM Auth enabled on the DBCluster
+        """
+        return pulumi.get(self, "publicly_accessible")
+
     @_builtins.property
     @pulumi.getter
     def tags(self) -> pulumi.Output[Optional[Sequence['_root_outputs.Tag']]]: