pulumi-aws-native 1.38.0a1761286050__py3-none-any.whl → 1.38.0a1761329030__py3-none-any.whl

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,6 +1139,7 @@ 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>
@@ -1144,6 +1148,8 @@ class OriginEndpointEncryptionMethod(dict):
         """
         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 +1161,11 @@ class OriginEndpointEncryptionMethod(dict):
         """
         return pulumi.get(self, "cmaf_encryption_method")
 
+    @_builtins.property
+    @pulumi.getter(name="ismEncryptionMethod")
+    def ism_encryption_method(self) -> Optional['OriginEndpointIsmEncryptionMethod']:
+        return pulumi.get(self, "ism_encryption_method")
+
     @_builtins.property
     @pulumi.getter(name="tsEncryptionMethod")
     def ts_encryption_method(self) -> Optional['OriginEndpointTsEncryptionMethod']:
@@ -1594,6 +1605,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']]]:

pulumi_aws_native/neptune/get_db_instance.py

@@ -24,7 +24,7 @@ __all__ = [
 
 @pulumi.output_type
 class GetDbInstanceResult:
-    def __init__(__self__, auto_minor_version_upgrade=None, db_instance_class=None, db_parameter_group_name=None, endpoint=None, port=None, preferred_maintenance_window=None, tags=None):
+    def __init__(__self__, auto_minor_version_upgrade=None, db_instance_class=None, db_parameter_group_name=None, endpoint=None, port=None, preferred_maintenance_window=None, publicly_accessible=None, tags=None):
         if auto_minor_version_upgrade and not isinstance(auto_minor_version_upgrade, bool):
             raise TypeError("Expected argument 'auto_minor_version_upgrade' to be a bool")
         pulumi.set(__self__, "auto_minor_version_upgrade", auto_minor_version_upgrade)
@@ -43,6 +43,9 @@ class GetDbInstanceResult:
         if preferred_maintenance_window and not isinstance(preferred_maintenance_window, str):
             raise TypeError("Expected argument 'preferred_maintenance_window' to be a str")
         pulumi.set(__self__, "preferred_maintenance_window", preferred_maintenance_window)
+        if publicly_accessible and not isinstance(publicly_accessible, bool):
+            raise TypeError("Expected argument 'publicly_accessible' to be a bool")
+        pulumi.set(__self__, "publicly_accessible", publicly_accessible)
         if tags and not isinstance(tags, list):
             raise TypeError("Expected argument 'tags' to be a list")
         pulumi.set(__self__, "tags", tags)
@@ -99,6 +102,14 @@ class GetDbInstanceResult:
         """
         return pulumi.get(self, "preferred_maintenance_window")
 
+    @_builtins.property
+    @pulumi.getter(name="publiclyAccessible")
+    def publicly_accessible(self) -> 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) -> Optional[Sequence['_root_outputs.Tag']]:
@@ -120,6 +131,7 @@ class AwaitableGetDbInstanceResult(GetDbInstanceResult):
             endpoint=self.endpoint,
             port=self.port,
             preferred_maintenance_window=self.preferred_maintenance_window,
+            publicly_accessible=self.publicly_accessible,
             tags=self.tags)
 
 
@@ -143,6 +155,7 @@ def get_db_instance(db_instance_identifier: Optional[_builtins.str] = None,
         endpoint=pulumi.get(__ret__, 'endpoint'),
         port=pulumi.get(__ret__, 'port'),
         preferred_maintenance_window=pulumi.get(__ret__, 'preferred_maintenance_window'),
+        publicly_accessible=pulumi.get(__ret__, 'publicly_accessible'),
         tags=pulumi.get(__ret__, 'tags'))
 def get_db_instance_output(db_instance_identifier: Optional[pulumi.Input[_builtins.str]] = None,
                            opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetDbInstanceResult]:
@@ -163,4 +176,5 @@ def get_db_instance_output(db_instance_identifier: Optional[pulumi.Input[_builti
         endpoint=pulumi.get(__response__, 'endpoint'),
         port=pulumi.get(__response__, 'port'),
         preferred_maintenance_window=pulumi.get(__response__, 'preferred_maintenance_window'),
+        publicly_accessible=pulumi.get(__response__, 'publicly_accessible'),
         tags=pulumi.get(__response__, 'tags')))

pulumi_aws_native/observabilityadmin/_enums.py

@@ -21,18 +21,27 @@ __all__ = [
 
 @pulumi.type_token("aws-native:observabilityadmin:OrganizationCentralizationRuleLogsEncryptionConfigurationEncryptionConflictResolutionStrategy")
 class OrganizationCentralizationRuleLogsEncryptionConfigurationEncryptionConflictResolutionStrategy(_builtins.str, Enum):
+    """
+    Conflict resolution strategy for centralization if the encryption strategy is set to CUSTOMER_MANAGED and the destination log group is encrypted with an AWS_OWNED KMS Key. ALLOW lets centralization go through while SKIP prevents centralization into the destination log group.
+    """
     ALLOW = "ALLOW"
     SKIP = "SKIP"
 
 
 @pulumi.type_token("aws-native:observabilityadmin:OrganizationCentralizationRuleLogsEncryptionConfigurationEncryptionStrategy")
 class OrganizationCentralizationRuleLogsEncryptionConfigurationEncryptionStrategy(_builtins.str, Enum):
+    """
+    Configuration that determines the encryption strategy of the destination log groups. CUSTOMER_MANAGED uses the configured KmsKeyArn to encrypt newly created destination log groups.
+    """
     CUSTOMER_MANAGED = "CUSTOMER_MANAGED"
     AWS_OWNED = "AWS_OWNED"
 
 
 @pulumi.type_token("aws-native:observabilityadmin:OrganizationCentralizationRuleSourceLogsConfigurationEncryptedLogGroupStrategy")
 class OrganizationCentralizationRuleSourceLogsConfigurationEncryptedLogGroupStrategy(_builtins.str, Enum):
+    """
+    A strategy determining whether to centralize source log groups that are encrypted with customer managed KMS keys (CMK). ALLOW will consider CMK encrypted source log groups for centralization while SKIP will skip CMK encrypted source log groups from centralization.
+    """
     ALLOW = "ALLOW"
     SKIP = "SKIP"