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

pulumi_aws/redshift/outputs.py

@@ -19,6 +19,14 @@ __all__ = [
     'ClusterClusterNode',
     'EndpointAccessVpcEndpoint',
     'EndpointAccessVpcEndpointNetworkInterface',
+    'IdcApplicationAuthorizedTokenIssuer',
+    'IdcApplicationServiceIntegration',
+    'IdcApplicationServiceIntegrationLakeFormation',
+    'IdcApplicationServiceIntegrationLakeFormationLakeFormationQuery',
+    'IdcApplicationServiceIntegrationRedshift',
+    'IdcApplicationServiceIntegrationRedshiftConnect',
+    'IdcApplicationServiceIntegrationS3AccessGrants',
+    'IdcApplicationServiceIntegrationS3AccessGrantsReadWriteAccess',
     'IntegrationTimeouts',
     'ParameterGroupParameter',
     'ScheduledActionTargetAction',
@@ -236,6 +244,263 @@ class EndpointAccessVpcEndpointNetworkInterface(dict):
         return pulumi.get(self, "subnet_id")
 
 
+@pulumi.output_type
+class IdcApplicationAuthorizedTokenIssuer(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "authorizedAudiencesLists":
+            suggest = "authorized_audiences_lists"
+        elif key == "trustedTokenIssuerArn":
+            suggest = "trusted_token_issuer_arn"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in IdcApplicationAuthorizedTokenIssuer. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        IdcApplicationAuthorizedTokenIssuer.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        IdcApplicationAuthorizedTokenIssuer.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 authorized_audiences_lists: Optional[Sequence[_builtins.str]] = None,
+                 trusted_token_issuer_arn: Optional[_builtins.str] = None):
+        """
+        :param Sequence[_builtins.str] authorized_audiences_lists: List of audiences for the authorized token issuer for integrating Amazon Redshift with IDC Identity Center.
+        :param _builtins.str trusted_token_issuer_arn: ARN for the authorized token issuer for integrating Amazon Redshift with IDC Identity Center.
+        """
+        if authorized_audiences_lists is not None:
+            pulumi.set(__self__, "authorized_audiences_lists", authorized_audiences_lists)
+        if trusted_token_issuer_arn is not None:
+            pulumi.set(__self__, "trusted_token_issuer_arn", trusted_token_issuer_arn)
+
+    @_builtins.property
+    @pulumi.getter(name="authorizedAudiencesLists")
+    def authorized_audiences_lists(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        List of audiences for the authorized token issuer for integrating Amazon Redshift with IDC Identity Center.
+        """
+        return pulumi.get(self, "authorized_audiences_lists")
+
+    @_builtins.property
+    @pulumi.getter(name="trustedTokenIssuerArn")
+    def trusted_token_issuer_arn(self) -> Optional[_builtins.str]:
+        """
+        ARN for the authorized token issuer for integrating Amazon Redshift with IDC Identity Center.
+        """
+        return pulumi.get(self, "trusted_token_issuer_arn")
+
+
+@pulumi.output_type
+class IdcApplicationServiceIntegration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "lakeFormation":
+            suggest = "lake_formation"
+        elif key == "s3AccessGrants":
+            suggest = "s3_access_grants"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in IdcApplicationServiceIntegration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        IdcApplicationServiceIntegration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        IdcApplicationServiceIntegration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 lake_formation: Optional['outputs.IdcApplicationServiceIntegrationLakeFormation'] = None,
+                 redshift: Optional['outputs.IdcApplicationServiceIntegrationRedshift'] = None,
+                 s3_access_grants: Optional['outputs.IdcApplicationServiceIntegrationS3AccessGrants'] = None):
+        """
+        :param 'IdcApplicationServiceIntegrationLakeFormationArgs' lake_formation: List of scopes set up for Lake Formation integration. Refer to the lake_formation documentation for more details.
+        :param 'IdcApplicationServiceIntegrationRedshiftArgs' redshift: List of scopes set up for Redshift integration. Refer to the redshift documentation for more details.
+        :param 'IdcApplicationServiceIntegrationS3AccessGrantsArgs' s3_access_grants: List of scopes set up for S3 Access Grants integration. Refer to the s3_access_grants documentation for more details.
+        """
+        if lake_formation is not None:
+            pulumi.set(__self__, "lake_formation", lake_formation)
+        if redshift is not None:
+            pulumi.set(__self__, "redshift", redshift)
+        if s3_access_grants is not None:
+            pulumi.set(__self__, "s3_access_grants", s3_access_grants)
+
+    @_builtins.property
+    @pulumi.getter(name="lakeFormation")
+    def lake_formation(self) -> Optional['outputs.IdcApplicationServiceIntegrationLakeFormation']:
+        """
+        List of scopes set up for Lake Formation integration. Refer to the lake_formation documentation for more details.
+        """
+        return pulumi.get(self, "lake_formation")
+
+    @_builtins.property
+    @pulumi.getter
+    def redshift(self) -> Optional['outputs.IdcApplicationServiceIntegrationRedshift']:
+        """
+        List of scopes set up for Redshift integration. Refer to the redshift documentation for more details.
+        """
+        return pulumi.get(self, "redshift")
+
+    @_builtins.property
+    @pulumi.getter(name="s3AccessGrants")
+    def s3_access_grants(self) -> Optional['outputs.IdcApplicationServiceIntegrationS3AccessGrants']:
+        """
+        List of scopes set up for S3 Access Grants integration. Refer to the s3_access_grants documentation for more details.
+        """
+        return pulumi.get(self, "s3_access_grants")
+
+
+@pulumi.output_type
+class IdcApplicationServiceIntegrationLakeFormation(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "lakeFormationQuery":
+            suggest = "lake_formation_query"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in IdcApplicationServiceIntegrationLakeFormation. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        IdcApplicationServiceIntegrationLakeFormation.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        IdcApplicationServiceIntegrationLakeFormation.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 lake_formation_query: Optional['outputs.IdcApplicationServiceIntegrationLakeFormationLakeFormationQuery'] = None):
+        """
+        :param 'IdcApplicationServiceIntegrationLakeFormationLakeFormationQueryArgs' lake_formation_query: Lake formation scope.
+        """
+        if lake_formation_query is not None:
+            pulumi.set(__self__, "lake_formation_query", lake_formation_query)
+
+    @_builtins.property
+    @pulumi.getter(name="lakeFormationQuery")
+    def lake_formation_query(self) -> Optional['outputs.IdcApplicationServiceIntegrationLakeFormationLakeFormationQuery']:
+        """
+        Lake formation scope.
+        """
+        return pulumi.get(self, "lake_formation_query")
+
+
+@pulumi.output_type
+class IdcApplicationServiceIntegrationLakeFormationLakeFormationQuery(dict):
+    def __init__(__self__, *,
+                 authorization: _builtins.str):
+        """
+        :param _builtins.str authorization: Determines whether the query scope is enabled or disabled.
+        """
+        pulumi.set(__self__, "authorization", authorization)
+
+    @_builtins.property
+    @pulumi.getter
+    def authorization(self) -> _builtins.str:
+        """
+        Determines whether the query scope is enabled or disabled.
+        """
+        return pulumi.get(self, "authorization")
+
+
+@pulumi.output_type
+class IdcApplicationServiceIntegrationRedshift(dict):
+    def __init__(__self__, *,
+                 connect: Optional['outputs.IdcApplicationServiceIntegrationRedshiftConnect'] = None):
+        """
+        :param 'IdcApplicationServiceIntegrationRedshiftConnectArgs' connect: Amazon Redshift connect service integration scope.
+        """
+        if connect is not None:
+            pulumi.set(__self__, "connect", connect)
+
+    @_builtins.property
+    @pulumi.getter
+    def connect(self) -> Optional['outputs.IdcApplicationServiceIntegrationRedshiftConnect']:
+        """
+        Amazon Redshift connect service integration scope.
+        """
+        return pulumi.get(self, "connect")
+
+
+@pulumi.output_type
+class IdcApplicationServiceIntegrationRedshiftConnect(dict):
+    def __init__(__self__, *,
+                 authorization: _builtins.str):
+        """
+        :param _builtins.str authorization: Determines whether the connect integration is enabled or disabled.
+        """
+        pulumi.set(__self__, "authorization", authorization)
+
+    @_builtins.property
+    @pulumi.getter
+    def authorization(self) -> _builtins.str:
+        """
+        Determines whether the connect integration is enabled or disabled.
+        """
+        return pulumi.get(self, "authorization")
+
+
+@pulumi.output_type
+class IdcApplicationServiceIntegrationS3AccessGrants(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "readWriteAccess":
+            suggest = "read_write_access"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in IdcApplicationServiceIntegrationS3AccessGrants. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        IdcApplicationServiceIntegrationS3AccessGrants.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        IdcApplicationServiceIntegrationS3AccessGrants.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 read_write_access: Optional['outputs.IdcApplicationServiceIntegrationS3AccessGrantsReadWriteAccess'] = None):
+        """
+        :param 'IdcApplicationServiceIntegrationS3AccessGrantsReadWriteAccessArgs' read_write_access: S3 Access grants integration scope.
+        """
+        if read_write_access is not None:
+            pulumi.set(__self__, "read_write_access", read_write_access)
+
+    @_builtins.property
+    @pulumi.getter(name="readWriteAccess")
+    def read_write_access(self) -> Optional['outputs.IdcApplicationServiceIntegrationS3AccessGrantsReadWriteAccess']:
+        """
+        S3 Access grants integration scope.
+        """
+        return pulumi.get(self, "read_write_access")
+
+
+@pulumi.output_type
+class IdcApplicationServiceIntegrationS3AccessGrantsReadWriteAccess(dict):
+    def __init__(__self__, *,
+                 authorization: _builtins.str):
+        """
+        :param _builtins.str authorization: Determines whether read/write scope is enabled or disabled.
+        """
+        pulumi.set(__self__, "authorization", authorization)
+
+    @_builtins.property
+    @pulumi.getter
+    def authorization(self) -> _builtins.str:
+        """
+        Determines whether read/write scope is enabled or disabled.
+        """
+        return pulumi.get(self, "authorization")
+
+
 @pulumi.output_type
 class IntegrationTimeouts(dict):
     def __init__(__self__, *,

pulumi_aws/route53/get_resolver_firewall_rules.py

@@ -50,11 +50,17 @@ class GetResolverFirewallRulesResult:
     @_builtins.property
     @pulumi.getter
     def action(self) -> Optional[_builtins.str]:
+        """
+        The action that DNS Firewall should take on a DNS query when it matches one of the domains in the rule's domain list, or a threat in a DNS Firewall Advanced rule.
+        """
         return pulumi.get(self, "action")
 
     @_builtins.property
     @pulumi.getter(name="firewallRuleGroupId")
     def firewall_rule_group_id(self) -> _builtins.str:
+        """
+        The unique identifier of the firewall rule group.
+        """
         return pulumi.get(self, "firewall_rule_group_id")
 
     @_builtins.property
@@ -76,6 +82,9 @@ class GetResolverFirewallRulesResult:
     @_builtins.property
     @pulumi.getter
     def priority(self) -> Optional[_builtins.int]:
+        """
+        The priority of the rule in the rule group.
+        """
         return pulumi.get(self, "priority")
 
     @_builtins.property

pulumi_aws/route53/get_resolver_rule.py

@@ -13,6 +13,7 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
+from . import outputs
 
 __all__ = [
     'GetResolverRuleResult',
@@ -26,7 +27,7 @@ class GetResolverRuleResult:
     """
     A collection of values returned by getResolverRule.
     """
-    def __init__(__self__, arn=None, domain_name=None, id=None, name=None, owner_id=None, region=None, resolver_endpoint_id=None, resolver_rule_id=None, rule_type=None, share_status=None, tags=None):
+    def __init__(__self__, arn=None, domain_name=None, id=None, name=None, owner_id=None, region=None, resolver_endpoint_id=None, resolver_rule_id=None, rule_type=None, share_status=None, tags=None, target_ips=None):
         if arn and not isinstance(arn, str):
             raise TypeError("Expected argument 'arn' to be a str")
         pulumi.set(__self__, "arn", arn)
@@ -60,6 +61,9 @@ class GetResolverRuleResult:
         if tags and not isinstance(tags, dict):
             raise TypeError("Expected argument 'tags' to be a dict")
         pulumi.set(__self__, "tags", tags)
+        if target_ips and not isinstance(target_ips, list):
+            raise TypeError("Expected argument 'target_ips' to be a list")
+        pulumi.set(__self__, "target_ips", target_ips)
 
     @_builtins.property
     @pulumi.getter
@@ -132,6 +136,14 @@ class GetResolverRuleResult:
         """
         return pulumi.get(self, "tags")
 
+    @_builtins.property
+    @pulumi.getter(name="targetIps")
+    def target_ips(self) -> Sequence['outputs.GetResolverRuleTargetIpResult']:
+        """
+        List of configurations for target IP addresses. Only applicable for `FORWARD` rules. See `target_ips` below for details.
+        """
+        return pulumi.get(self, "target_ips")
+
 
 class AwaitableGetResolverRuleResult(GetResolverRuleResult):
     # pylint: disable=using-constant-test
@@ -149,7 +161,8 @@ class AwaitableGetResolverRuleResult(GetResolverRuleResult):
             resolver_rule_id=self.resolver_rule_id,
             rule_type=self.rule_type,
             share_status=self.share_status,
-            tags=self.tags)
+            tags=self.tags,
+            target_ips=self.target_ips)
 
 
 def get_resolver_rule(domain_name: Optional[_builtins.str] = None,
@@ -206,7 +219,8 @@ def get_resolver_rule(domain_name: Optional[_builtins.str] = None,
         resolver_rule_id=pulumi.get(__ret__, 'resolver_rule_id'),
         rule_type=pulumi.get(__ret__, 'rule_type'),
         share_status=pulumi.get(__ret__, 'share_status'),
-        tags=pulumi.get(__ret__, 'tags'))
+        tags=pulumi.get(__ret__, 'tags'),
+        target_ips=pulumi.get(__ret__, 'target_ips'))
 def get_resolver_rule_output(domain_name: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
                              name: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
                              region: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
@@ -260,4 +274,5 @@ def get_resolver_rule_output(domain_name: Optional[pulumi.Input[Optional[_builti
         resolver_rule_id=pulumi.get(__response__, 'resolver_rule_id'),
         rule_type=pulumi.get(__response__, 'rule_type'),
         share_status=pulumi.get(__response__, 'share_status'),
-        tags=pulumi.get(__response__, 'tags')))
+        tags=pulumi.get(__response__, 'tags'),
+        target_ips=pulumi.get(__response__, 'target_ips')))

pulumi_aws/route53/outputs.py

@@ -50,6 +50,7 @@ __all__ = [
     'GetRecordsResourceRecordSetResourceRecordResult',
     'GetResolverEndpointFilterResult',
     'GetResolverFirewallRulesFirewallRuleResult',
+    'GetResolverRuleTargetIpResult',
     'GetTrafficPolicyDocumentEndpointResult',
     'GetTrafficPolicyDocumentRuleResult',
     'GetTrafficPolicyDocumentRuleGeoProximityLocationResult',
@@ -1703,39 +1704,54 @@ class GetResolverFirewallRulesFirewallRuleResult(dict):
                  block_override_domain: _builtins.str,
                  block_override_ttl: _builtins.int,
                  block_response: _builtins.str,
+                 confidence_threshold: _builtins.str,
                  creation_time: _builtins.str,
                  creator_request_id: _builtins.str,
+                 dns_threat_protection: _builtins.str,
                  firewall_domain_list_id: _builtins.str,
+                 firewall_domain_redirection_action: _builtins.str,
                  firewall_rule_group_id: _builtins.str,
+                 firewall_threat_protection_id: _builtins.str,
                  modification_time: _builtins.str,
                  name: _builtins.str,
-                 priority: _builtins.int):
+                 priority: _builtins.int,
+                 q_type: _builtins.str):
         """
         :param _builtins.str action: The action that DNS Firewall should take on a DNS query when it matches one of the domains in the rule's domain list.
         :param _builtins.str block_override_dns_type: The DNS record's type.
         :param _builtins.str block_override_domain: The custom DNS record to send back in response to the query.
         :param _builtins.int block_override_ttl: The recommended amount of time, in seconds, for the DNS resolver or web browser to cache the provided override record.
         :param _builtins.str block_response: The way that you want DNS Firewall to block the request.
+        :param _builtins.str confidence_threshold: The confidence threshold for DNS Firewall Advanced rules.
         :param _builtins.str creation_time: The date and time that the rule was created, in Unix time format and Coordinated Universal Time (UTC).
         :param _builtins.str creator_request_id: A unique string defined by you to identify the request.
+        :param _builtins.str dns_threat_protection: The type of DNS Firewall Advanced rule.
         :param _builtins.str firewall_domain_list_id: The ID of the domain list that's used in the rule.
+        :param _builtins.str firewall_domain_redirection_action: How DNS Firewall evaluates DNS redirection in the DNS redirection chain.
         :param _builtins.str firewall_rule_group_id: The unique identifier of the firewall rule group that you want to retrieve the rules for.
+        :param _builtins.str firewall_threat_protection_id: The ID of the DNS Firewall Advanced rule.
         :param _builtins.str modification_time: The date and time that the rule was last modified, in Unix time format and Coordinated Universal Time (UTC).
         :param _builtins.str name: The name of the rule.
         :param _builtins.int priority: The setting that determines the processing order of the rules in a rule group.
+        :param _builtins.str q_type: The DNS query type that the rule evaluates.
         """
         pulumi.set(__self__, "action", action)
         pulumi.set(__self__, "block_override_dns_type", block_override_dns_type)
         pulumi.set(__self__, "block_override_domain", block_override_domain)
         pulumi.set(__self__, "block_override_ttl", block_override_ttl)
         pulumi.set(__self__, "block_response", block_response)
