pulumi-gcp 7.29.0a1719416802__py3-none-any.whl → 7.30.0__py3-none-any.whl

pulumi_gcp/dns/_inputs.py

@@ -4,48 +4,97 @@
 
 import copy
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
 
 __all__ = [
     'DnsManagedZoneIamBindingConditionArgs',
+    'DnsManagedZoneIamBindingConditionArgsDict',
     'DnsManagedZoneIamMemberConditionArgs',
+    'DnsManagedZoneIamMemberConditionArgsDict',
     'ManagedZoneCloudLoggingConfigArgs',
+    'ManagedZoneCloudLoggingConfigArgsDict',
     'ManagedZoneDnssecConfigArgs',
+    'ManagedZoneDnssecConfigArgsDict',
     'ManagedZoneDnssecConfigDefaultKeySpecArgs',
+    'ManagedZoneDnssecConfigDefaultKeySpecArgsDict',
     'ManagedZoneForwardingConfigArgs',
+    'ManagedZoneForwardingConfigArgsDict',
     'ManagedZoneForwardingConfigTargetNameServerArgs',
+    'ManagedZoneForwardingConfigTargetNameServerArgsDict',
     'ManagedZonePeeringConfigArgs',
+    'ManagedZonePeeringConfigArgsDict',
     'ManagedZonePeeringConfigTargetNetworkArgs',
+    'ManagedZonePeeringConfigTargetNetworkArgsDict',
     'ManagedZonePrivateVisibilityConfigArgs',
+    'ManagedZonePrivateVisibilityConfigArgsDict',
     'ManagedZonePrivateVisibilityConfigGkeClusterArgs',
+    'ManagedZonePrivateVisibilityConfigGkeClusterArgsDict',
     'ManagedZonePrivateVisibilityConfigNetworkArgs',
+    'ManagedZonePrivateVisibilityConfigNetworkArgsDict',
     'ManagedZoneServiceDirectoryConfigArgs',
+    'ManagedZoneServiceDirectoryConfigArgsDict',
     'ManagedZoneServiceDirectoryConfigNamespaceArgs',
+    'ManagedZoneServiceDirectoryConfigNamespaceArgsDict',
     'PolicyAlternativeNameServerConfigArgs',
+    'PolicyAlternativeNameServerConfigArgsDict',
     'PolicyAlternativeNameServerConfigTargetNameServerArgs',
+    'PolicyAlternativeNameServerConfigTargetNameServerArgsDict',
     'PolicyNetworkArgs',
+    'PolicyNetworkArgsDict',
     'RecordSetRoutingPolicyArgs',
+    'RecordSetRoutingPolicyArgsDict',
     'RecordSetRoutingPolicyGeoArgs',
+    'RecordSetRoutingPolicyGeoArgsDict',
     'RecordSetRoutingPolicyGeoHealthCheckedTargetsArgs',
+    'RecordSetRoutingPolicyGeoHealthCheckedTargetsArgsDict',
     'RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArgs',
+    'RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArgsDict',
     'RecordSetRoutingPolicyPrimaryBackupArgs',
+    'RecordSetRoutingPolicyPrimaryBackupArgsDict',
     'RecordSetRoutingPolicyPrimaryBackupBackupGeoArgs',
+    'RecordSetRoutingPolicyPrimaryBackupBackupGeoArgsDict',
     'RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsArgs',
+    'RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsArgsDict',
     'RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArgs',
+    'RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArgsDict',
     'RecordSetRoutingPolicyPrimaryBackupPrimaryArgs',
+    'RecordSetRoutingPolicyPrimaryBackupPrimaryArgsDict',
     'RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArgs',
+    'RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArgsDict',
     'RecordSetRoutingPolicyWrrArgs',
+    'RecordSetRoutingPolicyWrrArgsDict',
     'RecordSetRoutingPolicyWrrHealthCheckedTargetsArgs',
+    'RecordSetRoutingPolicyWrrHealthCheckedTargetsArgsDict',
     'RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArgs',
+    'RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArgsDict',
     'ResponsePolicyGkeClusterArgs',
+    'ResponsePolicyGkeClusterArgsDict',
     'ResponsePolicyNetworkArgs',
+    'ResponsePolicyNetworkArgsDict',
     'ResponsePolicyRuleLocalDataArgs',
+    'ResponsePolicyRuleLocalDataArgsDict',
     'ResponsePolicyRuleLocalDataLocalDataArgs',
+    'ResponsePolicyRuleLocalDataLocalDataArgsDict',
 ]
 
