pulumi-aws-native 1.38.0a1761284362__py3-none-any.whl → 1.38.0a1761310773__py3-none-any.whl

pulumi_aws_native/organizations/get_account.py

@@ -25,7 +25,7 @@ __all__ = [
 
 @pulumi.output_type
 class GetAccountResult:
-    def __init__(__self__, account_id=None, account_name=None, arn=None, email=None, joined_method=None, joined_timestamp=None, parent_ids=None, status=None, tags=None):
+    def __init__(__self__, account_id=None, account_name=None, arn=None, email=None, joined_method=None, joined_timestamp=None, parent_ids=None, state=None, status=None, tags=None):
         if account_id and not isinstance(account_id, str):
             raise TypeError("Expected argument 'account_id' to be a str")
         pulumi.set(__self__, "account_id", account_id)
@@ -47,6 +47,9 @@ class GetAccountResult:
         if parent_ids and not isinstance(parent_ids, list):
             raise TypeError("Expected argument 'parent_ids' to be a list")
         pulumi.set(__self__, "parent_ids", parent_ids)
+        if state and not isinstance(state, str):
+            raise TypeError("Expected argument 'state' to be a str")
+        pulumi.set(__self__, "state", state)
         if status and not isinstance(status, str):
             raise TypeError("Expected argument 'status' to be a str")
         pulumi.set(__self__, "status", status)
@@ -110,6 +113,14 @@ class GetAccountResult:
         """
         return pulumi.get(self, "parent_ids")
 
+    @_builtins.property
+    @pulumi.getter
+    def state(self) -> Optional['AccountState']:
+        """
+        The state of the account in the organization.
+        """
+        return pulumi.get(self, "state")
+
     @_builtins.property
     @pulumi.getter
     def status(self) -> Optional['AccountStatus']:
@@ -140,6 +151,7 @@ class AwaitableGetAccountResult(GetAccountResult):
             joined_method=self.joined_method,
             joined_timestamp=self.joined_timestamp,
             parent_ids=self.parent_ids,
+            state=self.state,
             status=self.status,
             tags=self.tags)
 
@@ -165,6 +177,7 @@ def get_account(account_id: Optional[_builtins.str] = None,
         joined_method=pulumi.get(__ret__, 'joined_method'),
         joined_timestamp=pulumi.get(__ret__, 'joined_timestamp'),
         parent_ids=pulumi.get(__ret__, 'parent_ids'),
+        state=pulumi.get(__ret__, 'state'),
         status=pulumi.get(__ret__, 'status'),
         tags=pulumi.get(__ret__, 'tags'))
 def get_account_output(account_id: Optional[pulumi.Input[_builtins.str]] = None,
@@ -187,5 +200,6 @@ def get_account_output(account_id: Optional[pulumi.Input[_builtins.str]] = None,
         joined_method=pulumi.get(__response__, 'joined_method'),
         joined_timestamp=pulumi.get(__response__, 'joined_timestamp'),
         parent_ids=pulumi.get(__response__, 'parent_ids'),
+        state=pulumi.get(__response__, 'state'),
         status=pulumi.get(__response__, 'status'),
         tags=pulumi.get(__response__, 'tags')))

pulumi_aws_native/osis/_inputs.py

@@ -24,6 +24,8 @@ __all__ = [
     'PipelineLogPublishingOptionsCloudWatchLogDestinationPropertiesArgsDict',
     'PipelineLogPublishingOptionsArgs',
     'PipelineLogPublishingOptionsArgsDict',
+    'PipelineResourcePolicyArgs',
+    'PipelineResourcePolicyArgsDict',
     'PipelineVpcOptionsVpcAttachmentOptionsPropertiesArgs',
     'PipelineVpcOptionsVpcAttachmentOptionsPropertiesArgsDict',
     'PipelineVpcOptionsArgs',
@@ -186,6 +188,28 @@ class PipelineLogPublishingOptionsArgs:
         pulumi.set(self, "is_logging_enabled", value)
 
 
+if not MYPY:
+    class PipelineResourcePolicyArgsDict(TypedDict):
+        policy: Any
+elif False:
+    PipelineResourcePolicyArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PipelineResourcePolicyArgs:
+    def __init__(__self__, *,
+                 policy: Any):
+        pulumi.set(__self__, "policy", policy)
+
+    @_builtins.property
+    @pulumi.getter
+    def policy(self) -> Any:
+        return pulumi.get(self, "policy")
+
+    @policy.setter
+    def policy(self, value: Any):
+        pulumi.set(self, "policy", value)
+
+
 if not MYPY:
     class PipelineVpcOptionsVpcAttachmentOptionsPropertiesArgsDict(TypedDict):
         """

pulumi_aws_native/osis/get_pipeline.py

@@ -26,7 +26,7 @@ __all__ = [
 
 @pulumi.output_type
 class GetPipelineResult:
-    def __init__(__self__, buffer_options=None, encryption_at_rest_options=None, ingest_endpoint_urls=None, log_publishing_options=None, max_units=None, min_units=None, pipeline_arn=None, pipeline_configuration_body=None, tags=None, vpc_endpoint_service=None, vpc_endpoints=None):
+    def __init__(__self__, buffer_options=None, encryption_at_rest_options=None, ingest_endpoint_urls=None, log_publishing_options=None, max_units=None, min_units=None, pipeline_arn=None, pipeline_configuration_body=None, pipeline_role_arn=None, resource_policy=None, tags=None, vpc_endpoint_service=None, vpc_endpoints=None):
         if buffer_options and not isinstance(buffer_options, dict):
             raise TypeError("Expected argument 'buffer_options' to be a dict")
         pulumi.set(__self__, "buffer_options", buffer_options)
@@ -51,6 +51,12 @@ class GetPipelineResult:
         if pipeline_configuration_body and not isinstance(pipeline_configuration_body, str):
             raise TypeError("Expected argument 'pipeline_configuration_body' to be a str")
         pulumi.set(__self__, "pipeline_configuration_body", pipeline_configuration_body)
+        if pipeline_role_arn and not isinstance(pipeline_role_arn, str):
+            raise TypeError("Expected argument 'pipeline_role_arn' to be a str")
+        pulumi.set(__self__, "pipeline_role_arn", pipeline_role_arn)
+        if resource_policy and not isinstance(resource_policy, dict):
+            raise TypeError("Expected argument 'resource_policy' to be a dict")
+        pulumi.set(__self__, "resource_policy", resource_policy)
         if tags and not isinstance(tags, list):
             raise TypeError("Expected argument 'tags' to be a list")
         pulumi.set(__self__, "tags", tags)
@@ -125,6 +131,19 @@ class GetPipelineResult:
         """
         return pulumi.get(self, "pipeline_configuration_body")
 
+    @_builtins.property
+    @pulumi.getter(name="pipelineRoleArn")
+    def pipeline_role_arn(self) -> Optional[_builtins.str]:
+        """
+        The Pipeline Role (ARN) for the pipeline.
+        """
+        return pulumi.get(self, "pipeline_role_arn")
+
+    @_builtins.property
+    @pulumi.getter(name="resourcePolicy")
+    def resource_policy(self) -> Optional['outputs.PipelineResourcePolicy']:
+        return pulumi.get(self, "resource_policy")
+
     @_builtins.property
     @pulumi.getter
     def tags(self) -> Optional[Sequence['_root_outputs.Tag']]:
@@ -164,6 +183,8 @@ class AwaitableGetPipelineResult(GetPipelineResult):
             min_units=self.min_units,
             pipeline_arn=self.pipeline_arn,
             pipeline_configuration_body=self.pipeline_configuration_body,
+            pipeline_role_arn=self.pipeline_role_arn,
+            resource_policy=self.resource_policy,
             tags=self.tags,
             vpc_endpoint_service=self.vpc_endpoint_service,
             vpc_endpoints=self.vpc_endpoints)
@@ -191,6 +212,8 @@ def get_pipeline(pipeline_arn: Optional[_builtins.str] = None,
         min_units=pulumi.get(__ret__, 'min_units'),
         pipeline_arn=pulumi.get(__ret__, 'pipeline_arn'),
         pipeline_configuration_body=pulumi.get(__ret__, 'pipeline_configuration_body'),
+        pipeline_role_arn=pulumi.get(__ret__, 'pipeline_role_arn'),
+        resource_policy=pulumi.get(__ret__, 'resource_policy'),
         tags=pulumi.get(__ret__, 'tags'),
         vpc_endpoint_service=pulumi.get(__ret__, 'vpc_endpoint_service'),
         vpc_endpoints=pulumi.get(__ret__, 'vpc_endpoints'))
@@ -215,6 +238,8 @@ def get_pipeline_output(pipeline_arn: Optional[pulumi.Input[_builtins.str]] = No
         min_units=pulumi.get(__response__, 'min_units'),
         pipeline_arn=pulumi.get(__response__, 'pipeline_arn'),
         pipeline_configuration_body=pulumi.get(__response__, 'pipeline_configuration_body'),
+        pipeline_role_arn=pulumi.get(__response__, 'pipeline_role_arn'),
+        resource_policy=pulumi.get(__response__, 'resource_policy'),
         tags=pulumi.get(__response__, 'tags'),
         vpc_endpoint_service=pulumi.get(__response__, 'vpc_endpoint_service'),
         vpc_endpoints=pulumi.get(__response__, 'vpc_endpoints')))

pulumi_aws_native/osis/outputs.py

@@ -21,6 +21,7 @@ __all__ = [
     'PipelineEncryptionAtRestOptions',
     'PipelineLogPublishingOptions',
     'PipelineLogPublishingOptionsCloudWatchLogDestinationProperties',
+    'PipelineResourcePolicy',
     'PipelineVpcEndpoint',
     'PipelineVpcOptions',
     'PipelineVpcOptionsVpcAttachmentOptionsProperties',
@@ -193,6 +194,18 @@ class PipelineLogPublishingOptionsCloudWatchLogDestinationProperties(dict):
         return pulumi.get(self, "log_group")
 
 
+@pulumi.output_type
+class PipelineResourcePolicy(dict):
+    def __init__(__self__, *,
+                 policy: Any):
+        pulumi.set(__self__, "policy", policy)
+
+    @_builtins.property
+    @pulumi.getter
+    def policy(self) -> Any:
+        return pulumi.get(self, "policy")
+
+
 @pulumi.output_type
 class PipelineVpcEndpoint(dict):
     """

pulumi_aws_native/osis/pipeline.py

@@ -31,6 +31,8 @@ class PipelineArgs:
                  encryption_at_rest_options: Optional[pulumi.Input['PipelineEncryptionAtRestOptionsArgs']] = None,
                  log_publishing_options: Optional[pulumi.Input['PipelineLogPublishingOptionsArgs']] = None,
                  pipeline_name: Optional[pulumi.Input[_builtins.str]] = None,
+                 pipeline_role_arn: Optional[pulumi.Input[_builtins.str]] = None,
+                 resource_policy: Optional[pulumi.Input['PipelineResourcePolicyArgs']] = None,
                  tags: Optional[pulumi.Input[Sequence[pulumi.Input['_root_inputs.TagArgs']]]] = None,
                  vpc_options: Optional[pulumi.Input['PipelineVpcOptionsArgs']] = None):
         """
@@ -42,6 +44,7 @@ class PipelineArgs:
         :param pulumi.Input['PipelineEncryptionAtRestOptionsArgs'] encryption_at_rest_options: Options to control how OpenSearch encrypts buffer data.
         :param pulumi.Input['PipelineLogPublishingOptionsArgs'] log_publishing_options: Key-value pairs that represent log publishing settings.
         :param pulumi.Input[_builtins.str] pipeline_name: Name of the OpenSearch Ingestion Service pipeline to create. Pipeline names are unique across the pipelines owned by an account within an AWS Region.
+        :param pulumi.Input[_builtins.str] pipeline_role_arn: The Pipeline Role (ARN) for the pipeline.
         :param pulumi.Input[Sequence[pulumi.Input['_root_inputs.TagArgs']]] tags: An array of key-value pairs to apply to this resource.
         :param pulumi.Input['PipelineVpcOptionsArgs'] vpc_options: Options that specify the subnets and security groups for an OpenSearch Ingestion VPC endpoint.
         """
@@ -56,6 +59,10 @@ class PipelineArgs:
             pulumi.set(__self__, "log_publishing_options", log_publishing_options)
         if pipeline_name is not None:
             pulumi.set(__self__, "pipeline_name", pipeline_name)
+        if pipeline_role_arn is not None:
+            pulumi.set(__self__, "pipeline_role_arn", pipeline_role_arn)
+        if resource_policy is not None:
+            pulumi.set(__self__, "resource_policy", resource_policy)
         if tags is not None:
             pulumi.set(__self__, "tags", tags)
         if vpc_options is not None:
@@ -145,6 +152,27 @@ class PipelineArgs:
     def pipeline_name(self, value: Optional[pulumi.Input[_builtins.str]]):
         pulumi.set(self, "pipeline_name", value)
 
+    @_builtins.property
+    @pulumi.getter(name="pipelineRoleArn")
+    def pipeline_role_arn(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The Pipeline Role (ARN) for the pipeline.
+        """
+        return pulumi.get(self, "pipeline_role_arn")
+
+    @pipeline_role_arn.setter
+    def pipeline_role_arn(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "pipeline_role_arn", value)
+
+    @_builtins.property
+    @pulumi.getter(name="resourcePolicy")
+    def resource_policy(self) -> Optional[pulumi.Input['PipelineResourcePolicyArgs']]:
+        return pulumi.get(self, "resource_policy")
+
+    @resource_policy.setter
+    def resource_policy(self, value: Optional[pulumi.Input['PipelineResourcePolicyArgs']]):
+        pulumi.set(self, "resource_policy", value)
+
     @_builtins.property
     @pulumi.getter
     def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['_root_inputs.TagArgs']]]]:
@@ -183,6 +211,8 @@ class Pipeline(pulumi.CustomResource):
                  min_units: Optional[pulumi.Input[_builtins.int]] = None,
                  pipeline_configuration_body: Optional[pulumi.Input[_builtins.str]] = None,
                  pipeline_name: Optional[pulumi.Input[_builtins.str]] = None,
+                 pipeline_role_arn: Optional[pulumi.Input[_builtins.str]] = None,
+                 resource_policy: Optional[pulumi.Input[Union['PipelineResourcePolicyArgs', 'PipelineResourcePolicyArgsDict']]] = None,
                  tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['_root_inputs.TagArgs', '_root_inputs.TagArgsDict']]]]] = None,
                  vpc_options: Optional[pulumi.Input[Union['PipelineVpcOptionsArgs', 'PipelineVpcOptionsArgsDict']]] = None,
                  __props__=None):
@@ -198,6 +228,7 @@ class Pipeline(pulumi.CustomResource):
         :param pulumi.Input[_builtins.int] min_units: The minimum pipeline capacity, in Ingestion OpenSearch Compute Units (OCUs).
         :param pulumi.Input[_builtins.str] pipeline_configuration_body: The Data Prepper pipeline configuration.
         :param pulumi.Input[_builtins.str] pipeline_name: Name of the OpenSearch Ingestion Service pipeline to create. Pipeline names are unique across the pipelines owned by an account within an AWS Region.
+        :param pulumi.Input[_builtins.str] pipeline_role_arn: The Pipeline Role (ARN) for the pipeline.
         :param pulumi.Input[Sequence[pulumi.Input[Union['_root_inputs.TagArgs', '_root_inputs.TagArgsDict']]]] tags: An array of key-value pairs to apply to this resource.
         :param pulumi.Input[Union['PipelineVpcOptionsArgs', 'PipelineVpcOptionsArgsDict']] vpc_options: Options that specify the subnets and security groups for an OpenSearch Ingestion VPC endpoint.
         """
@@ -232,6 +263,8 @@ class Pipeline(pulumi.CustomResource):
                  min_units: Optional[pulumi.Input[_builtins.int]] = None,
                  pipeline_configuration_body: Optional[pulumi.Input[_builtins.str]] = None,
                  pipeline_name: Optional[pulumi.Input[_builtins.str]] = None,
+                 pipeline_role_arn: Optional[pulumi.Input[_builtins.str]] = None,
+                 resource_policy: Optional[pulumi.Input[Union['PipelineResourcePolicyArgs', 'PipelineResourcePolicyArgsDict']]] = None,
                  tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['_root_inputs.TagArgs', '_root_inputs.TagArgsDict']]]]] = None,
                  vpc_options: Optional[pulumi.Input[Union['PipelineVpcOptionsArgs', 'PipelineVpcOptionsArgsDict']]] = None,
                  __props__=None):