+        pulumi.set(__self__, "confidence_threshold", confidence_threshold)
         pulumi.set(__self__, "creation_time", creation_time)
         pulumi.set(__self__, "creator_request_id", creator_request_id)
+        pulumi.set(__self__, "dns_threat_protection", dns_threat_protection)
         pulumi.set(__self__, "firewall_domain_list_id", firewall_domain_list_id)
+        pulumi.set(__self__, "firewall_domain_redirection_action", firewall_domain_redirection_action)
         pulumi.set(__self__, "firewall_rule_group_id", firewall_rule_group_id)
+        pulumi.set(__self__, "firewall_threat_protection_id", firewall_threat_protection_id)
         pulumi.set(__self__, "modification_time", modification_time)
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "priority", priority)
+        pulumi.set(__self__, "q_type", q_type)
 
     @_builtins.property
     @pulumi.getter
@@ -1777,6 +1793,14 @@ class GetResolverFirewallRulesFirewallRuleResult(dict):
         """
         return pulumi.get(self, "block_response")
 
+    @_builtins.property
+    @pulumi.getter(name="confidenceThreshold")
+    def confidence_threshold(self) -> _builtins.str:
+        """
+        The confidence threshold for DNS Firewall Advanced rules.
+        """
+        return pulumi.get(self, "confidence_threshold")
+
     @_builtins.property
     @pulumi.getter(name="creationTime")
     def creation_time(self) -> _builtins.str:
@@ -1793,6 +1817,14 @@ class GetResolverFirewallRulesFirewallRuleResult(dict):
         """
         return pulumi.get(self, "creator_request_id")
 