+MYPY = False
+
+if not MYPY:
+    class DnsManagedZoneIamBindingConditionArgsDict(TypedDict):
+        expression: pulumi.Input[str]
+        title: pulumi.Input[str]
+        description: NotRequired[pulumi.Input[str]]
+elif False:
+    DnsManagedZoneIamBindingConditionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class DnsManagedZoneIamBindingConditionArgs:
     def __init__(__self__, *,
@@ -85,6 +134,14 @@ class DnsManagedZoneIamBindingConditionArgs:
         pulumi.set(self, "description", value)
 
 
+if not MYPY:
+    class DnsManagedZoneIamMemberConditionArgsDict(TypedDict):
+        expression: pulumi.Input[str]
+        title: pulumi.Input[str]
+        description: NotRequired[pulumi.Input[str]]
+elif False:
+    DnsManagedZoneIamMemberConditionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class DnsManagedZoneIamMemberConditionArgs:
     def __init__(__self__, *,
@@ -124,6 +181,15 @@ class DnsManagedZoneIamMemberConditionArgs:
         pulumi.set(self, "description", value)
 
 
+if not MYPY:
+    class ManagedZoneCloudLoggingConfigArgsDict(TypedDict):
+        enable_logging: pulumi.Input[bool]
+        """
+        If set, enable query logging for this ManagedZone. False by default, making logging opt-in.
+        """
+elif False:
+    ManagedZoneCloudLoggingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ManagedZoneCloudLoggingConfigArgs:
     def __init__(__self__, *,
@@ -146,6 +212,34 @@ class ManagedZoneCloudLoggingConfigArgs:
         pulumi.set(self, "enable_logging", value)
 
 
+if not MYPY:
+    class ManagedZoneDnssecConfigArgsDict(TypedDict):
+        default_key_specs: NotRequired[pulumi.Input[Sequence[pulumi.Input['ManagedZoneDnssecConfigDefaultKeySpecArgsDict']]]]
+        """
+        Specifies parameters that will be used for generating initial DnsKeys
+        for this ManagedZone. If you provide a spec for keySigning or zoneSigning,
+        you must also provide one for the other.
+        default_key_specs can only be updated when the state is `off`.
+        Structure is documented below.
+        """
+        kind: NotRequired[pulumi.Input[str]]
+        """
+        Identifies what kind of resource this is
+        """
+        non_existence: NotRequired[pulumi.Input[str]]
+        """
+        Specifies the mechanism used to provide authenticated denial-of-existence responses.
+        non_existence can only be updated when the state is `off`.
+        Possible values are: `nsec`, `nsec3`.
+        """
+        state: NotRequired[pulumi.Input[str]]
+        """
+        Specifies whether DNSSEC is enabled, and what mode it is in
+        Possible values are: `off`, `on`, `transfer`.
+        """
+elif False:
+    ManagedZoneDnssecConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ManagedZoneDnssecConfigArgs:
     def __init__(__self__, *,
@@ -231,6 +325,34 @@ class ManagedZoneDnssecConfigArgs:
         pulumi.set(self, "state", value)
 
 
+if not MYPY:
+    class ManagedZoneDnssecConfigDefaultKeySpecArgsDict(TypedDict):
+        algorithm: NotRequired[pulumi.Input[str]]
+        """
+        String mnemonic specifying the DNSSEC algorithm of this key
+        Possible values are: `ecdsap256sha256`, `ecdsap384sha384`, `rsasha1`, `rsasha256`, `rsasha512`.
+        """
+        key_length: NotRequired[pulumi.Input[int]]
+        """
+        Length of the keys in bits
+        """
+        key_type: NotRequired[pulumi.Input[str]]
+        """
+        Specifies whether this is a key signing key (KSK) or a zone
+        signing key (ZSK). Key signing keys have the Secure Entry
+        Point flag set and, when active, will only be used to sign
+        resource record sets of type DNSKEY. Zone signing keys do
+        not have the Secure Entry Point flag set and will be used
+        to sign all other types of resource record sets.
+        Possible values are: `keySigning`, `zoneSigning`.
+        """
+        kind: NotRequired[pulumi.Input[str]]
+        """
+        Identifies what kind of resource this is
+        """
+elif False:
+    ManagedZoneDnssecConfigDefaultKeySpecArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ManagedZoneDnssecConfigDefaultKeySpecArgs:
     def __init__(__self__, *,
@@ -316,6 +438,18 @@ class ManagedZoneDnssecConfigDefaultKeySpecArgs:
         pulumi.set(self, "kind", value)
 
 
+if not MYPY:
+    class ManagedZoneForwardingConfigArgsDict(TypedDict):
+        target_name_servers: pulumi.Input[Sequence[pulumi.Input['ManagedZoneForwardingConfigTargetNameServerArgsDict']]]
+        """
+        List of target name servers to forward to. Cloud DNS will
+        select the best available name server if more than
+        one target is given.
+        Structure is documented below.
+        """
+elif False:
+    ManagedZoneForwardingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ManagedZoneForwardingConfigArgs:
     def __init__(__self__, *,
@@ -344,6 +478,22 @@ class ManagedZoneForwardingConfigArgs:
         pulumi.set(self, "target_name_servers", value)
 
 
+if not MYPY:
+    class ManagedZoneForwardingConfigTargetNameServerArgsDict(TypedDict):
+        ipv4_address: pulumi.Input[str]
+        """
+        IPv4 address of a target name server.
+        """
+        forwarding_path: NotRequired[pulumi.Input[str]]
+        """
+        Forwarding path for this TargetNameServer. If unset or `default` Cloud DNS will make forwarding
+        decision based on address ranges, i.e. RFC1918 addresses go to the VPC, Non-RFC1918 addresses go
+        to the Internet. When set to `private`, Cloud DNS will always send queries through VPC for this target
+        Possible values are: `default`, `private`.
+        """
+elif False:
+    ManagedZoneForwardingConfigTargetNameServerArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ManagedZoneForwardingConfigTargetNameServerArgs:
     def __init__(__self__, *,
@@ -388,6 +538,16 @@ class ManagedZoneForwardingConfigTargetNameServerArgs:
         pulumi.set(self, "forwarding_path", value)
 
 
+if not MYPY:
+    class ManagedZonePeeringConfigArgsDict(TypedDict):
+        target_network: pulumi.Input['ManagedZonePeeringConfigTargetNetworkArgsDict']
+        """
+        The network with which to peer.
+        Structure is documented below.
+        """
+elif False:
+    ManagedZonePeeringConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ManagedZonePeeringConfigArgs:
     def __init__(__self__, *,
@@ -412,6 +572,17 @@ class ManagedZonePeeringConfigArgs:
         pulumi.set(self, "target_network", value)
 
 
+if not MYPY:
+    class ManagedZonePeeringConfigTargetNetworkArgsDict(TypedDict):
+        network_url: pulumi.Input[str]
+        """
+        The id or fully qualified URL of the VPC network to forward queries to.
+        This should be formatted like `projects/{project}/global/networks/{network}` or
+        `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
+        """
+elif False:
+    ManagedZonePeeringConfigTargetNetworkArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ManagedZonePeeringConfigTargetNetworkArgs:
     def __init__(__self__, *,
@@ -438,6 +609,17 @@ class ManagedZonePeeringConfigTargetNetworkArgs:
         pulumi.set(self, "network_url", value)
 
 
+if not MYPY:
+    class ManagedZonePrivateVisibilityConfigArgsDict(TypedDict):
+        gke_clusters: NotRequired[pulumi.Input[Sequence[pulumi.Input['ManagedZonePrivateVisibilityConfigGkeClusterArgsDict']]]]
+        """
+        The list of Google Kubernetes Engine clusters that can see this zone.
+        Structure is documented below.
+        """
+        networks: NotRequired[pulumi.Input[Sequence[pulumi.Input['ManagedZonePrivateVisibilityConfigNetworkArgsDict']]]]
+elif False:
+    ManagedZonePrivateVisibilityConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ManagedZonePrivateVisibilityConfigArgs:
     def __init__(__self__, *,
@@ -475,6 +657,17 @@ class ManagedZonePrivateVisibilityConfigArgs:
         pulumi.set(self, "networks", value)
 
 
+if not MYPY:
+    class ManagedZonePrivateVisibilityConfigGkeClusterArgsDict(TypedDict):
+        gke_cluster_name: pulumi.Input[str]
+        """
+        The resource name of the cluster to bind this ManagedZone to.
+        This should be specified in the format like
+        `projects/*/locations/*/clusters/*`
+        """
+elif False:
+    ManagedZonePrivateVisibilityConfigGkeClusterArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ManagedZonePrivateVisibilityConfigGkeClusterArgs:
     def __init__(__self__, *,
@@ -501,6 +694,17 @@ class ManagedZonePrivateVisibilityConfigGkeClusterArgs:
         pulumi.set(self, "gke_cluster_name", value)
 
 
+if not MYPY:
+    class ManagedZonePrivateVisibilityConfigNetworkArgsDict(TypedDict):
+        network_url: pulumi.Input[str]
+        """
+        The id or fully qualified URL of the VPC network to bind to.
+        This should be formatted like `projects/{project}/global/networks/{network}` or
+        `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
+        """
+elif False:
+    ManagedZonePrivateVisibilityConfigNetworkArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ManagedZonePrivateVisibilityConfigNetworkArgs:
     def __init__(__self__, *,
@@ -527,6 +731,16 @@ class ManagedZonePrivateVisibilityConfigNetworkArgs:
         pulumi.set(self, "network_url", value)
 
 
+if not MYPY:
+    class ManagedZoneServiceDirectoryConfigArgsDict(TypedDict):
+        namespace: pulumi.Input['ManagedZoneServiceDirectoryConfigNamespaceArgsDict']
+        """
+        The namespace associated with the zone.
+        Structure is documented below.
+        """
+elif False:
+    ManagedZoneServiceDirectoryConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ManagedZoneServiceDirectoryConfigArgs:
     def __init__(__self__, *,
@@ -551,6 +765,19 @@ class ManagedZoneServiceDirectoryConfigArgs:
         pulumi.set(self, "namespace", value)
 
 
+if not MYPY:
+    class ManagedZoneServiceDirectoryConfigNamespaceArgsDict(TypedDict):
+        namespace_url: pulumi.Input[str]
+        """
+        The fully qualified or partial URL of the service directory namespace that should be
+        associated with the zone. This should be formatted like
+        `https://servicedirectory.googleapis.com/v1/projects/{project}/locations/{location}/namespaces/{namespace_id}`
+        or simply `projects/{project}/locations/{location}/namespaces/{namespace_id}`
+        Ignored for `public` visibility zones.
+        """
+elif False:
+    ManagedZoneServiceDirectoryConfigNamespaceArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ManagedZoneServiceDirectoryConfigNamespaceArgs:
     def __init__(__self__, *,
@@ -581,6 +808,18 @@ class ManagedZoneServiceDirectoryConfigNamespaceArgs:
         pulumi.set(self, "namespace_url", value)
 
 
+if not MYPY:
+    class PolicyAlternativeNameServerConfigArgsDict(TypedDict):
+        target_name_servers: pulumi.Input[Sequence[pulumi.Input['PolicyAlternativeNameServerConfigTargetNameServerArgsDict']]]
+        """
+        Sets an alternative name server for the associated networks. When specified,
+        all DNS queries are forwarded to a name server that you choose. Names such as .internal
+        are not available when an alternative name server is specified.
+        Structure is documented below.
+        """
+elif False:
+    PolicyAlternativeNameServerConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class PolicyAlternativeNameServerConfigArgs:
     def __init__(__self__, *,
@@ -609,6 +848,22 @@ class PolicyAlternativeNameServerConfigArgs:
         pulumi.set(self, "target_name_servers", value)
 
 
+if not MYPY:
+    class PolicyAlternativeNameServerConfigTargetNameServerArgsDict(TypedDict):
+        ipv4_address: pulumi.Input[str]
+        """
+        IPv4 address to forward to.
+        """
+        forwarding_path: NotRequired[pulumi.Input[str]]
+        """
+        Forwarding path for this TargetNameServer. If unset or `default` Cloud DNS will make forwarding
+        decision based on address ranges, i.e. RFC1918 addresses go to the VPC, Non-RFC1918 addresses go
+        to the Internet. When set to `private`, Cloud DNS will always send queries through VPC for this target
+        Possible values are: `default`, `private`.
+        """
+elif False:
+    PolicyAlternativeNameServerConfigTargetNameServerArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class PolicyAlternativeNameServerConfigTargetNameServerArgs:
     def __init__(__self__, *,
@@ -653,6 +908,17 @@ class PolicyAlternativeNameServerConfigTargetNameServerArgs:
         pulumi.set(self, "forwarding_path", value)
 
 
+if not MYPY:
+    class PolicyNetworkArgsDict(TypedDict):
+        network_url: pulumi.Input[str]
+        """
+        The id or fully qualified URL of the VPC network to forward queries to.
+        This should be formatted like `projects/{project}/global/networks/{network}` or
+        `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
+        """
+elif False:
+    PolicyNetworkArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class PolicyNetworkArgs:
     def __init__(__self__, *,
@@ -679,6 +945,30 @@ class PolicyNetworkArgs:
         pulumi.set(self, "network_url", value)
 
 
+if not MYPY:
+    class RecordSetRoutingPolicyArgsDict(TypedDict):
+        enable_geo_fencing: NotRequired[pulumi.Input[bool]]
+        """
+        Specifies whether to enable fencing for geo queries.
+        """
+        geos: NotRequired[pulumi.Input[Sequence[pulumi.Input['RecordSetRoutingPolicyGeoArgsDict']]]]
+        """
+        The configuration for Geolocation based routing policy.
+        Structure is documented below.
+        """
+        primary_backup: NotRequired[pulumi.Input['RecordSetRoutingPolicyPrimaryBackupArgsDict']]
+        """
+        The configuration for a failover policy with global to regional failover. Queries are responded to with the global primary targets, but if none of the primary targets are healthy, then we fallback to a regional failover policy.
+        Structure is documented below.
+        """
+        wrrs: NotRequired[pulumi.Input[Sequence[pulumi.Input['RecordSetRoutingPolicyWrrArgsDict']]]]
+        """
+        The configuration for Weighted Round Robin based routing policy.
+        Structure is documented below.
+        """
+elif False:
+    RecordSetRoutingPolicyArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RecordSetRoutingPolicyArgs:
     def __init__(__self__, *,
@@ -756,6 +1046,24 @@ class RecordSetRoutingPolicyArgs:
         pulumi.set(self, "wrrs", value)
 
 
+if not MYPY:
+    class RecordSetRoutingPolicyGeoArgsDict(TypedDict):
+        location: pulumi.Input[str]
+        """
+        The location name defined in Google Cloud.
+        """
+        health_checked_targets: NotRequired[pulumi.Input['RecordSetRoutingPolicyGeoHealthCheckedTargetsArgsDict']]
+        """
+        For A and AAAA types only. The list of targets to be health checked. These can be specified along with `rrdatas` within this item.
+        Structure is documented below.
+        """
+        rrdatas: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Same as `rrdatas` above.
+        """
+elif False:
+    RecordSetRoutingPolicyGeoArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RecordSetRoutingPolicyGeoArgs:
     def __init__(__self__, *,
@@ -812,6 +1120,16 @@ class RecordSetRoutingPolicyGeoArgs:
         pulumi.set(self, "rrdatas", value)
 
 
+if not MYPY:
+    class RecordSetRoutingPolicyGeoHealthCheckedTargetsArgsDict(TypedDict):
+        internal_load_balancers: pulumi.Input[Sequence[pulumi.Input['RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArgsDict']]]
+        """
+        The list of internal load balancers to health check.
+        Structure is documented below.
+        """
+elif False:
+    RecordSetRoutingPolicyGeoHealthCheckedTargetsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RecordSetRoutingPolicyGeoHealthCheckedTargetsArgs:
     def __init__(__self__, *,
@@ -836,6 +1154,39 @@ class RecordSetRoutingPolicyGeoHealthCheckedTargetsArgs:
         pulumi.set(self, "internal_load_balancers", value)
 
 
+if not MYPY:
+    class RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArgsDict(TypedDict):
+        ip_address: pulumi.Input[str]
+        """
+        The frontend IP address of the load balancer.
+        """
+        ip_protocol: pulumi.Input[str]
+        """
+        The configured IP protocol of the load balancer. This value is case-sensitive. Possible values: ["tcp", "udp"]
+        """
+        load_balancer_type: pulumi.Input[str]
+        """
+        The type of load balancer. This value is case-sensitive. Possible values: ["regionalL4ilb", "regionalL7ilb", "globalL7ilb"]
+        """
+        network_url: pulumi.Input[str]
+        """
+        The fully qualified url of the network in which the load balancer belongs. This should be formatted like `projects/{project}/global/networks/{network}` or `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`.
+        """
+        port: pulumi.Input[str]
+        """
+        The configured port of the load balancer.
+        """
+        project: pulumi.Input[str]
+        """
+        The ID of the project in which the load balancer belongs.
+        """
+        region: NotRequired[pulumi.Input[str]]
+        """
+        The region of the load balancer. Only needed for regional load balancers.
+        """
+elif False:
+    RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArgs:
     def __init__(__self__, *,
@@ -949,6 +1300,29 @@ class RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArgs:
         pulumi.set(self, "region", value)
 
 
+if not MYPY:
+    class RecordSetRoutingPolicyPrimaryBackupArgsDict(TypedDict):
+        backup_geos: pulumi.Input[Sequence[pulumi.Input['RecordSetRoutingPolicyPrimaryBackupBackupGeoArgsDict']]]
+        """
+        The backup geo targets, which provide a regional failover policy for the otherwise global primary targets.
+        Structure is document above.
+        """
+        primary: pulumi.Input['RecordSetRoutingPolicyPrimaryBackupPrimaryArgsDict']
+        """
+        The list of global primary targets to be health checked.
+        Structure is documented below.
+        """
+        enable_geo_fencing_for_backups: NotRequired[pulumi.Input[bool]]
+        """
+        Specifies whether to enable fencing for backup geo queries.
+        """
+        trickle_ratio: NotRequired[pulumi.Input[float]]
+        """
+        Specifies the percentage of traffic to send to the backup targets even when the primary targets are healthy.
+        """
+elif False:
+    RecordSetRoutingPolicyPrimaryBackupArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RecordSetRoutingPolicyPrimaryBackupArgs:
     def __init__(__self__, *,
@@ -1022,6 +1396,20 @@ class RecordSetRoutingPolicyPrimaryBackupArgs:
         pulumi.set(self, "trickle_ratio", value)
 
 
+if not MYPY:
+    class RecordSetRoutingPolicyPrimaryBackupBackupGeoArgsDict(TypedDict):
+        location: pulumi.Input[str]
+        """
+        The location name defined in Google Cloud.
+        """
+        health_checked_targets: NotRequired[pulumi.Input['RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsArgsDict']]
+        """
+        For A and AAAA types only. The list of targets to be health checked. These can be specified along with `rrdatas` within this item.
+        """
+        rrdatas: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+elif False:
+    RecordSetRoutingPolicyPrimaryBackupBackupGeoArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RecordSetRoutingPolicyPrimaryBackupBackupGeoArgs:
     def __init__(__self__, *,
@@ -1072,6 +1460,16 @@ class RecordSetRoutingPolicyPrimaryBackupBackupGeoArgs:
         pulumi.set(self, "rrdatas", value)
 
 
+if not MYPY:
+    class RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsArgsDict(TypedDict):
+        internal_load_balancers: pulumi.Input[Sequence[pulumi.Input['RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArgsDict']]]
+        """
+        The list of internal load balancers to health check.
+        Structure is documented below.
+        """
+elif False:
+    RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsArgs:
     def __init__(__self__, *,
@@ -1096,6 +1494,39 @@ class RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsArgs:
         pulumi.set(self, "internal_load_balancers", value)
 
 
+if not MYPY:
+    class RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArgsDict(TypedDict):
+        ip_address: pulumi.Input[str]
+        """
+        The frontend IP address of the load balancer.
+        """
+        ip_protocol: pulumi.Input[str]
+        """
+        The configured IP protocol of the load balancer. This value is case-sensitive. Possible values: ["tcp", "udp"]
+        """
+        load_balancer_type: pulumi.Input[str]
+        """
+        The type of load balancer. This value is case-sensitive. Possible values: ["regionalL4ilb", "regionalL7ilb", "globalL7ilb"]
+        """
+        network_url: pulumi.Input[str]
+        """
+        The fully qualified url of the network in which the load balancer belongs. This should be formatted like `projects/{project}/global/networks/{network}` or `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`.
+        """
+        port: pulumi.Input[str]
+        """
+        The configured port of the load balancer.
+        """
+        project: pulumi.Input[str]
+        """
+        The ID of the project in which the load balancer belongs.
+        """
+        region: NotRequired[pulumi.Input[str]]
+        """
+        The region of the load balancer. Only needed for regional load balancers.
+        """
+elif False:
+    RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArgs:
     def __init__(__self__, *,
@@ -1209,6 +1640,15 @@ class RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLo
         pulumi.set(self, "region", value)
 
 
+if not MYPY:
+    class RecordSetRoutingPolicyPrimaryBackupPrimaryArgsDict(TypedDict):
+        internal_load_balancers: pulumi.Input[Sequence[pulumi.Input['RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArgsDict']]]
+        """
+        The list of internal load balancers to health check.
+        """
+elif False:
+    RecordSetRoutingPolicyPrimaryBackupPrimaryArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RecordSetRoutingPolicyPrimaryBackupPrimaryArgs:
     def __init__(__self__, *,
@@ -1231,6 +1671,39 @@ class RecordSetRoutingPolicyPrimaryBackupPrimaryArgs:
         pulumi.set(self, "internal_load_balancers", value)
 
 
+if not MYPY:
+    class RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArgsDict(TypedDict):
+        ip_address: pulumi.Input[str]
+        """
+        The frontend IP address of the load balancer.
+        """
+        ip_protocol: pulumi.Input[str]
+        """
+        The configured IP protocol of the load balancer. This value is case-sensitive. Possible values: ["tcp", "udp"]
+        """
+        load_balancer_type: pulumi.Input[str]
+        """
+        The type of load balancer. This value is case-sensitive. Possible values: ["regionalL4ilb", "regionalL7ilb", "globalL7ilb"]
+        """
+        network_url: pulumi.Input[str]
+        """
+        The fully qualified url of the network in which the load balancer belongs. This should be formatted like `projects/{project}/global/networks/{network}` or `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`.
+        """
+        port: pulumi.Input[str]
+        """
+        The configured port of the load balancer.
+        """
+        project: pulumi.Input[str]
+        """
+        The ID of the project in which the load balancer belongs.
+        """
+        region: NotRequired[pulumi.Input[str]]
+        """
+        The region of the load balancer. Only needed for regional load balancers.
+        """
+elif False:
+    RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArgs:
     def __init__(__self__, *,
@@ -1344,6 +1817,24 @@ class RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArgs:
         pulumi.set(self, "region", value)
 
 
+if not MYPY:
+    class RecordSetRoutingPolicyWrrArgsDict(TypedDict):
+        weight: pulumi.Input[float]
+        """
+        The ratio of traffic routed to the target.
+        """
+        health_checked_targets: NotRequired[pulumi.Input['RecordSetRoutingPolicyWrrHealthCheckedTargetsArgsDict']]
+        """
+        The list of targets to be health checked. Note that if DNSSEC is enabled for this zone, only one of `rrdatas` or `health_checked_targets` can be set.
+        Structure is documented below.
+        """
+        rrdatas: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Same as `rrdatas` above.
+        """
+elif False:
+    RecordSetRoutingPolicyWrrArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RecordSetRoutingPolicyWrrArgs:
     def __init__(__self__, *,
@@ -1400,6 +1891,16 @@ class RecordSetRoutingPolicyWrrArgs:
         pulumi.set(self, "rrdatas", value)
 
 
+if not MYPY:
+    class RecordSetRoutingPolicyWrrHealthCheckedTargetsArgsDict(TypedDict):
+        internal_load_balancers: pulumi.Input[Sequence[pulumi.Input['RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArgsDict']]]
+        """
+        The list of internal load balancers to health check.
+        Structure is documented below.
+        """
+elif False:
+    RecordSetRoutingPolicyWrrHealthCheckedTargetsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RecordSetRoutingPolicyWrrHealthCheckedTargetsArgs:
     def __init__(__self__, *,
@@ -1424,6 +1925,39 @@ class RecordSetRoutingPolicyWrrHealthCheckedTargetsArgs:
         pulumi.set(self, "internal_load_balancers", value)
 
 
+if not MYPY:
+    class RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArgsDict(TypedDict):
+        ip_address: pulumi.Input[str]
+        """
+        The frontend IP address of the load balancer.
+        """
+        ip_protocol: pulumi.Input[str]
+        """
+        The configured IP protocol of the load balancer. This value is case-sensitive. Possible values: ["tcp", "udp"]
+        """
+        load_balancer_type: pulumi.Input[str]
+        """
+        The type of load balancer. This value is case-sensitive. Possible values: ["regionalL4ilb", "regionalL7ilb", "globalL7ilb"]
+        """
+        network_url: pulumi.Input[str]
+        """
+        The fully qualified url of the network in which the load balancer belongs. This should be formatted like `projects/{project}/global/networks/{network}` or `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`.
+        """
+        port: pulumi.Input[str]
+        """
+        The configured port of the load balancer.
+        """
+        project: pulumi.Input[str]
+        """
+        The ID of the project in which the load balancer belongs.
+        """
+        region: NotRequired[pulumi.Input[str]]
+        """
+        The region of the load balancer. Only needed for regional load balancers.
+        """
+elif False:
+    RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArgs:
     def __init__(__self__, *,
@@ -1537,6 +2071,17 @@ class RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArgs:
         pulumi.set(self, "region", value)
 
 
+if not MYPY:
+    class ResponsePolicyGkeClusterArgsDict(TypedDict):
+        gke_cluster_name: pulumi.Input[str]
+        """
+        The resource name of the cluster to bind this ManagedZone to.
+        This should be specified in the format like
+        `projects/*/locations/*/clusters/*`
+        """
+elif False:
+    ResponsePolicyGkeClusterArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ResponsePolicyGkeClusterArgs:
     def __init__(__self__, *,
@@ -1563,6 +2108,17 @@ class ResponsePolicyGkeClusterArgs:
         pulumi.set(self, "gke_cluster_name", value)
 
 
+if not MYPY:
+    class ResponsePolicyNetworkArgsDict(TypedDict):
+        network_url: pulumi.Input[str]
+        """
+        The fully qualified URL of the VPC network to bind to.
+        This should be formatted like
+        `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
+        """
+elif False:
+    ResponsePolicyNetworkArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ResponsePolicyNetworkArgs:
     def __init__(__self__, *,
@@ -1589,6 +2145,16 @@ class ResponsePolicyNetworkArgs:
         pulumi.set(self, "network_url", value)
 
 
+if not MYPY:
+    class ResponsePolicyRuleLocalDataArgsDict(TypedDict):
+        local_datas: pulumi.Input[Sequence[pulumi.Input['ResponsePolicyRuleLocalDataLocalDataArgsDict']]]
+        """
+        All resource record sets for this selector, one per resource record type. The name must match the dns_name.
+        Structure is documented below.
+        """
+elif False:
+    ResponsePolicyRuleLocalDataArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ResponsePolicyRuleLocalDataArgs:
     def __init__(__self__, *,
@@ -1613,6 +2179,29 @@ class ResponsePolicyRuleLocalDataArgs:
         pulumi.set(self, "local_datas", value)
 
 
+if not MYPY:
+    class ResponsePolicyRuleLocalDataLocalDataArgsDict(TypedDict):
+        name: pulumi.Input[str]
+        """
+        For example, www.example.com.
+        """
+        type: pulumi.Input[str]
+        """
+        One of valid DNS resource types.
+        Possible values are: `A`, `AAAA`, `CAA`, `CNAME`, `DNSKEY`, `DS`, `HTTPS`, `IPSECVPNKEY`, `MX`, `NAPTR`, `NS`, `PTR`, `SOA`, `SPF`, `SRV`, `SSHFP`, `SVCB`, `TLSA`, `TXT`.
+        """
+        rrdatas: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        As defined in RFC 1035 (section 5) and RFC 1034 (section 3.6.1)
+        """
+        ttl: NotRequired[pulumi.Input[int]]
+        """
+        Number of seconds that this ResourceRecordSet can be cached by
+        resolvers.
+        """
+elif False:
+    ResponsePolicyRuleLocalDataLocalDataArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ResponsePolicyRuleLocalDataLocalDataArgs:
     def __init__(__self__, *,