@@ -256,6 +289,8 @@ class Pipeline(pulumi.CustomResource):
                 raise TypeError("Missing required property 'pipeline_configuration_body'")
             __props__.__dict__["pipeline_configuration_body"] = pipeline_configuration_body
             __props__.__dict__["pipeline_name"] = pipeline_name
+            __props__.__dict__["pipeline_role_arn"] = pipeline_role_arn
+            __props__.__dict__["resource_policy"] = resource_policy
             __props__.__dict__["tags"] = tags
             __props__.__dict__["vpc_options"] = vpc_options
             __props__.__dict__["ingest_endpoint_urls"] = None
@@ -295,6 +330,8 @@ class Pipeline(pulumi.CustomResource):
         __props__.__dict__["pipeline_arn"] = None
         __props__.__dict__["pipeline_configuration_body"] = None
         __props__.__dict__["pipeline_name"] = None
+        __props__.__dict__["pipeline_role_arn"] = None
+        __props__.__dict__["resource_policy"] = None
         __props__.__dict__["tags"] = None
         __props__.__dict__["vpc_endpoint_service"] = None
         __props__.__dict__["vpc_endpoints"] = None
@@ -373,6 +410,19 @@ class Pipeline(pulumi.CustomResource):
         """
         return pulumi.get(self, "pipeline_name")
 
+    @_builtins.property
+    @pulumi.getter(name="pipelineRoleArn")
+    def pipeline_role_arn(self) -> pulumi.Output[Optional[_builtins.str]]:
+        """
+        The Pipeline Role (ARN) for the pipeline.
+        """
+        return pulumi.get(self, "pipeline_role_arn")
+
+    @_builtins.property
+    @pulumi.getter(name="resourcePolicy")
+    def resource_policy(self) -> pulumi.Output[Optional['outputs.PipelineResourcePolicy']]:
+        return pulumi.get(self, "resource_policy")
+
     @_builtins.property
     @pulumi.getter
     def tags(self) -> pulumi.Output[Optional[Sequence['_root_outputs.Tag']]]:

pulumi_aws_native/pulumi-plugin.json

@@ -1,5 +1,5 @@
 {
   "resource": true,
   "name": "aws-native",
-  "version": "1.38.0-alpha.1761284362"
+  "version": "1.38.0-alpha.1761310773"
 }

pulumi_aws_native/quicksight/_enums.py

@@ -2551,7 +2551,7 @@ class RefreshScheduleMapRefreshType(_builtins.str, Enum):
     - `FULL_REFRESH` : A complete refresh of a dataset.
     - `INCREMENTAL_REFRESH` : A partial refresh of some rows of a dataset, based on the time window specified.
 
-    For more information on full and incremental refreshes, see [Refreshing SPICE data](https://docs.aws.amazon.com/quicksight/latest/user/refreshing-imported-data.html) in the *QuickSight User Guide* .
+    For more information on full and incremental refreshes, see [Refreshing SPICE data](https://docs.aws.amazon.com/quicksight/latest/user/refreshing-imported-data.html) in the *Quick Suite User Guide* .
     """
     FULL_REFRESH = "FULL_REFRESH"
     INCREMENTAL_REFRESH = "INCREMENTAL_REFRESH"