+    @_builtins.property
+    @pulumi.getter(name="dnsThreatProtection")
+    def dns_threat_protection(self) -> _builtins.str:
+        """
+        The type of DNS Firewall Advanced rule.
+        """
+        return pulumi.get(self, "dns_threat_protection")
+
     @_builtins.property
     @pulumi.getter(name="firewallDomainListId")
     def firewall_domain_list_id(self) -> _builtins.str:
@@ -1801,6 +1833,14 @@ class GetResolverFirewallRulesFirewallRuleResult(dict):
         """
         return pulumi.get(self, "firewall_domain_list_id")
 
+    @_builtins.property
+    @pulumi.getter(name="firewallDomainRedirectionAction")
+    def firewall_domain_redirection_action(self) -> _builtins.str:
+        """
+        How DNS Firewall evaluates DNS redirection in the DNS redirection chain.
+        """
+        return pulumi.get(self, "firewall_domain_redirection_action")
+
     @_builtins.property
     @pulumi.getter(name="firewallRuleGroupId")
     def firewall_rule_group_id(self) -> _builtins.str:
@@ -1809,6 +1849,14 @@ class GetResolverFirewallRulesFirewallRuleResult(dict):
         """
         return pulumi.get(self, "firewall_rule_group_id")
 
+    @_builtins.property
+    @pulumi.getter(name="firewallThreatProtectionId")
+    def firewall_threat_protection_id(self) -> _builtins.str:
+        """
+        The ID of the DNS Firewall Advanced rule.
+        """
+        return pulumi.get(self, "firewall_threat_protection_id")
+
     @_builtins.property
     @pulumi.getter(name="modificationTime")
     def modification_time(self) -> _builtins.str:
