pulumi-gcp 7.30.0__py3-none-any.whl → 7.30.0a1719470057__py3-none-any.whl

pulumi_gcp/dns/_inputs.py

@@ -4,97 +4,48 @@
 
 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__, *,
@@ -134,14 +85,6 @@ 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__, *,
@@ -181,15 +124,6 @@ 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__, *,
@@ -212,34 +146,6 @@ 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__, *,
@@ -325,34 +231,6 @@ 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__, *,
@@ -438,18 +316,6 @@ 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__, *,
@@ -478,22 +344,6 @@ 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__, *,
@@ -538,16 +388,6 @@ 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__, *,
@@ -572,17 +412,6 @@ 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__, *,
@@ -609,17 +438,6 @@ 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__, *,
@@ -657,17 +475,6 @@ 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__, *,
@@ -694,17 +501,6 @@ 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__, *,
@@ -731,16 +527,6 @@ 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__, *,
@@ -765,19 +551,6 @@ 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__, *,
@@ -808,18 +581,6 @@ 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__, *,
@@ -848,22 +609,6 @@ 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__, *,
@@ -908,17 +653,6 @@ 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__, *,
@@ -945,30 +679,6 @@ 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__, *,
@@ -1046,24 +756,6 @@ 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__, *,
@@ -1120,16 +812,6 @@ 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__, *,
@@ -1154,39 +836,6 @@ 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__, *,
@@ -1300,29 +949,6 @@ 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__, *,
@@ -1396,20 +1022,6 @@ 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__, *,
@@ -1460,16 +1072,6 @@ 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__, *,
@@ -1494,39 +1096,6 @@ 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__, *,
@@ -1640,15 +1209,6 @@ 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__, *,
@@ -1671,39 +1231,6 @@ 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__, *,
@@ -1817,24 +1344,6 @@ 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__, *,
@@ -1891,16 +1400,6 @@ 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__, *,
@@ -1925,39 +1424,6 @@ 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__, *,
@@ -2071,17 +1537,6 @@ 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__, *,
@@ -2108,17 +1563,6 @@ 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__, *,
@@ -2145,16 +1589,6 @@ 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__, *,
@@ -2179,29 +1613,6 @@ 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__, *,