pulumi-aws 7.15.0__py3-none-any.whl → 7.16.0__py3-none-any.whl

pulumi_aws/dynamodb/outputs.py

@@ -16,6 +16,12 @@ from .. import _utilities
 from . import outputs
 
 __all__ = [
+    'GlobalSecondaryIndexKeySchema',
+    'GlobalSecondaryIndexOnDemandThroughput',
+    'GlobalSecondaryIndexProjection',
+    'GlobalSecondaryIndexProvisionedThroughput',
+    'GlobalSecondaryIndexTimeouts',
+    'GlobalSecondaryIndexWarmThroughput',
     'GlobalTableReplica',
     'TableAttribute',
     'TableExportIncrementalExportSpecification',
@@ -47,6 +53,315 @@ __all__ = [
     'GetTableWarmThroughputResult',
 ]
 
+@pulumi.output_type
+class GlobalSecondaryIndexKeySchema(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "attributeName":
+            suggest = "attribute_name"
+        elif key == "attributeType":
+            suggest = "attribute_type"
+        elif key == "keyType":
+            suggest = "key_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in GlobalSecondaryIndexKeySchema. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        GlobalSecondaryIndexKeySchema.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        GlobalSecondaryIndexKeySchema.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 attribute_name: _builtins.str,
+                 attribute_type: _builtins.str,
+                 key_type: _builtins.str):
+        """
+        :param _builtins.str attribute_name: Name of the attribute.
+        :param _builtins.str attribute_type: Type of the attribute in the index.
+               Valid values are `S` (string), `N` (number), or `B` (binary).
+        :param _builtins.str key_type: Key type.
+               Valid values are `HASH` or `RANGE`.
+        """
+        pulumi.set(__self__, "attribute_name", attribute_name)
+        pulumi.set(__self__, "attribute_type", attribute_type)
+        pulumi.set(__self__, "key_type", key_type)
+
+    @_builtins.property
+    @pulumi.getter(name="attributeName")
+    def attribute_name(self) -> _builtins.str:
+        """
+        Name of the attribute.
+        """
+        return pulumi.get(self, "attribute_name")
+
+    @_builtins.property
+    @pulumi.getter(name="attributeType")
+    def attribute_type(self) -> _builtins.str:
+        """
+        Type of the attribute in the index.
+        Valid values are `S` (string), `N` (number), or `B` (binary).
+        """
+        return pulumi.get(self, "attribute_type")
+
+    @_builtins.property
+    @pulumi.getter(name="keyType")
+    def key_type(self) -> _builtins.str:
+        """
+        Key type.
+        Valid values are `HASH` or `RANGE`.
+        """
+        return pulumi.get(self, "key_type")
+
+
+@pulumi.output_type
+class GlobalSecondaryIndexOnDemandThroughput(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "maxReadRequestUnits":
+            suggest = "max_read_request_units"
+        elif key == "maxWriteRequestUnits":
+            suggest = "max_write_request_units"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in GlobalSecondaryIndexOnDemandThroughput. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        GlobalSecondaryIndexOnDemandThroughput.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        GlobalSecondaryIndexOnDemandThroughput.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 max_read_request_units: Optional[_builtins.int] = None,
+                 max_write_request_units: Optional[_builtins.int] = None):
+        """
+        :param _builtins.int max_read_request_units: Maximum number of read request units for this index.
+        :param _builtins.int max_write_request_units: Maximum number of write request units for this index.
+        """
+        if max_read_request_units is not None:
+            pulumi.set(__self__, "max_read_request_units", max_read_request_units)
+        if max_write_request_units is not None:
+            pulumi.set(__self__, "max_write_request_units", max_write_request_units)
+
+    @_builtins.property
+    @pulumi.getter(name="maxReadRequestUnits")
+    def max_read_request_units(self) -> Optional[_builtins.int]:
+        """
+        Maximum number of read request units for this index.
+        """
+        return pulumi.get(self, "max_read_request_units")
+
+    @_builtins.property
+    @pulumi.getter(name="maxWriteRequestUnits")
+    def max_write_request_units(self) -> Optional[_builtins.int]:
+        """
+        Maximum number of write request units for this index.
+        """
+        return pulumi.get(self, "max_write_request_units")
+
+
+@pulumi.output_type
+class GlobalSecondaryIndexProjection(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "projectionType":
+            suggest = "projection_type"
+        elif key == "nonKeyAttributes":
+            suggest = "non_key_attributes"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in GlobalSecondaryIndexProjection. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        GlobalSecondaryIndexProjection.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        GlobalSecondaryIndexProjection.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 projection_type: _builtins.str,
+                 non_key_attributes: Optional[Sequence[_builtins.str]] = None):
+        """
+        :param _builtins.str projection_type: The set of attributes represented in the index.
+               One of `ALL`, `INCLUDE`, or `KEYS_ONLY`.
+        :param Sequence[_builtins.str] non_key_attributes: Specifies which additional attributes to include in the index.
+               Only valid when `projection_type` is `INCLUDE`.`
+        """
+        pulumi.set(__self__, "projection_type", projection_type)
+        if non_key_attributes is not None:
+            pulumi.set(__self__, "non_key_attributes", non_key_attributes)
+
+    @_builtins.property
+    @pulumi.getter(name="projectionType")
+    def projection_type(self) -> _builtins.str:
+        """
+        The set of attributes represented in the index.
+        One of `ALL`, `INCLUDE`, or `KEYS_ONLY`.
+        """
+        return pulumi.get(self, "projection_type")
+
+    @_builtins.property
+    @pulumi.getter(name="nonKeyAttributes")
+    def non_key_attributes(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        Specifies which additional attributes to include in the index.
+        Only valid when `projection_type` is `INCLUDE`.`
+        """
+        return pulumi.get(self, "non_key_attributes")
+
+
+@pulumi.output_type
+class GlobalSecondaryIndexProvisionedThroughput(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "readCapacityUnits":
+            suggest = "read_capacity_units"
+        elif key == "writeCapacityUnits":
+            suggest = "write_capacity_units"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in GlobalSecondaryIndexProvisionedThroughput. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        GlobalSecondaryIndexProvisionedThroughput.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        GlobalSecondaryIndexProvisionedThroughput.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 read_capacity_units: Optional[_builtins.int] = None,
+                 write_capacity_units: Optional[_builtins.int] = None):
+        """
+        :param _builtins.int read_capacity_units: Number of read capacity units for this index.
+        :param _builtins.int write_capacity_units: Number of write capacity units for this index.
+        """
+        if read_capacity_units is not None:
+            pulumi.set(__self__, "read_capacity_units", read_capacity_units)
+        if write_capacity_units is not None:
+            pulumi.set(__self__, "write_capacity_units", write_capacity_units)
+
+    @_builtins.property
+    @pulumi.getter(name="readCapacityUnits")
+    def read_capacity_units(self) -> Optional[_builtins.int]:
+        """
+        Number of read capacity units for this index.
+        """
+        return pulumi.get(self, "read_capacity_units")
+
+    @_builtins.property
+    @pulumi.getter(name="writeCapacityUnits")
+    def write_capacity_units(self) -> Optional[_builtins.int]:
+        """
+        Number of write capacity units for this index.
+        """
+        return pulumi.get(self, "write_capacity_units")
+
+
+@pulumi.output_type
+class GlobalSecondaryIndexTimeouts(dict):
+    def __init__(__self__, *,
+                 create: Optional[_builtins.str] = None,
+                 delete: Optional[_builtins.str] = None,
+                 update: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str create: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
+        :param _builtins.str delete: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
+        :param _builtins.str update: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
+        """
+        if create is not None:
+            pulumi.set(__self__, "create", create)
+        if delete is not None:
+            pulumi.set(__self__, "delete", delete)
+        if update is not None:
+            pulumi.set(__self__, "update", update)
+
+    @_builtins.property
+    @pulumi.getter
+    def create(self) -> Optional[_builtins.str]:
+        """
+        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
+        """
+        return pulumi.get(self, "create")
+
+    @_builtins.property
+    @pulumi.getter
+    def delete(self) -> Optional[_builtins.str]:
+        """
+        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
+        """
+        return pulumi.get(self, "delete")
+
+    @_builtins.property
+    @pulumi.getter
+    def update(self) -> Optional[_builtins.str]:
+        """
+        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
+        """
+        return pulumi.get(self, "update")
+
+
+@pulumi.output_type
+class GlobalSecondaryIndexWarmThroughput(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "readUnitsPerSecond":
+            suggest = "read_units_per_second"
+        elif key == "writeUnitsPerSecond":
+            suggest = "write_units_per_second"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in GlobalSecondaryIndexWarmThroughput. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        GlobalSecondaryIndexWarmThroughput.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        GlobalSecondaryIndexWarmThroughput.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 read_units_per_second: _builtins.int,
+                 write_units_per_second: _builtins.int):
+        """
+        :param _builtins.int read_units_per_second: Number of read operations this index can instantaneously support.
+        :param _builtins.int write_units_per_second: Number of write operations this index can instantaneously support.
+        """
+        pulumi.set(__self__, "read_units_per_second", read_units_per_second)
+        pulumi.set(__self__, "write_units_per_second", write_units_per_second)
+
+    @_builtins.property
+    @pulumi.getter(name="readUnitsPerSecond")
+    def read_units_per_second(self) -> _builtins.int:
+        """
+        Number of read operations this index can instantaneously support.
+        """
+        return pulumi.get(self, "read_units_per_second")
+
+    @_builtins.property
+    @pulumi.getter(name="writeUnitsPerSecond")
+    def write_units_per_second(self) -> _builtins.int:
+        """
+        Number of write operations this index can instantaneously support.
+        """
+        return pulumi.get(self, "write_units_per_second")
+
+
 @pulumi.output_type
 class GlobalTableReplica(dict):
     @staticmethod

pulumi_aws/dynamodb/table.py

@@ -1019,6 +1019,8 @@ class Table(pulumi.CustomResource):
 
         > **Note:** When using dynamodb.TableReplica with this resource, use `lifecycle` `ignore_changes` for `replica`, _e.g._, `lifecycle { ignore_changes = [replica] }`.
 
+        > **Note:** If autoscaling creates drift for your `global_secondary_index` blocks and/or more granular `lifecycle` management for GSIs, we recommend using the new **experimental** resource `dynamodb.GlobalSecondaryIndex`.
+
         ## DynamoDB Table attributes
 
         Only define attributes on the table object that are going to be used as:
@@ -1028,6 +1030,8 @@ class Table(pulumi.CustomResource):
 
         The DynamoDB API expects attribute structure (name and type) to be passed along when creating or updating GSI/LSIs or creating the initial table. In these cases it expects the Hash / Range keys to be provided. Because these get re-used in numerous places (i.e the table's range key could be a part of one or more GSIs), they are stored on the table object to prevent duplication and increase consistency. If you add attributes here that are not used in these scenarios it can cause an infinite loop in planning.
 
+        > **Note:** When using the `dynamodb.GlobalSecondaryIndex` resource, you do not need to define the attributes for externally managed GSIs in the `dynamodb.Table` resource.
+
         ## Example Usage
 
         ### Basic Example
@@ -1269,6 +1273,8 @@ class Table(pulumi.CustomResource):
 
         > **Note:** When using dynamodb.TableReplica with this resource, use `lifecycle` `ignore_changes` for `replica`, _e.g._, `lifecycle { ignore_changes = [replica] }`.
 
+        > **Note:** If autoscaling creates drift for your `global_secondary_index` blocks and/or more granular `lifecycle` management for GSIs, we recommend using the new **experimental** resource `dynamodb.GlobalSecondaryIndex`.
+
         ## DynamoDB Table attributes
 
         Only define attributes on the table object that are going to be used as:
@@ -1278,6 +1284,8 @@ class Table(pulumi.CustomResource):
 
         The DynamoDB API expects attribute structure (name and type) to be passed along when creating or updating GSI/LSIs or creating the initial table. In these cases it expects the Hash / Range keys to be provided. Because these get re-used in numerous places (i.e the table's range key could be a part of one or more GSIs), they are stored on the table object to prevent duplication and increase consistency. If you add attributes here that are not used in these scenarios it can cause an infinite loop in planning.
 
+        > **Note:** When using the `dynamodb.GlobalSecondaryIndex` resource, you do not need to define the attributes for externally managed GSIs in the `dynamodb.Table` resource.
+
         ## Example Usage
 
         ### Basic Example
@@ -1709,7 +1717,7 @@ class Table(pulumi.CustomResource):
 
     @_builtins.property
     @pulumi.getter(name="globalSecondaryIndexes")
-    def global_secondary_indexes(self) -> pulumi.Output[Optional[Sequence['outputs.TableGlobalSecondaryIndex']]]:
+    def global_secondary_indexes(self) -> pulumi.Output[Sequence['outputs.TableGlobalSecondaryIndex']]:
         """
         Describe a GSI for the table; subject to the normal limits on the number of GSIs, projected attributes, etc. See below.
         """

pulumi_aws/ec2/_inputs.py

@@ -22499,7 +22499,15 @@ if not MYPY:
         """
         private_dns_only_for_inbound_resolver_endpoint: NotRequired[pulumi.Input[_builtins.bool]]
         """
-        Indicates whether to enable private DNS only for inbound endpoints. This option is available only for services that support both gateway and interface endpoints. It routes traffic that originates from the VPC to the gateway endpoint and traffic that originates from on-premises to the interface endpoint. Default is `false`. Can only be specified if private_dns_enabled is `true`.
+        Boolean indicating whether to enable private DNS only for inbound endpoints. This option is available only for interface endpoints of services that support both gateway and interface endpoints. A gateway endpoint for the same service must be created before an interface endpoint is created. Traffic originating from the VPC is routed to the gateway endpoint, while traffic originating from on-premises is routed to the interface endpoint. Defaults to `false`. This argument can be specified only if `private_dns_enabled` is `true`.
+        """
+        private_dns_preference: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Preference for which private domains have a private hosted zone created for and associated with the specified VPC. Valid values are `ALL_DOMAINS`, `VERIFIED_DOMAINS_ONLY`, `VERIFIED_DOMAINS_AND_SPECIFIED_DOMAINS`, and `SPECIFIED_DOMAINS_ONLY`. Only supported when `private_dns_enabled` is `true` and when the `vpc_endpoint_type` is `ServiceNetwork` or `Resource`.
+        """
+        private_dns_specified_domains: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
+        """
+        List of private domains to create private hosted zones for and associate with the specified VPC. Must be specified when `private_dns_enabled` is `true` and `private_dns_preference` is set to either `VERIFIED_DOMAINS_AND_SPECIFIED_DOMAINS` or `SPECIFIED_DOMAINS_ONLY`. In all other cases, this argument must not be specified.
         """
 elif False:
     VpcEndpointDnsOptionsArgsDict: TypeAlias = Mapping[str, Any]
@@ -22508,15 +22516,23 @@ elif False:
 class VpcEndpointDnsOptionsArgs:
     def __init__(__self__, *,
                  dns_record_ip_type: Optional[pulumi.Input[_builtins.str]] = None,
-                 private_dns_only_for_inbound_resolver_endpoint: Optional[pulumi.Input[_builtins.bool]] = None):
+                 private_dns_only_for_inbound_resolver_endpoint: Optional[pulumi.Input[_builtins.bool]] = None,
+                 private_dns_preference: Optional[pulumi.Input[_builtins.str]] = None,
+                 private_dns_specified_domains: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
         """
         :param pulumi.Input[_builtins.str] dns_record_ip_type: The DNS records created for the endpoint. Valid values are `ipv4`, `dualstack`, `service-defined`, and `ipv6`.
-        :param pulumi.Input[_builtins.bool] private_dns_only_for_inbound_resolver_endpoint: Indicates whether to enable private DNS only for inbound endpoints. This option is available only for services that support both gateway and interface endpoints. It routes traffic that originates from the VPC to the gateway endpoint and traffic that originates from on-premises to the interface endpoint. Default is `false`. Can only be specified if private_dns_enabled is `true`.
+        :param pulumi.Input[_builtins.bool] private_dns_only_for_inbound_resolver_endpoint: Boolean indicating whether to enable private DNS only for inbound endpoints. This option is available only for interface endpoints of services that support both gateway and interface endpoints. A gateway endpoint for the same service must be created before an interface endpoint is created. Traffic originating from the VPC is routed to the gateway endpoint, while traffic originating from on-premises is routed to the interface endpoint. Defaults to `false`. This argument can be specified only if `private_dns_enabled` is `true`.
+        :param pulumi.Input[_builtins.str] private_dns_preference: Preference for which private domains have a private hosted zone created for and associated with the specified VPC. Valid values are `ALL_DOMAINS`, `VERIFIED_DOMAINS_ONLY`, `VERIFIED_DOMAINS_AND_SPECIFIED_DOMAINS`, and `SPECIFIED_DOMAINS_ONLY`. Only supported when `private_dns_enabled` is `true` and when the `vpc_endpoint_type` is `ServiceNetwork` or `Resource`.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] private_dns_specified_domains: List of private domains to create private hosted zones for and associate with the specified VPC. Must be specified when `private_dns_enabled` is `true` and `private_dns_preference` is set to either `VERIFIED_DOMAINS_AND_SPECIFIED_DOMAINS` or `SPECIFIED_DOMAINS_ONLY`. In all other cases, this argument must not be specified.
         """
         if dns_record_ip_type is not None:
             pulumi.set(__self__, "dns_record_ip_type", dns_record_ip_type)
         if private_dns_only_for_inbound_resolver_endpoint is not None:
             pulumi.set(__self__, "private_dns_only_for_inbound_resolver_endpoint", private_dns_only_for_inbound_resolver_endpoint)
+        if private_dns_preference is not None:
+            pulumi.set(__self__, "private_dns_preference", private_dns_preference)
+        if private_dns_specified_domains is not None:
+            pulumi.set(__self__, "private_dns_specified_domains", private_dns_specified_domains)
 
     @_builtins.property
     @pulumi.getter(name="dnsRecordIpType")
@@ -22534,7 +22550,7 @@ class VpcEndpointDnsOptionsArgs:
     @pulumi.getter(name="privateDnsOnlyForInboundResolverEndpoint")
     def private_dns_only_for_inbound_resolver_endpoint(self) -> Optional[pulumi.Input[_builtins.bool]]:
         """
-        Indicates whether to enable private DNS only for inbound endpoints. This option is available only for services that support both gateway and interface endpoints. It routes traffic that originates from the VPC to the gateway endpoint and traffic that originates from on-premises to the interface endpoint. Default is `false`. Can only be specified if private_dns_enabled is `true`.
+        Boolean indicating whether to enable private DNS only for inbound endpoints. This option is available only for interface endpoints of services that support both gateway and interface endpoints. A gateway endpoint for the same service must be created before an interface endpoint is created. Traffic originating from the VPC is routed to the gateway endpoint, while traffic originating from on-premises is routed to the interface endpoint. Defaults to `false`. This argument can be specified only if `private_dns_enabled` is `true`.
         """
         return pulumi.get(self, "private_dns_only_for_inbound_resolver_endpoint")
 
@@ -22542,6 +22558,30 @@ class VpcEndpointDnsOptionsArgs:
     def private_dns_only_for_inbound_resolver_endpoint(self, value: Optional[pulumi.Input[_builtins.bool]]):
         pulumi.set(self, "private_dns_only_for_inbound_resolver_endpoint", value)
 
+    @_builtins.property
+    @pulumi.getter(name="privateDnsPreference")
+    def private_dns_preference(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Preference for which private domains have a private hosted zone created for and associated with the specified VPC. Valid values are `ALL_DOMAINS`, `VERIFIED_DOMAINS_ONLY`, `VERIFIED_DOMAINS_AND_SPECIFIED_DOMAINS`, and `SPECIFIED_DOMAINS_ONLY`. Only supported when `private_dns_enabled` is `true` and when the `vpc_endpoint_type` is `ServiceNetwork` or `Resource`.
+        """
+        return pulumi.get(self, "private_dns_preference")
+
+    @private_dns_preference.setter
+    def private_dns_preference(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "private_dns_preference", value)
+
+    @_builtins.property
+    @pulumi.getter(name="privateDnsSpecifiedDomains")
+    def private_dns_specified_domains(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
+        """
+        List of private domains to create private hosted zones for and associate with the specified VPC. Must be specified when `private_dns_enabled` is `true` and `private_dns_preference` is set to either `VERIFIED_DOMAINS_AND_SPECIFIED_DOMAINS` or `SPECIFIED_DOMAINS_ONLY`. In all other cases, this argument must not be specified.
+        """
+        return pulumi.get(self, "private_dns_specified_domains")
+
+    @private_dns_specified_domains.setter
+    def private_dns_specified_domains(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
+        pulumi.set(self, "private_dns_specified_domains", value)
+
 
 if not MYPY:
     class VpcEndpointServicePrivateDnsNameConfigurationArgsDict(TypedDict):

pulumi_aws/ec2/get_vpc_endpoint.py

@@ -28,7 +28,7 @@ class GetVpcEndpointResult:
     """
     A collection of values returned by getVpcEndpoint.
     """
-    def __init__(__self__, arn=None, cidr_blocks=None, dns_entries=None, dns_options=None, filters=None, id=None, ip_address_type=None, network_interface_ids=None, owner_id=None, policy=None, prefix_list_id=None, private_dns_enabled=None, region=None, requester_managed=None, route_table_ids=None, security_group_ids=None, service_name=None, state=None, subnet_ids=None, tags=None, vpc_endpoint_type=None, vpc_id=None):
+    def __init__(__self__, arn=None, cidr_blocks=None, dns_entries=None, dns_options=None, filters=None, id=None, ip_address_type=None, network_interface_ids=None, owner_id=None, policy=None, prefix_list_id=None, private_dns_enabled=None, region=None, requester_managed=None, route_table_ids=None, security_group_ids=None, service_name=None, service_region=None, state=None, subnet_ids=None, tags=None, vpc_endpoint_type=None, vpc_id=None):
         if arn and not isinstance(arn, str):
             raise TypeError("Expected argument 'arn' to be a str")
         pulumi.set(__self__, "arn", arn)
@@ -80,6 +80,9 @@ class GetVpcEndpointResult:
         if service_name and not isinstance(service_name, str):
             raise TypeError("Expected argument 'service_name' to be a str")
         pulumi.set(__self__, "service_name", service_name)
+        if service_region and not isinstance(service_region, str):
+            raise TypeError("Expected argument 'service_region' to be a str")
+        pulumi.set(__self__, "service_region", service_region)
         if state and not isinstance(state, str):
             raise TypeError("Expected argument 'state' to be a str")
         pulumi.set(__self__, "state", state)
@@ -217,6 +220,11 @@ class GetVpcEndpointResult:
     def service_name(self) -> _builtins.str:
         return pulumi.get(self, "service_name")
 
+    @_builtins.property
+    @pulumi.getter(name="serviceRegion")
+    def service_region(self) -> _builtins.str:
+        return pulumi.get(self, "service_region")
+
     @_builtins.property
     @pulumi.getter
     def state(self) -> _builtins.str:
@@ -238,9 +246,6 @@ class GetVpcEndpointResult:
     @_builtins.property
     @pulumi.getter(name="vpcEndpointType")
     def vpc_endpoint_type(self) -> _builtins.str:
-        """
-        VPC Endpoint type, `Gateway` or `Interface`.
-        """
         return pulumi.get(self, "vpc_endpoint_type")
 
     @_builtins.property
@@ -272,6 +277,7 @@ class AwaitableGetVpcEndpointResult(GetVpcEndpointResult):
             route_table_ids=self.route_table_ids,
             security_group_ids=self.security_group_ids,
             service_name=self.service_name,
+            service_region=self.service_region,
             state=self.state,
             subnet_ids=self.subnet_ids,
             tags=self.tags,
@@ -283,8 +289,10 @@ def get_vpc_endpoint(filters: Optional[Sequence[Union['GetVpcEndpointFilterArgs'
                      id: Optional[_builtins.str] = None,
                      region: Optional[_builtins.str] = None,
                      service_name: Optional[_builtins.str] = None,
+                     service_region: Optional[_builtins.str] = None,
                      state: Optional[_builtins.str] = None,
                      tags: Optional[Mapping[str, _builtins.str]] = None,
+                     vpc_endpoint_type: Optional[_builtins.str] = None,
                      vpc_id: Optional[_builtins.str] = None,
                      opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetVpcEndpointResult:
     """
@@ -310,9 +318,11 @@ def get_vpc_endpoint(filters: Optional[Sequence[Union['GetVpcEndpointFilterArgs'
     :param _builtins.str id: ID of the specific VPC Endpoint to retrieve.
     :param _builtins.str region: Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
     :param _builtins.str service_name: Service name of the specific VPC Endpoint to retrieve. For AWS services the service name is usually in the form `com.amazonaws.<region>.<service>` (the SageMaker AI Notebook service is an exception to this rule, the service name is in the form `aws.sagemaker.<region>.notebook`).
+    :param _builtins.str service_region: AWS region of the VPC Endpoint Service. Applicable for endpoints of type `Interface`.
     :param _builtins.str state: State of the specific VPC Endpoint to retrieve.
     :param Mapping[str, _builtins.str] tags: Map of tags, each pair of which must exactly match
            a pair on the specific VPC Endpoint to retrieve.
+    :param _builtins.str vpc_endpoint_type: VPC Endpoint type. Valid values are `Interface`, `Gateway`, `GatewayLoadBalancer`, `Resource`, and `ServiceNetwork`.
     :param _builtins.str vpc_id: ID of the VPC in which the specific VPC Endpoint is used.
            
            The arguments of this data source act as filters for querying the available VPC endpoints.
@@ -323,8 +333,10 @@ def get_vpc_endpoint(filters: Optional[Sequence[Union['GetVpcEndpointFilterArgs'
     __args__['id'] = id
     __args__['region'] = region
     __args__['serviceName'] = service_name
+    __args__['serviceRegion'] = service_region
     __args__['state'] = state
     __args__['tags'] = tags
+    __args__['vpcEndpointType'] = vpc_endpoint_type
     __args__['vpcId'] = vpc_id
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke('aws:ec2/getVpcEndpoint:getVpcEndpoint', __args__, opts=opts, typ=GetVpcEndpointResult).value
@@ -347,6 +359,7 @@ def get_vpc_endpoint(filters: Optional[Sequence[Union['GetVpcEndpointFilterArgs'
         route_table_ids=pulumi.get(__ret__, 'route_table_ids'),
         security_group_ids=pulumi.get(__ret__, 'security_group_ids'),
         service_name=pulumi.get(__ret__, 'service_name'),
+        service_region=pulumi.get(__ret__, 'service_region'),
         state=pulumi.get(__ret__, 'state'),
         subnet_ids=pulumi.get(__ret__, 'subnet_ids'),
         tags=pulumi.get(__ret__, 'tags'),
@@ -356,8 +369,10 @@ def get_vpc_endpoint_output(filters: Optional[pulumi.Input[Optional[Sequence[Uni
                             id: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
                             region: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
                             service_name: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
+                            service_region: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
                             state: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
                             tags: Optional[pulumi.Input[Optional[Mapping[str, _builtins.str]]]] = None,
+                            vpc_endpoint_type: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
                             vpc_id: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
                             opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetVpcEndpointResult]:
     """
@@ -383,9 +398,11 @@ def get_vpc_endpoint_output(filters: Optional[pulumi.Input[Optional[Sequence[Uni
     :param _builtins.str id: ID of the specific VPC Endpoint to retrieve.
     :param _builtins.str region: Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
     :param _builtins.str service_name: Service name of the specific VPC Endpoint to retrieve. For AWS services the service name is usually in the form `com.amazonaws.<region>.<service>` (the SageMaker AI Notebook service is an exception to this rule, the service name is in the form `aws.sagemaker.<region>.notebook`).
+    :param _builtins.str service_region: AWS region of the VPC Endpoint Service. Applicable for endpoints of type `Interface`.
     :param _builtins.str state: State of the specific VPC Endpoint to retrieve.
     :param Mapping[str, _builtins.str] tags: Map of tags, each pair of which must exactly match
            a pair on the specific VPC Endpoint to retrieve.
+    :param _builtins.str vpc_endpoint_type: VPC Endpoint type. Valid values are `Interface`, `Gateway`, `GatewayLoadBalancer`, `Resource`, and `ServiceNetwork`.
     :param _builtins.str vpc_id: ID of the VPC in which the specific VPC Endpoint is used.
            
            The arguments of this data source act as filters for querying the available VPC endpoints.
@@ -396,8 +413,10 @@ def get_vpc_endpoint_output(filters: Optional[pulumi.Input[Optional[Sequence[Uni
     __args__['id'] = id
     __args__['region'] = region
     __args__['serviceName'] = service_name
+    __args__['serviceRegion'] = service_region
     __args__['state'] = state
     __args__['tags'] = tags
+    __args__['vpcEndpointType'] = vpc_endpoint_type
     __args__['vpcId'] = vpc_id
     opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('aws:ec2/getVpcEndpoint:getVpcEndpoint', __args__, opts=opts, typ=GetVpcEndpointResult)
@@ -419,6 +438,7 @@ def get_vpc_endpoint_output(filters: Optional[pulumi.Input[Optional[Sequence[Uni
         route_table_ids=pulumi.get(__response__, 'route_table_ids'),
         security_group_ids=pulumi.get(__response__, 'security_group_ids'),
         service_name=pulumi.get(__response__, 'service_name'),
+        service_region=pulumi.get(__response__, 'service_region'),
         state=pulumi.get(__response__, 'state'),
         subnet_ids=pulumi.get(__response__, 'subnet_ids'),
         tags=pulumi.get(__response__, 'tags'),