@@ -1833,6 +1881,65 @@ class GetResolverFirewallRulesFirewallRuleResult(dict):
         """
         return pulumi.get(self, "priority")
 
+    @_builtins.property
+    @pulumi.getter(name="qType")
+    def q_type(self) -> _builtins.str:
+        """
+        The DNS query type that the rule evaluates.
+        """
+        return pulumi.get(self, "q_type")
+
+
+@pulumi.output_type
+class GetResolverRuleTargetIpResult(dict):
+    def __init__(__self__, *,
+                 ip: _builtins.str,
+                 ipv6: _builtins.str,
+                 port: _builtins.int,
+                 protocol: _builtins.str):
+        """
+        :param _builtins.str ip: IPv4 address that you want to forward DNS queries to.
+        :param _builtins.str ipv6: IPv6 address that you want to forward DNS queries to.
+        :param _builtins.int port: Port at the IP address that you want to forward DNS queries to.
+        :param _builtins.str protocol: Protocol for the target IP address. Valid values are `Do53` (DNS over port 53), `DoH` (DNS over HTTPS), and `DoH-FIPS` (DNS over HTTPS with FIPS).
+        """
+        pulumi.set(__self__, "ip", ip)
+        pulumi.set(__self__, "ipv6", ipv6)
+        pulumi.set(__self__, "port", port)
+        pulumi.set(__self__, "protocol", protocol)
+
+    @_builtins.property
+    @pulumi.getter
+    def ip(self) -> _builtins.str:
+        """
+        IPv4 address that you want to forward DNS queries to.
+        """
+        return pulumi.get(self, "ip")
+
+    @_builtins.property
+    @pulumi.getter
+    def ipv6(self) -> _builtins.str:
+        """
+        IPv6 address that you want to forward DNS queries to.
+        """
+        return pulumi.get(self, "ipv6")
+
+    @_builtins.property
+    @pulumi.getter
+    def port(self) -> _builtins.int:
+        """
+        Port at the IP address that you want to forward DNS queries to.
+        """
+        return pulumi.get(self, "port")
+
+    @_builtins.property
+    @pulumi.getter
+    def protocol(self) -> _builtins.str:
+        """
+        Protocol for the target IP address. Valid values are `Do53` (DNS over port 53), `DoH` (DNS over HTTPS), and `DoH-FIPS` (DNS over HTTPS with FIPS).
+        """
+        return pulumi.get(self, "protocol")
+
 
 @pulumi.output_type
 class GetTrafficPolicyDocumentEndpointResult(dict):