pulumi_aws_native/quicksight/_inputs.py

@@ -99108,7 +99108,7 @@ if not MYPY:
         - `FULL_REFRESH` : A complete refresh of a dataset.
         - `INCREMENTAL_REFRESH` : A partial refresh of some rows of a dataset, based on the time window specified.
 
-        For more information on full and incremental refreshes, see [Refreshing SPICE data](https://docs.aws.amazon.com/quicksight/latest/user/refreshing-imported-data.html) in the *QuickSight User Guide* .
+        For more information on full and incremental refreshes, see [Refreshing SPICE data](https://docs.aws.amazon.com/quicksight/latest/user/refreshing-imported-data.html) in the *Quick Suite User Guide* .
         """
         schedule_frequency: NotRequired[pulumi.Input['RefreshScheduleMapScheduleFrequencyPropertiesArgsDict']]
         """
@@ -99138,7 +99138,7 @@ class RefreshScheduleMapArgs:
                - `FULL_REFRESH` : A complete refresh of a dataset.
                - `INCREMENTAL_REFRESH` : A partial refresh of some rows of a dataset, based on the time window specified.
                
-               For more information on full and incremental refreshes, see [Refreshing SPICE data](https://docs.aws.amazon.com/quicksight/latest/user/refreshing-imported-data.html) in the *QuickSight User Guide* .
+               For more information on full and incremental refreshes, see [Refreshing SPICE data](https://docs.aws.amazon.com/quicksight/latest/user/refreshing-imported-data.html) in the *Quick Suite User Guide* .
         :param pulumi.Input['RefreshScheduleMapScheduleFrequencyPropertiesArgs'] schedule_frequency: <p>Information about the schedule frequency.</p>
         :param pulumi.Input[_builtins.str] schedule_id: <p>An unique identifier for the refresh schedule.</p>
         :param pulumi.Input[_builtins.str] start_after_date_time: <p>The date time after which refresh is to be scheduled</p>
@@ -99161,7 +99161,7 @@ class RefreshScheduleMapArgs:
         - `FULL_REFRESH` : A complete refresh of a dataset.
         - `INCREMENTAL_REFRESH` : A partial refresh of some rows of a dataset, based on the time window specified.
 
-        For more information on full and incremental refreshes, see [Refreshing SPICE data](https://docs.aws.amazon.com/quicksight/latest/user/refreshing-imported-data.html) in the *QuickSight User Guide* .
+        For more information on full and incremental refreshes, see [Refreshing SPICE data](https://docs.aws.amazon.com/quicksight/latest/user/refreshing-imported-data.html) in the *Quick Suite User Guide* .
         """
         return pulumi.get(self, "refresh_type")
 

pulumi_aws_native/quicksight/outputs.py

@@ -80162,7 +80162,7 @@ class RefreshScheduleMap(dict):
                - `FULL_REFRESH` : A complete refresh of a dataset.
                - `INCREMENTAL_REFRESH` : A partial refresh of some rows of a dataset, based on the time window specified.
                
-               For more information on full and incremental refreshes, see [Refreshing SPICE data](https://docs.aws.amazon.com/quicksight/latest/user/refreshing-imported-data.html) in the *QuickSight User Guide* .
+               For more information on full and incremental refreshes, see [Refreshing SPICE data](https://docs.aws.amazon.com/quicksight/latest/user/refreshing-imported-data.html) in the *Quick Suite User Guide* .
         :param 'RefreshScheduleMapScheduleFrequencyProperties' schedule_frequency: <p>Information about the schedule frequency.</p>
         :param _builtins.str schedule_id: <p>An unique identifier for the refresh schedule.</p>
         :param _builtins.str start_after_date_time: <p>The date time after which refresh is to be scheduled</p>
@@ -80185,7 +80185,7 @@ class RefreshScheduleMap(dict):
         - `FULL_REFRESH` : A complete refresh of a dataset.
         - `INCREMENTAL_REFRESH` : A partial refresh of some rows of a dataset, based on the time window specified.
 
-        For more information on full and incremental refreshes, see [Refreshing SPICE data](https://docs.aws.amazon.com/quicksight/latest/user/refreshing-imported-data.html) in the *QuickSight User Guide* .
+        For more information on full and incremental refreshes, see [Refreshing SPICE data](https://docs.aws.amazon.com/quicksight/latest/user/refreshing-imported-data.html) in the *Quick Suite User Guide* .
         """
         return pulumi.get(self, "refresh_type")
 

pulumi_aws_native/rds/db_cluster.py

@@ -308,17 +308,13 @@ class DbClusterArgs:
                 Constraints: Minimum 30-minute window.
                 Valid for: Aurora DB clusters and Multi-AZ DB clusters
         :param pulumi.Input[_builtins.bool] publicly_accessible: Specifies whether the DB cluster is publicly accessible.
-                When the DB cluster is publicly accessible and you connect from outside of the DB cluster's virtual private cloud (VPC), its Domain Name System (DNS) endpoint resolves to the public IP address. When you connect from within the same VPC as the DB cluster, the endpoint resolves to the private IP address. Access to the DB cluster is ultimately controlled by the security group it uses. That public access isn't permitted if the security group assigned to the DB cluster doesn't permit it.
-                When the DB cluster isn't publicly accessible, it is an internal DB cluster with a DNS name that resolves to a private IP address.
                 Valid for Cluster Type: Multi-AZ DB clusters only
-                Default: The default behavior varies depending on whether ``DBSubnetGroupName`` is specified.
-                If ``DBSubnetGroupName`` isn't specified, and ``PubliclyAccessible`` isn't specified, the following applies:
-                 +  If the default VPC in the target Region doesn’t have an internet gateway attached to it, the DB cluster is private.
-                 +  If the default VPC in the target Region has an internet gateway attached to it, the DB cluster is public.
-                 
-                If ``DBSubnetGroupName`` is specified, and ``PubliclyAccessible`` isn't specified, the following applies:
-                 +  If the subnets are part of a VPC that doesn’t have an internet gateway attached to it, the DB cluster is private.
-                 +  If the subnets are part of a VPC that has an internet gateway attached to it, the DB cluster is public.
+                When the DB cluster is publicly accessible and you connect from outside of the DB cluster's virtual private cloud (VPC), its domain name system (DNS) endpoint resolves to the public IP address. When you connect from within the same VPC as the DB cluster, the endpoint resolves to the private IP address. Access to the DB cluster is controlled by its security group settings.
+                When the DB cluster isn't publicly accessible, it is an internal DB cluster with a DNS name that resolves to a private IP address.
+                The default behavior when ``PubliclyAccessible`` is not specified depends on whether a ``DBSubnetGroup`` is specified.
+                If ``DBSubnetGroup`` isn't specified, ``PubliclyAccessible`` defaults to ``true``.
+                If ``DBSubnetGroup`` is specified, ``PubliclyAccessible`` defaults to ``false`` unless the value of ``DBSubnetGroup`` is ``default``, in which case ``PubliclyAccessible`` defaults to ``true``.
+                If ``PubliclyAccessible`` is true and the VPC that the ``DBSubnetGroup`` is in doesn't have an internet gateway attached to it, Amazon RDS returns an error.
         :param pulumi.Input[_builtins.str] replication_source_identifier: The Amazon Resource Name (ARN) of the source DB instance or DB cluster if this DB cluster is created as a read replica.
                 Valid for: Aurora DB clusters only
         :param pulumi.Input[_builtins.str] restore_to_time: The date and time to restore the DB cluster to.
@@ -1255,17 +1251,13 @@ class DbClusterArgs:
     def publicly_accessible(self) -> Optional[pulumi.Input[_builtins.bool]]:
         """
         Specifies whether the DB cluster is publicly accessible.
-         When the DB cluster is publicly accessible and you connect from outside of the DB cluster's virtual private cloud (VPC), its Domain Name System (DNS) endpoint resolves to the public IP address. When you connect from within the same VPC as the DB cluster, the endpoint resolves to the private IP address. Access to the DB cluster is ultimately controlled by the security group it uses. That public access isn't permitted if the security group assigned to the DB cluster doesn't permit it.
-         When the DB cluster isn't publicly accessible, it is an internal DB cluster with a DNS name that resolves to a private IP address.
          Valid for Cluster Type: Multi-AZ DB clusters only
-         Default: The default behavior varies depending on whether ``DBSubnetGroupName`` is specified.
-         If ``DBSubnetGroupName`` isn't specified, and ``PubliclyAccessible`` isn't specified, the following applies:
-          +  If the default VPC in the target Region doesn’t have an internet gateway attached to it, the DB cluster is private.
-          +  If the default VPC in the target Region has an internet gateway attached to it, the DB cluster is public.
-          
-         If ``DBSubnetGroupName`` is specified, and ``PubliclyAccessible`` isn't specified, the following applies:
-          +  If the subnets are part of a VPC that doesn’t have an internet gateway attached to it, the DB cluster is private.
-          +  If the subnets are part of a VPC that has an internet gateway attached to it, the DB cluster is public.
+         When the DB cluster is publicly accessible and you connect from outside of the DB cluster's virtual private cloud (VPC), its domain name system (DNS) endpoint resolves to the public IP address. When you connect from within the same VPC as the DB cluster, the endpoint resolves to the private IP address. Access to the DB cluster is controlled by its security group settings.
+         When the DB cluster isn't publicly accessible, it is an internal DB cluster with a DNS name that resolves to a private IP address.
+         The default behavior when ``PubliclyAccessible`` is not specified depends on whether a ``DBSubnetGroup`` is specified.
+         If ``DBSubnetGroup`` isn't specified, ``PubliclyAccessible`` defaults to ``true``.
+         If ``DBSubnetGroup`` is specified, ``PubliclyAccessible`` defaults to ``false`` unless the value of ``DBSubnetGroup`` is ``default``, in which case ``PubliclyAccessible`` defaults to ``true``.
+         If ``PubliclyAccessible`` is true and the VPC that the ``DBSubnetGroup`` is in doesn't have an internet gateway attached to it, Amazon RDS returns an error.
         """
         return pulumi.get(self, "publicly_accessible")
 
@@ -1819,17 +1811,13 @@ class DbCluster(pulumi.CustomResource):
                 Constraints: Minimum 30-minute window.
                 Valid for: Aurora DB clusters and Multi-AZ DB clusters
         :param pulumi.Input[_builtins.bool] publicly_accessible: Specifies whether the DB cluster is publicly accessible.
-                When the DB cluster is publicly accessible and you connect from outside of the DB cluster's virtual private cloud (VPC), its Domain Name System (DNS) endpoint resolves to the public IP address. When you connect from within the same VPC as the DB cluster, the endpoint resolves to the private IP address. Access to the DB cluster is ultimately controlled by the security group it uses. That public access isn't permitted if the security group assigned to the DB cluster doesn't permit it.
-                When the DB cluster isn't publicly accessible, it is an internal DB cluster with a DNS name that resolves to a private IP address.
                 Valid for Cluster Type: Multi-AZ DB clusters only
-                Default: The default behavior varies depending on whether ``DBSubnetGroupName`` is specified.
-                If ``DBSubnetGroupName`` isn't specified, and ``PubliclyAccessible`` isn't specified, the following applies:
-                 +  If the default VPC in the target Region doesn’t have an internet gateway attached to it, the DB cluster is private.
-                 +  If the default VPC in the target Region has an internet gateway attached to it, the DB cluster is public.
-                 
-                If ``DBSubnetGroupName`` is specified, and ``PubliclyAccessible`` isn't specified, the following applies:
-                 +  If the subnets are part of a VPC that doesn’t have an internet gateway attached to it, the DB cluster is private.
-                 +  If the subnets are part of a VPC that has an internet gateway attached to it, the DB cluster is public.
+                When the DB cluster is publicly accessible and you connect from outside of the DB cluster's virtual private cloud (VPC), its domain name system (DNS) endpoint resolves to the public IP address. When you connect from within the same VPC as the DB cluster, the endpoint resolves to the private IP address. Access to the DB cluster is controlled by its security group settings.
+                When the DB cluster isn't publicly accessible, it is an internal DB cluster with a DNS name that resolves to a private IP address.
+                The default behavior when ``PubliclyAccessible`` is not specified depends on whether a ``DBSubnetGroup`` is specified.
+                If ``DBSubnetGroup`` isn't specified, ``PubliclyAccessible`` defaults to ``true``.
+                If ``DBSubnetGroup`` is specified, ``PubliclyAccessible`` defaults to ``false`` unless the value of ``DBSubnetGroup`` is ``default``, in which case ``PubliclyAccessible`` defaults to ``true``.
+                If ``PubliclyAccessible`` is true and the VPC that the ``DBSubnetGroup`` is in doesn't have an internet gateway attached to it, Amazon RDS returns an error.
         :param pulumi.Input[_builtins.str] replication_source_identifier: The Amazon Resource Name (ARN) of the source DB instance or DB cluster if this DB cluster is created as a read replica.
                 Valid for: Aurora DB clusters only
         :param pulumi.Input[_builtins.str] restore_to_time: The date and time to restore the DB cluster to.
@@ -2748,17 +2736,13 @@ class DbCluster(pulumi.CustomResource):
     def publicly_accessible(self) -> pulumi.Output[Optional[_builtins.bool]]:
         """
         Specifies whether the DB cluster is publicly accessible.
-         When the DB cluster is publicly accessible and you connect from outside of the DB cluster's virtual private cloud (VPC), its Domain Name System (DNS) endpoint resolves to the public IP address. When you connect from within the same VPC as the DB cluster, the endpoint resolves to the private IP address. Access to the DB cluster is ultimately controlled by the security group it uses. That public access isn't permitted if the security group assigned to the DB cluster doesn't permit it.
-         When the DB cluster isn't publicly accessible, it is an internal DB cluster with a DNS name that resolves to a private IP address.
          Valid for Cluster Type: Multi-AZ DB clusters only
-         Default: The default behavior varies depending on whether ``DBSubnetGroupName`` is specified.
-         If ``DBSubnetGroupName`` isn't specified, and ``PubliclyAccessible`` isn't specified, the following applies:
-          +  If the default VPC in the target Region doesn’t have an internet gateway attached to it, the DB cluster is private.
-          +  If the default VPC in the target Region has an internet gateway attached to it, the DB cluster is public.
-          
-         If ``DBSubnetGroupName`` is specified, and ``PubliclyAccessible`` isn't specified, the following applies:
-          +  If the subnets are part of a VPC that doesn’t have an internet gateway attached to it, the DB cluster is private.
-          +  If the subnets are part of a VPC that has an internet gateway attached to it, the DB cluster is public.
+         When the DB cluster is publicly accessible and you connect from outside of the DB cluster's virtual private cloud (VPC), its domain name system (DNS) endpoint resolves to the public IP address. When you connect from within the same VPC as the DB cluster, the endpoint resolves to the private IP address. Access to the DB cluster is controlled by its security group settings.
+         When the DB cluster isn't publicly accessible, it is an internal DB cluster with a DNS name that resolves to a private IP address.
+         The default behavior when ``PubliclyAccessible`` is not specified depends on whether a ``DBSubnetGroup`` is specified.
+         If ``DBSubnetGroup`` isn't specified, ``PubliclyAccessible`` defaults to ``true``.
+         If ``DBSubnetGroup`` is specified, ``PubliclyAccessible`` defaults to ``false`` unless the value of ``DBSubnetGroup`` is ``default``, in which case ``PubliclyAccessible`` defaults to ``true``.
+         If ``PubliclyAccessible`` is true and the VPC that the ``DBSubnetGroup`` is in doesn't have an internet gateway attached to it, Amazon RDS returns an error.
         """
         return pulumi.get(self, "publicly_accessible")
 

pulumi_aws_native/route53/_inputs.py

@@ -187,7 +187,9 @@ if not MYPY:
         """
         The number of consecutive health checks that an endpoint must pass or fail for Amazon Route 53 to change the current status of the endpoint from unhealthy to healthy or vice versa. For more information, see [How Amazon Route 53 Determines Whether an Endpoint Is Healthy](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-determining-health-of-endpoints.html) in the *Amazon Route 53 Developer Guide* .
 
-        If you don't specify a value for `FailureThreshold` , the default value is three health checks.
+        `FailureThreshold` is not supported when you specify a value for `Type` of `RECOVERY_CONTROL` .
+
+        Otherwise, if you don't specify a value for `FailureThreshold` , the default value is three health checks.
         """
         fully_qualified_domain_name: NotRequired[pulumi.Input[_builtins.str]]
         """
@@ -263,6 +265,8 @@ if not MYPY:
         """
         Specify whether you want Amazon Route 53 to measure the latency between health checkers in multiple AWS regions and your endpoint, and to display CloudWatch latency graphs on the *Health Checks* page in the Route 53 console.
 
+        `MeasureLatency` is not supported when you specify a value for `Type` of `RECOVERY_CONTROL` .
+
         > You can't change the value of `MeasureLatency` after you create a health check.
         """
         port: NotRequired[pulumi.Input[_builtins.int]]
@@ -283,6 +287,8 @@ if not MYPY:
         """
         The number of seconds between the time that Amazon Route 53 gets a response from your endpoint and the time that it sends the next health check request. Each Route 53 health checker makes requests at this interval.
 
+        `RequestInterval` is not supported when you specify a value for `Type` of `RECOVERY_CONTROL` .
+
         > You can't change the value of `RequestInterval` after you create a health check. 
 
         If you don't specify a value for `RequestInterval` , the default value is `30` seconds.
@@ -360,7 +366,9 @@ class HealthCheckConfigPropertiesArgs:
                The SSL/TLS certificate on your endpoint includes a domain name in the `Common Name` field and possibly several more in the `Subject Alternative Names` field. One of the domain names in the certificate should match the value that you specify for `FullyQualifiedDomainName` . If the endpoint responds to the `client_hello` message with a certificate that does not include the domain name that you specified in `FullyQualifiedDomainName` , a health checker will retry the handshake. In the second attempt, the health checker will omit `FullyQualifiedDomainName` from the `client_hello` message.
         :param pulumi.Input[_builtins.int] failure_threshold: The number of consecutive health checks that an endpoint must pass or fail for Amazon Route 53 to change the current status of the endpoint from unhealthy to healthy or vice versa. For more information, see [How Amazon Route 53 Determines Whether an Endpoint Is Healthy](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-determining-health-of-endpoints.html) in the *Amazon Route 53 Developer Guide* .
                
-               If you don't specify a value for `FailureThreshold` , the default value is three health checks.
+               `FailureThreshold` is not supported when you specify a value for `Type` of `RECOVERY_CONTROL` .
+               
+               Otherwise, if you don't specify a value for `FailureThreshold` , the default value is three health checks.
         :param pulumi.Input[_builtins.str] fully_qualified_domain_name: Amazon Route 53 behavior depends on whether you specify a value for `IPAddress` .
                
                *If you specify a value for* `IPAddress` :
@@ -418,6 +426,8 @@ class HealthCheckConfigPropertiesArgs:
                When the value of `Type` is `CALCULATED` or `CLOUDWATCH_METRIC` , omit `IPAddress` .
         :param pulumi.Input[_builtins.bool] measure_latency: Specify whether you want Amazon Route 53 to measure the latency between health checkers in multiple AWS regions and your endpoint, and to display CloudWatch latency graphs on the *Health Checks* page in the Route 53 console.
                
+               `MeasureLatency` is not supported when you specify a value for `Type` of `RECOVERY_CONTROL` .
+               
                > You can't change the value of `MeasureLatency` after you create a health check.
         :param pulumi.Input[_builtins.int] port: The port on the endpoint that you want Amazon Route 53 to perform health checks on.
                
@@ -429,6 +439,8 @@ class HealthCheckConfigPropertiesArgs:
                If you update a health check to remove a region that has been performing health checks, Route 53 will briefly continue to perform checks from that region to ensure that some health checkers are always checking the endpoint (for example, if you replace three regions with four different regions).
         :param pulumi.Input[_builtins.int] request_interval: The number of seconds between the time that Amazon Route 53 gets a response from your endpoint and the time that it sends the next health check request. Each Route 53 health checker makes requests at this interval.
                
+               `RequestInterval` is not supported when you specify a value for `Type` of `RECOVERY_CONTROL` .
+               
                > You can't change the value of `RequestInterval` after you create a health check. 
                
                If you don't specify a value for `RequestInterval` , the default value is `30` seconds.
@@ -554,7 +566,9 @@ class HealthCheckConfigPropertiesArgs:
         """
         The number of consecutive health checks that an endpoint must pass or fail for Amazon Route 53 to change the current status of the endpoint from unhealthy to healthy or vice versa. For more information, see [How Amazon Route 53 Determines Whether an Endpoint Is Healthy](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-determining-health-of-endpoints.html) in the *Amazon Route 53 Developer Guide* .
 
-        If you don't specify a value for `FailureThreshold` , the default value is three health checks.
+        `FailureThreshold` is not supported when you specify a value for `Type` of `RECOVERY_CONTROL` .
+
+        Otherwise, if you don't specify a value for `FailureThreshold` , the default value is three health checks.
         """
         return pulumi.get(self, "failure_threshold")
 
@@ -678,6 +692,8 @@ class HealthCheckConfigPropertiesArgs:
         """
         Specify whether you want Amazon Route 53 to measure the latency between health checkers in multiple AWS regions and your endpoint, and to display CloudWatch latency graphs on the *Health Checks* page in the Route 53 console.
 
+        `MeasureLatency` is not supported when you specify a value for `Type` of `RECOVERY_CONTROL` .
+
         > You can't change the value of `MeasureLatency` after you create a health check.
         """
         return pulumi.get(self, "measure_latency")
@@ -722,6 +738,8 @@ class HealthCheckConfigPropertiesArgs:
         """
         The number of seconds between the time that Amazon Route 53 gets a response from your endpoint and the time that it sends the next health check request. Each Route 53 health checker makes requests at this interval.
 
+        `RequestInterval` is not supported when you specify a value for `Type` of `RECOVERY_CONTROL` .
+
         > You can't change the value of `RequestInterval` after you create a health check. 
 
         If you don't specify a value for `RequestInterval` , the default value is `30` seconds.