# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities

__all__ = [
    'AutoscalarAutoscalingPolicyArgs',
    'AutoscalarAutoscalingPolicyCpuUtilizationArgs',
    'AutoscalarAutoscalingPolicyLoadBalancingUtilizationArgs',
    'AutoscalarAutoscalingPolicyMetricArgs',
    'AutoscalarAutoscalingPolicyScaleDownControlArgs',
    'AutoscalarAutoscalingPolicyScaleDownControlMaxScaledDownReplicasArgs',
    'AutoscalarAutoscalingPolicyScaleInControlArgs',
    'AutoscalarAutoscalingPolicyScaleInControlMaxScaledInReplicasArgs',
    'AutoscalarAutoscalingPolicyScalingScheduleArgs',
    'AutoscalerAutoscalingPolicyArgs',
    'AutoscalerAutoscalingPolicyCpuUtilizationArgs',
    'AutoscalerAutoscalingPolicyLoadBalancingUtilizationArgs',
    'AutoscalerAutoscalingPolicyMetricArgs',
    'AutoscalerAutoscalingPolicyScaleDownControlArgs',
    'AutoscalerAutoscalingPolicyScaleDownControlMaxScaledDownReplicasArgs',
    'AutoscalerAutoscalingPolicyScaleInControlArgs',
    'AutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicasArgs',
    'AutoscalerAutoscalingPolicyScalingScheduleArgs',
    'BackendBucketCdnPolicyArgs',
    'BackendBucketCdnPolicyBypassCacheOnRequestHeaderArgs',
    'BackendBucketCdnPolicyCacheKeyPolicyArgs',
    'BackendBucketCdnPolicyNegativeCachingPolicyArgs',
    'BackendBucketIamBindingConditionArgs',
    'BackendBucketIamMemberConditionArgs',
    'BackendServiceBackendArgs',
    'BackendServiceCdnPolicyArgs',
    'BackendServiceCdnPolicyCacheKeyPolicyArgs',
    'BackendServiceCdnPolicyNegativeCachingPolicyArgs',
    'BackendServiceCircuitBreakersArgs',
    'BackendServiceCircuitBreakersConnectTimeoutArgs',
    'BackendServiceConsistentHashArgs',
    'BackendServiceConsistentHashHttpCookieArgs',
    'BackendServiceConsistentHashHttpCookieTtlArgs',
    'BackendServiceIamBindingConditionArgs',
    'BackendServiceIamMemberConditionArgs',
    'BackendServiceIapArgs',
    'BackendServiceLogConfigArgs',
    'BackendServiceOutlierDetectionArgs',
    'BackendServiceOutlierDetectionBaseEjectionTimeArgs',
    'BackendServiceOutlierDetectionIntervalArgs',
    'BackendServiceSecuritySettingsArgs',
    'DiskDiskEncryptionKeyArgs',
    'DiskIamBindingConditionArgs',
    'DiskIamMemberConditionArgs',
    'DiskSourceImageEncryptionKeyArgs',
    'DiskSourceSnapshotEncryptionKeyArgs',
    'ExternalVpnGatewayInterfaceArgs',
    'FirewallAllowArgs',
    'FirewallDenyArgs',
    'FirewallLogConfigArgs',
    'FirewallPolicyRuleMatchArgs',
    'FirewallPolicyRuleMatchLayer4ConfigArgs',
    'ForwardingRuleServiceDirectoryRegistrationArgs',
    'GlobalForwardingRuleMetadataFilterArgs',
    'GlobalForwardingRuleMetadataFilterFilterLabelArgs',
    'HaVpnGatewayVpnInterfaceArgs',
    'HealthCheckGrpcHealthCheckArgs',
    'HealthCheckHttp2HealthCheckArgs',
    'HealthCheckHttpHealthCheckArgs',
    'HealthCheckHttpsHealthCheckArgs',
    'HealthCheckLogConfigArgs',
    'HealthCheckSslHealthCheckArgs',
    'HealthCheckTcpHealthCheckArgs',
    'ImageGuestOsFeatureArgs',
    'ImageIamBindingConditionArgs',
    'ImageIamMemberConditionArgs',
    'ImageRawDiskArgs',
    'InstanceAdvancedMachineFeaturesArgs',
    'InstanceAttachedDiskArgs',
    'InstanceBootDiskArgs',
    'InstanceBootDiskInitializeParamsArgs',
    'InstanceConfidentialInstanceConfigArgs',
    'InstanceFromMachineImageAdvancedMachineFeaturesArgs',
    'InstanceFromMachineImageAttachedDiskArgs',
    'InstanceFromMachineImageBootDiskArgs',
    'InstanceFromMachineImageBootDiskInitializeParamsArgs',
    'InstanceFromMachineImageConfidentialInstanceConfigArgs',
    'InstanceFromMachineImageGuestAcceleratorArgs',
    'InstanceFromMachineImageNetworkInterfaceArgs',
    'InstanceFromMachineImageNetworkInterfaceAccessConfigArgs',
    'InstanceFromMachineImageNetworkInterfaceAliasIpRangeArgs',
    'InstanceFromMachineImageNetworkInterfaceIpv6AccessConfigArgs',
    'InstanceFromMachineImageNetworkPerformanceConfigArgs',
    'InstanceFromMachineImageReservationAffinityArgs',
    'InstanceFromMachineImageReservationAffinitySpecificReservationArgs',
    'InstanceFromMachineImageSchedulingArgs',
    'InstanceFromMachineImageSchedulingNodeAffinityArgs',
    'InstanceFromMachineImageScratchDiskArgs',
    'InstanceFromMachineImageServiceAccountArgs',
    'InstanceFromMachineImageShieldedInstanceConfigArgs',
    'InstanceFromTemplateAdvancedMachineFeaturesArgs',
    'InstanceFromTemplateAttachedDiskArgs',
    'InstanceFromTemplateBootDiskArgs',
    'InstanceFromTemplateBootDiskInitializeParamsArgs',
    'InstanceFromTemplateConfidentialInstanceConfigArgs',
    'InstanceFromTemplateGuestAcceleratorArgs',
    'InstanceFromTemplateNetworkInterfaceArgs',
    'InstanceFromTemplateNetworkInterfaceAccessConfigArgs',
    'InstanceFromTemplateNetworkInterfaceAliasIpRangeArgs',
    'InstanceFromTemplateNetworkInterfaceIpv6AccessConfigArgs',
    'InstanceFromTemplateNetworkPerformanceConfigArgs',
    'InstanceFromTemplateReservationAffinityArgs',
    'InstanceFromTemplateReservationAffinitySpecificReservationArgs',
    'InstanceFromTemplateSchedulingArgs',
    'InstanceFromTemplateSchedulingNodeAffinityArgs',
    'InstanceFromTemplateScratchDiskArgs',
    'InstanceFromTemplateServiceAccountArgs',
    'InstanceFromTemplateShieldedInstanceConfigArgs',
    'InstanceGroupManagerAllInstancesConfigArgs',
    'InstanceGroupManagerAutoHealingPoliciesArgs',
    'InstanceGroupManagerNamedPortArgs',
    'InstanceGroupManagerStatefulDiskArgs',
    'InstanceGroupManagerStatusArgs',
    'InstanceGroupManagerStatusAllInstancesConfigArgs',
    'InstanceGroupManagerStatusStatefulArgs',
    'InstanceGroupManagerStatusStatefulPerInstanceConfigArgs',
    'InstanceGroupManagerStatusVersionTargetArgs',
    'InstanceGroupManagerUpdatePolicyArgs',
    'InstanceGroupManagerVersionArgs',
    'InstanceGroupManagerVersionTargetSizeArgs',
    'InstanceGroupNamedPortArgs',
    'InstanceGuestAcceleratorArgs',
    'InstanceIAMBindingConditionArgs',
    'InstanceIAMMemberConditionArgs',
    'InstanceNetworkInterfaceArgs',
    'InstanceNetworkInterfaceAccessConfigArgs',
    'InstanceNetworkInterfaceAliasIpRangeArgs',
    'InstanceNetworkInterfaceIpv6AccessConfigArgs',
    'InstanceNetworkPerformanceConfigArgs',
    'InstanceReservationAffinityArgs',
    'InstanceReservationAffinitySpecificReservationArgs',
    'InstanceSchedulingArgs',
    'InstanceSchedulingNodeAffinityArgs',
    'InstanceScratchDiskArgs',
    'InstanceServiceAccountArgs',
    'InstanceShieldedInstanceConfigArgs',
    'InstanceTemplateAdvancedMachineFeaturesArgs',
    'InstanceTemplateConfidentialInstanceConfigArgs',
    'InstanceTemplateDiskArgs',
    'InstanceTemplateDiskDiskEncryptionKeyArgs',
    'InstanceTemplateGuestAcceleratorArgs',
    'InstanceTemplateNetworkInterfaceArgs',
    'InstanceTemplateNetworkInterfaceAccessConfigArgs',
    'InstanceTemplateNetworkInterfaceAliasIpRangeArgs',
    'InstanceTemplateNetworkInterfaceIpv6AccessConfigArgs',
    'InstanceTemplateNetworkPerformanceConfigArgs',
    'InstanceTemplateReservationAffinityArgs',
    'InstanceTemplateReservationAffinitySpecificReservationArgs',
    'InstanceTemplateSchedulingArgs',
    'InstanceTemplateSchedulingNodeAffinityArgs',
    'InstanceTemplateServiceAccountArgs',
    'InstanceTemplateShieldedInstanceConfigArgs',
    'InterconnectAttachmentPrivateInterconnectInfoArgs',
    'MachineImageIamBindingConditionArgs',
    'MachineImageIamMemberConditionArgs',
    'MachineImageMachineImageEncryptionKeyArgs',
    'ManagedSslCertificateManagedArgs',
    'MangedSslCertificateManagedArgs',
    'NodeGroupAutoscalingPolicyArgs',
    'NodeGroupMaintenanceWindowArgs',
    'NodeTemplateNodeTypeFlexibilityArgs',
    'NodeTemplateServerBindingArgs',
    'OrganizationSecurityPolicyRuleMatchArgs',
    'OrganizationSecurityPolicyRuleMatchConfigArgs',
    'OrganizationSecurityPolicyRuleMatchConfigLayer4ConfigArgs',
    'PacketMirroringCollectorIlbArgs',
    'PacketMirroringFilterArgs',
    'PacketMirroringMirroredResourcesArgs',
    'PacketMirroringMirroredResourcesInstanceArgs',
    'PacketMirroringMirroredResourcesSubnetworkArgs',
    'PacketMirroringNetworkArgs',
    'PerInstanceConfigPreservedStateArgs',
    'PerInstanceConfigPreservedStateDiskArgs',
    'RegionAutoscalerAutoscalingPolicyArgs',
    'RegionAutoscalerAutoscalingPolicyCpuUtilizationArgs',
    'RegionAutoscalerAutoscalingPolicyLoadBalancingUtilizationArgs',
    'RegionAutoscalerAutoscalingPolicyMetricArgs',
    'RegionAutoscalerAutoscalingPolicyScaleDownControlArgs',
    'RegionAutoscalerAutoscalingPolicyScaleDownControlMaxScaledDownReplicasArgs',
    'RegionAutoscalerAutoscalingPolicyScaleInControlArgs',
    'RegionAutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicasArgs',
    'RegionAutoscalerAutoscalingPolicyScalingScheduleArgs',
    'RegionBackendServiceBackendArgs',
    'RegionBackendServiceCdnPolicyArgs',
    'RegionBackendServiceCdnPolicyCacheKeyPolicyArgs',
    'RegionBackendServiceCdnPolicyNegativeCachingPolicyArgs',
    'RegionBackendServiceCircuitBreakersArgs',
    'RegionBackendServiceCircuitBreakersConnectTimeoutArgs',
    'RegionBackendServiceConnectionTrackingPolicyArgs',
    'RegionBackendServiceConsistentHashArgs',
    'RegionBackendServiceConsistentHashHttpCookieArgs',
    'RegionBackendServiceConsistentHashHttpCookieTtlArgs',
    'RegionBackendServiceFailoverPolicyArgs',
    'RegionBackendServiceIamBindingConditionArgs',
    'RegionBackendServiceIamMemberConditionArgs',
    'RegionBackendServiceIapArgs',
    'RegionBackendServiceLogConfigArgs',
    'RegionBackendServiceOutlierDetectionArgs',
    'RegionBackendServiceOutlierDetectionBaseEjectionTimeArgs',
    'RegionBackendServiceOutlierDetectionIntervalArgs',
    'RegionBackendServiceSubsettingArgs',
    'RegionDiskDiskEncryptionKeyArgs',
    'RegionDiskIamBindingConditionArgs',
    'RegionDiskIamMemberConditionArgs',
    'RegionDiskSourceSnapshotEncryptionKeyArgs',
    'RegionHealthCheckGrpcHealthCheckArgs',
    'RegionHealthCheckHttp2HealthCheckArgs',
    'RegionHealthCheckHttpHealthCheckArgs',
    'RegionHealthCheckHttpsHealthCheckArgs',
    'RegionHealthCheckLogConfigArgs',
    'RegionHealthCheckSslHealthCheckArgs',
    'RegionHealthCheckTcpHealthCheckArgs',
    'RegionInstanceGroupManagerAllInstancesConfigArgs',
    'RegionInstanceGroupManagerAutoHealingPoliciesArgs',
    'RegionInstanceGroupManagerNamedPortArgs',
    'RegionInstanceGroupManagerStatefulDiskArgs',
    'RegionInstanceGroupManagerStatusArgs',
    'RegionInstanceGroupManagerStatusAllInstancesConfigArgs',
    'RegionInstanceGroupManagerStatusStatefulArgs',
    'RegionInstanceGroupManagerStatusStatefulPerInstanceConfigArgs',
    'RegionInstanceGroupManagerStatusVersionTargetArgs',
    'RegionInstanceGroupManagerUpdatePolicyArgs',
    'RegionInstanceGroupManagerVersionArgs',
    'RegionInstanceGroupManagerVersionTargetSizeArgs',
    'RegionNetworkEndpointGroupAppEngineArgs',
    'RegionNetworkEndpointGroupCloudFunctionArgs',
    'RegionNetworkEndpointGroupCloudRunArgs',
    'RegionNetworkEndpointGroupServerlessDeploymentArgs',
    'RegionPerInstanceConfigPreservedStateArgs',
    'RegionPerInstanceConfigPreservedStateDiskArgs',
    'RegionUrlMapDefaultUrlRedirectArgs',
    'RegionUrlMapHostRuleArgs',
    'RegionUrlMapPathMatcherArgs',
    'RegionUrlMapPathMatcherDefaultUrlRedirectArgs',
    'RegionUrlMapPathMatcherPathRuleArgs',
    'RegionUrlMapPathMatcherPathRuleRouteActionArgs',
    'RegionUrlMapPathMatcherPathRuleRouteActionCorsPolicyArgs',
    'RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs',
    'RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs',
    'RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs',
    'RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs',
    'RegionUrlMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs',
    'RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyArgs',
    'RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs',
    'RegionUrlMapPathMatcherPathRuleRouteActionTimeoutArgs',
    'RegionUrlMapPathMatcherPathRuleRouteActionUrlRewriteArgs',
    'RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs',
    'RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs',
    'RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs',
    'RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs',
    'RegionUrlMapPathMatcherPathRuleUrlRedirectArgs',
    'RegionUrlMapPathMatcherRouteRuleArgs',
    'RegionUrlMapPathMatcherRouteRuleHeaderActionArgs',
    'RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs',
    'RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs',
    'RegionUrlMapPathMatcherRouteRuleMatchRuleArgs',
    'RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs',
    'RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatchArgs',
    'RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs',
    'RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs',
    'RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs',
    'RegionUrlMapPathMatcherRouteRuleRouteActionArgs',
    'RegionUrlMapPathMatcherRouteRuleRouteActionCorsPolicyArgs',
    'RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyArgs',
    'RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbortArgs',
    'RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayArgs',
    'RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs',
    'RegionUrlMapPathMatcherRouteRuleRouteActionRequestMirrorPolicyArgs',
    'RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyArgs',
    'RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeoutArgs',
    'RegionUrlMapPathMatcherRouteRuleRouteActionTimeoutArgs',
    'RegionUrlMapPathMatcherRouteRuleRouteActionUrlRewriteArgs',
    'RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceArgs',
    'RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionArgs',
    'RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs',
    'RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs',
    'RegionUrlMapPathMatcherRouteRuleUrlRedirectArgs',
    'RegionUrlMapTestArgs',
    'ReservationShareSettingsArgs',
    'ReservationShareSettingsProjectMapArgs',
    'ReservationSpecificReservationArgs',
    'ReservationSpecificReservationInstancePropertiesArgs',
    'ReservationSpecificReservationInstancePropertiesGuestAcceleratorArgs',
    'ReservationSpecificReservationInstancePropertiesLocalSsdArgs',
    'ResourcePolicyGroupPlacementPolicyArgs',
    'ResourcePolicyInstanceSchedulePolicyArgs',
    'ResourcePolicyInstanceSchedulePolicyVmStartScheduleArgs',
    'ResourcePolicyInstanceSchedulePolicyVmStopScheduleArgs',
    'ResourcePolicySnapshotSchedulePolicyArgs',
    'ResourcePolicySnapshotSchedulePolicyRetentionPolicyArgs',
    'ResourcePolicySnapshotSchedulePolicyScheduleArgs',
    'ResourcePolicySnapshotSchedulePolicyScheduleDailyScheduleArgs',
    'ResourcePolicySnapshotSchedulePolicyScheduleHourlyScheduleArgs',
    'ResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleArgs',
    'ResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleDayOfWeekArgs',
    'ResourcePolicySnapshotSchedulePolicySnapshotPropertiesArgs',
    'RouterBgpArgs',
    'RouterBgpAdvertisedIpRangeArgs',
    'RouterNatLogConfigArgs',
    'RouterNatSubnetworkArgs',
    'RouterPeerAdvertisedIpRangeArgs',
    'RouterPeerBfdArgs',
    'SecurityPolicyAdaptiveProtectionConfigArgs',
    'SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigArgs',
    'SecurityPolicyAdvancedOptionsConfigArgs',
    'SecurityPolicyRuleArgs',
    'SecurityPolicyRuleMatchArgs',
    'SecurityPolicyRuleMatchConfigArgs',
    'SecurityPolicyRuleMatchExprArgs',
    'SecurityPolicyRuleRateLimitOptionsArgs',
    'SecurityPolicyRuleRateLimitOptionsBanThresholdArgs',
    'SecurityPolicyRuleRateLimitOptionsExceedRedirectOptionsArgs',
    'SecurityPolicyRuleRateLimitOptionsRateLimitThresholdArgs',
    'SecurityPolicyRuleRedirectOptionsArgs',
    'SecurityScanConfigAuthenticationArgs',
    'SecurityScanConfigAuthenticationCustomAccountArgs',
    'SecurityScanConfigAuthenticationGoogleAccountArgs',
    'SecurityScanConfigScheduleArgs',
    'ServiceAttachmentConnectedEndpointArgs',
    'ServiceAttachmentConsumerAcceptListArgs',
    'SnapshotIamBindingConditionArgs',
    'SnapshotIamMemberConditionArgs',
    'SnapshotSnapshotEncryptionKeyArgs',
    'SnapshotSourceDiskEncryptionKeyArgs',
    'SubnetworkIAMBindingConditionArgs',
    'SubnetworkIAMMemberConditionArgs',
    'SubnetworkLogConfigArgs',
    'SubnetworkSecondaryIpRangeArgs',
    'URLMapDefaultRouteActionArgs',
    'URLMapDefaultRouteActionCorsPolicyArgs',
    'URLMapDefaultRouteActionFaultInjectionPolicyArgs',
    'URLMapDefaultRouteActionFaultInjectionPolicyAbortArgs',
    'URLMapDefaultRouteActionFaultInjectionPolicyDelayArgs',
    'URLMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs',
    'URLMapDefaultRouteActionRequestMirrorPolicyArgs',
    'URLMapDefaultRouteActionRetryPolicyArgs',
    'URLMapDefaultRouteActionRetryPolicyPerTryTimeoutArgs',
    'URLMapDefaultRouteActionTimeoutArgs',
    'URLMapDefaultRouteActionUrlRewriteArgs',
    'URLMapDefaultRouteActionWeightedBackendServiceArgs',
    'URLMapDefaultRouteActionWeightedBackendServiceHeaderActionArgs',
    'URLMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs',
    'URLMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs',
    'URLMapDefaultUrlRedirectArgs',
    'URLMapHeaderActionArgs',
    'URLMapHeaderActionRequestHeadersToAddArgs',
    'URLMapHeaderActionResponseHeadersToAddArgs',
    'URLMapHostRuleArgs',
    'URLMapPathMatcherArgs',
    'URLMapPathMatcherDefaultRouteActionArgs',
    'URLMapPathMatcherDefaultRouteActionCorsPolicyArgs',
    'URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyArgs',
    'URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyAbortArgs',
    'URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayArgs',
    'URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs',
    'URLMapPathMatcherDefaultRouteActionRequestMirrorPolicyArgs',
    'URLMapPathMatcherDefaultRouteActionRetryPolicyArgs',
    'URLMapPathMatcherDefaultRouteActionRetryPolicyPerTryTimeoutArgs',
    'URLMapPathMatcherDefaultRouteActionTimeoutArgs',
    'URLMapPathMatcherDefaultRouteActionUrlRewriteArgs',
    'URLMapPathMatcherDefaultRouteActionWeightedBackendServiceArgs',
    'URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionArgs',
    'URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs',
    'URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs',
    'URLMapPathMatcherDefaultUrlRedirectArgs',
    'URLMapPathMatcherHeaderActionArgs',
    'URLMapPathMatcherHeaderActionRequestHeadersToAddArgs',
    'URLMapPathMatcherHeaderActionResponseHeadersToAddArgs',
    'URLMapPathMatcherPathRuleArgs',
    'URLMapPathMatcherPathRuleRouteActionArgs',
    'URLMapPathMatcherPathRuleRouteActionCorsPolicyArgs',
    'URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs',
    'URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs',
    'URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs',
    'URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs',
    'URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs',
    'URLMapPathMatcherPathRuleRouteActionRetryPolicyArgs',
    'URLMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs',
    'URLMapPathMatcherPathRuleRouteActionTimeoutArgs',
    'URLMapPathMatcherPathRuleRouteActionUrlRewriteArgs',
    'URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs',
    'URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs',
    'URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs',
    'URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs',
    'URLMapPathMatcherPathRuleUrlRedirectArgs',
    'URLMapPathMatcherRouteRuleArgs',
    'URLMapPathMatcherRouteRuleHeaderActionArgs',
    'URLMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs',
    'URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs',
    'URLMapPathMatcherRouteRuleMatchRuleArgs',
    'URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs',
    'URLMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatchArgs',
    'URLMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs',
    'URLMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs',
    'URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs',
    'URLMapPathMatcherRouteRuleRouteActionArgs',
    'URLMapPathMatcherRouteRuleRouteActionCorsPolicyArgs',
    'URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyArgs',
    'URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbortArgs',
    'URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayArgs',
    'URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs',
    'URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicyArgs',
    'URLMapPathMatcherRouteRuleRouteActionRetryPolicyArgs',
    'URLMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeoutArgs',
    'URLMapPathMatcherRouteRuleRouteActionTimeoutArgs',
    'URLMapPathMatcherRouteRuleRouteActionUrlRewriteArgs',
    'URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceArgs',
    'URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionArgs',
    'URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs',
    'URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs',
    'URLMapPathMatcherRouteRuleUrlRedirectArgs',
    'URLMapTestArgs',
]

@pulumi.input_type
class AutoscalarAutoscalingPolicyArgs:
    def __init__(__self__, *,
                 max_replicas: pulumi.Input[int],
                 min_replicas: pulumi.Input[int],
                 cooldown_period: Optional[pulumi.Input[int]] = None,
                 cpu_utilization: Optional[pulumi.Input['AutoscalarAutoscalingPolicyCpuUtilizationArgs']] = None,
                 load_balancing_utilization: Optional[pulumi.Input['AutoscalarAutoscalingPolicyLoadBalancingUtilizationArgs']] = None,
                 metrics: Optional[pulumi.Input[Sequence[pulumi.Input['AutoscalarAutoscalingPolicyMetricArgs']]]] = None,
                 mode: Optional[pulumi.Input[str]] = None,
                 scale_down_control: Optional[pulumi.Input['AutoscalarAutoscalingPolicyScaleDownControlArgs']] = None,
                 scale_in_control: Optional[pulumi.Input['AutoscalarAutoscalingPolicyScaleInControlArgs']] = None,
                 scaling_schedules: Optional[pulumi.Input[Sequence[pulumi.Input['AutoscalarAutoscalingPolicyScalingScheduleArgs']]]] = None):
        """
        :param pulumi.Input[int] max_replicas: The maximum number of instances that the autoscaler can scale up
               to. This is required when creating or updating an autoscaler. The
               maximum number of replicas should not be lower than minimal number
               of replicas.
        :param pulumi.Input[int] min_replicas: The minimum number of replicas that the autoscaler can scale down
               to. This cannot be less than 0. If not provided, autoscaler will
               choose a default value depending on maximum number of instances
               allowed.
        :param pulumi.Input[int] cooldown_period: The number of seconds that the autoscaler should wait before it
               starts collecting information from a new instance. This prevents
               the autoscaler from collecting information when the instance is
               initializing, during which the collected usage would not be
               reliable. The default time autoscaler waits is 60 seconds.
               Virtual machine initialization times might vary because of
               numerous factors. We recommend that you test how long an
               instance may take to initialize. To do this, create an instance
               and time the startup process.
        :param pulumi.Input['AutoscalarAutoscalingPolicyCpuUtilizationArgs'] cpu_utilization: Defines the CPU utilization policy that allows the autoscaler to
               scale based on the average CPU utilization of a managed instance
               group.
               Structure is documented below.
        :param pulumi.Input['AutoscalarAutoscalingPolicyLoadBalancingUtilizationArgs'] load_balancing_utilization: Configuration parameters of autoscaling based on a load balancer.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['AutoscalarAutoscalingPolicyMetricArgs']]] metrics: Configuration parameters of autoscaling based on a custom metric.
               Structure is documented below.
        :param pulumi.Input[str] mode: Defines operating mode for this policy.
               Default value is `ON`.
               Possible values are `OFF`, `ONLY_UP`, and `ON`.
        :param pulumi.Input['AutoscalarAutoscalingPolicyScaleDownControlArgs'] scale_down_control: Defines scale down controls to reduce the risk of response latency
               and outages due to abrupt scale-in events
               Structure is documented below.
        :param pulumi.Input['AutoscalarAutoscalingPolicyScaleInControlArgs'] scale_in_control: Defines scale in controls to reduce the risk of response latency
               and outages due to abrupt scale-in events
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['AutoscalarAutoscalingPolicyScalingScheduleArgs']]] scaling_schedules: Scaling schedules defined for an autoscaler. Multiple schedules can be set on an autoscaler and they can overlap.
               Structure is documented below.
        """
        pulumi.set(__self__, "max_replicas", max_replicas)
        pulumi.set(__self__, "min_replicas", min_replicas)
        if cooldown_period is not None:
            pulumi.set(__self__, "cooldown_period", cooldown_period)
        if cpu_utilization is not None:
            pulumi.set(__self__, "cpu_utilization", cpu_utilization)
        if load_balancing_utilization is not None:
            pulumi.set(__self__, "load_balancing_utilization", load_balancing_utilization)
        if metrics is not None:
            pulumi.set(__self__, "metrics", metrics)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if scale_down_control is not None:
            pulumi.set(__self__, "scale_down_control", scale_down_control)
        if scale_in_control is not None:
            pulumi.set(__self__, "scale_in_control", scale_in_control)
        if scaling_schedules is not None:
            pulumi.set(__self__, "scaling_schedules", scaling_schedules)

    @property
    @pulumi.getter(name="maxReplicas")
    def max_replicas(self) -> pulumi.Input[int]:
        """
        The maximum number of instances that the autoscaler can scale up
        to. This is required when creating or updating an autoscaler. The
        maximum number of replicas should not be lower than minimal number
        of replicas.
        """
        return pulumi.get(self, "max_replicas")

    @max_replicas.setter
    def max_replicas(self, value: pulumi.Input[int]):
        pulumi.set(self, "max_replicas", value)

    @property
    @pulumi.getter(name="minReplicas")
    def min_replicas(self) -> pulumi.Input[int]:
        """
        The minimum number of replicas that the autoscaler can scale down
        to. This cannot be less than 0. If not provided, autoscaler will
        choose a default value depending on maximum number of instances
        allowed.
        """
        return pulumi.get(self, "min_replicas")

    @min_replicas.setter
    def min_replicas(self, value: pulumi.Input[int]):
        pulumi.set(self, "min_replicas", value)

    @property
    @pulumi.getter(name="cooldownPeriod")
    def cooldown_period(self) -> Optional[pulumi.Input[int]]:
        """
        The number of seconds that the autoscaler should wait before it
        starts collecting information from a new instance. This prevents
        the autoscaler from collecting information when the instance is
        initializing, during which the collected usage would not be
        reliable. The default time autoscaler waits is 60 seconds.
        Virtual machine initialization times might vary because of
        numerous factors. We recommend that you test how long an
        instance may take to initialize. To do this, create an instance
        and time the startup process.
        """
        return pulumi.get(self, "cooldown_period")

    @cooldown_period.setter
    def cooldown_period(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "cooldown_period", value)

    @property
    @pulumi.getter(name="cpuUtilization")
    def cpu_utilization(self) -> Optional[pulumi.Input['AutoscalarAutoscalingPolicyCpuUtilizationArgs']]:
        """
        Defines the CPU utilization policy that allows the autoscaler to
        scale based on the average CPU utilization of a managed instance
        group.
        Structure is documented below.
        """
        return pulumi.get(self, "cpu_utilization")

    @cpu_utilization.setter
    def cpu_utilization(self, value: Optional[pulumi.Input['AutoscalarAutoscalingPolicyCpuUtilizationArgs']]):
        pulumi.set(self, "cpu_utilization", value)

    @property
    @pulumi.getter(name="loadBalancingUtilization")
    def load_balancing_utilization(self) -> Optional[pulumi.Input['AutoscalarAutoscalingPolicyLoadBalancingUtilizationArgs']]:
        """
        Configuration parameters of autoscaling based on a load balancer.
        Structure is documented below.
        """
        return pulumi.get(self, "load_balancing_utilization")

    @load_balancing_utilization.setter
    def load_balancing_utilization(self, value: Optional[pulumi.Input['AutoscalarAutoscalingPolicyLoadBalancingUtilizationArgs']]):
        pulumi.set(self, "load_balancing_utilization", value)

    @property
    @pulumi.getter
    def metrics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AutoscalarAutoscalingPolicyMetricArgs']]]]:
        """
        Configuration parameters of autoscaling based on a custom metric.
        Structure is documented below.
        """
        return pulumi.get(self, "metrics")

    @metrics.setter
    def metrics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AutoscalarAutoscalingPolicyMetricArgs']]]]):
        pulumi.set(self, "metrics", value)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[str]]:
        """
        Defines operating mode for this policy.
        Default value is `ON`.
        Possible values are `OFF`, `ONLY_UP`, and `ON`.
        """
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mode", value)

    @property
    @pulumi.getter(name="scaleDownControl")
    def scale_down_control(self) -> Optional[pulumi.Input['AutoscalarAutoscalingPolicyScaleDownControlArgs']]:
        """
        Defines scale down controls to reduce the risk of response latency
        and outages due to abrupt scale-in events
        Structure is documented below.
        """
        return pulumi.get(self, "scale_down_control")

    @scale_down_control.setter
    def scale_down_control(self, value: Optional[pulumi.Input['AutoscalarAutoscalingPolicyScaleDownControlArgs']]):
        pulumi.set(self, "scale_down_control", value)

    @property
    @pulumi.getter(name="scaleInControl")
    def scale_in_control(self) -> Optional[pulumi.Input['AutoscalarAutoscalingPolicyScaleInControlArgs']]:
        """
        Defines scale in controls to reduce the risk of response latency
        and outages due to abrupt scale-in events
        Structure is documented below.
        """
        return pulumi.get(self, "scale_in_control")

    @scale_in_control.setter
    def scale_in_control(self, value: Optional[pulumi.Input['AutoscalarAutoscalingPolicyScaleInControlArgs']]):
        pulumi.set(self, "scale_in_control", value)

    @property
    @pulumi.getter(name="scalingSchedules")
    def scaling_schedules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AutoscalarAutoscalingPolicyScalingScheduleArgs']]]]:
        """
        Scaling schedules defined for an autoscaler. Multiple schedules can be set on an autoscaler and they can overlap.
        Structure is documented below.
        """
        return pulumi.get(self, "scaling_schedules")

    @scaling_schedules.setter
    def scaling_schedules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AutoscalarAutoscalingPolicyScalingScheduleArgs']]]]):
        pulumi.set(self, "scaling_schedules", value)


@pulumi.input_type
class AutoscalarAutoscalingPolicyCpuUtilizationArgs:
    def __init__(__self__, *,
                 target: pulumi.Input[float],
                 predictive_method: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[float] target: Fraction of backend capacity utilization (set in HTTP(s) load
               balancing configuration) that autoscaler should maintain. Must
               be a positive float value. If not defined, the default is 0.8.
        :param pulumi.Input[str] predictive_method: Indicates whether predictive autoscaling based on CPU metric is enabled. Valid values are:
               - NONE (default). No predictive method is used. The autoscaler scales the group to meet current demand based on real-time metrics.
               - OPTIMIZE_AVAILABILITY. Predictive autoscaling improves availability by monitoring daily and weekly load patterns and scaling out ahead of anticipated demand.
        """
        pulumi.set(__self__, "target", target)
        if predictive_method is not None:
            pulumi.set(__self__, "predictive_method", predictive_method)

    @property
    @pulumi.getter
    def target(self) -> pulumi.Input[float]:
        """
        Fraction of backend capacity utilization (set in HTTP(s) load
        balancing configuration) that autoscaler should maintain. Must
        be a positive float value. If not defined, the default is 0.8.
        """
        return pulumi.get(self, "target")

    @target.setter
    def target(self, value: pulumi.Input[float]):
        pulumi.set(self, "target", value)

    @property
    @pulumi.getter(name="predictiveMethod")
    def predictive_method(self) -> Optional[pulumi.Input[str]]:
        """
        Indicates whether predictive autoscaling based on CPU metric is enabled. Valid values are:
        - NONE (default). No predictive method is used. The autoscaler scales the group to meet current demand based on real-time metrics.
        - OPTIMIZE_AVAILABILITY. Predictive autoscaling improves availability by monitoring daily and weekly load patterns and scaling out ahead of anticipated demand.
        """
        return pulumi.get(self, "predictive_method")

    @predictive_method.setter
    def predictive_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "predictive_method", value)


@pulumi.input_type
class AutoscalarAutoscalingPolicyLoadBalancingUtilizationArgs:
    def __init__(__self__, *,
                 target: pulumi.Input[float]):
        """
        :param pulumi.Input[float] target: Fraction of backend capacity utilization (set in HTTP(s) load
               balancing configuration) that autoscaler should maintain. Must
               be a positive float value. If not defined, the default is 0.8.
        """
        pulumi.set(__self__, "target", target)

    @property
    @pulumi.getter
    def target(self) -> pulumi.Input[float]:
        """
        Fraction of backend capacity utilization (set in HTTP(s) load
        balancing configuration) that autoscaler should maintain. Must
        be a positive float value. If not defined, the default is 0.8.
        """
        return pulumi.get(self, "target")

    @target.setter
    def target(self, value: pulumi.Input[float]):
        pulumi.set(self, "target", value)


@pulumi.input_type
class AutoscalarAutoscalingPolicyMetricArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 filter: Optional[pulumi.Input[str]] = None,
                 single_instance_assignment: Optional[pulumi.Input[float]] = None,
                 target: Optional[pulumi.Input[float]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for this object. Format specified above.
        :param pulumi.Input[str] filter: A filter string to be used as the filter string for
               a Stackdriver Monitoring TimeSeries.list API call.
               This filter is used to select a specific TimeSeries for
               the purpose of autoscaling and to determine whether the metric
               is exporting per-instance or per-group data.
               You can only use the AND operator for joining selectors.
               You can only use direct equality comparison operator (=) without
               any functions for each selector.
               You can specify the metric in both the filter string and in the
               metric field. However, if specified in both places, the metric must
               be identical.
               The monitored resource type determines what kind of values are
               expected for the metric. If it is a gce_instance, the autoscaler
               expects the metric to include a separate TimeSeries for each
               instance in a group. In such a case, you cannot filter on resource
               labels.
               If the resource type is any other value, the autoscaler expects
               this metric to contain values that apply to the entire autoscaled
               instance group and resource label filtering can be performed to
               point autoscaler at the correct TimeSeries to scale upon.
               This is called a per-group metric for the purpose of autoscaling.
               If not specified, the type defaults to gce_instance.
               You should provide a filter that is selective enough to pick just
               one TimeSeries for the autoscaled group or for each of the instances
               (if you are using gce_instance resource type). If multiple
               TimeSeries are returned upon the query execution, the autoscaler
               will sum their respective values to obtain its scaling value.
        :param pulumi.Input[float] single_instance_assignment: If scaling is based on a per-group metric value that represents the
               total amount of work to be done or resource usage, set this value to
               an amount assigned for a single instance of the scaled group.
               The autoscaler will keep the number of instances proportional to the
               value of this metric, the metric itself should not change value due
               to group resizing.
               For example, a good metric to use with the target is
               `pubsub.googleapis.com/subscription/num_undelivered_messages`
               or a custom metric exporting the total number of requests coming to
               your instances.
               A bad example would be a metric exporting an average or median
               latency, since this value can't include a chunk assignable to a
               single instance, it could be better used with utilization_target
               instead.
        :param pulumi.Input[float] target: Fraction of backend capacity utilization (set in HTTP(s) load
               balancing configuration) that autoscaler should maintain. Must
               be a positive float value. If not defined, the default is 0.8.
        :param pulumi.Input[str] type: Defines how target utilization value is expressed for a
               Stackdriver Monitoring metric.
               Possible values are `GAUGE`, `DELTA_PER_SECOND`, and `DELTA_PER_MINUTE`.
        """
        pulumi.set(__self__, "name", name)
        if filter is not None:
            pulumi.set(__self__, "filter", filter)
        if single_instance_assignment is not None:
            pulumi.set(__self__, "single_instance_assignment", single_instance_assignment)
        if target is not None:
            pulumi.set(__self__, "target", target)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The identifier for this object. Format specified above.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def filter(self) -> Optional[pulumi.Input[str]]:
        """
        A filter string to be used as the filter string for
        a Stackdriver Monitoring TimeSeries.list API call.
        This filter is used to select a specific TimeSeries for
        the purpose of autoscaling and to determine whether the metric
        is exporting per-instance or per-group data.
        You can only use the AND operator for joining selectors.
        You can only use direct equality comparison operator (=) without
        any functions for each selector.
        You can specify the metric in both the filter string and in the
        metric field. However, if specified in both places, the metric must
        be identical.
        The monitored resource type determines what kind of values are
        expected for the metric. If it is a gce_instance, the autoscaler
        expects the metric to include a separate TimeSeries for each
        instance in a group. In such a case, you cannot filter on resource
        labels.
        If the resource type is any other value, the autoscaler expects
        this metric to contain values that apply to the entire autoscaled
        instance group and resource label filtering can be performed to
        point autoscaler at the correct TimeSeries to scale upon.
        This is called a per-group metric for the purpose of autoscaling.
        If not specified, the type defaults to gce_instance.
        You should provide a filter that is selective enough to pick just
        one TimeSeries for the autoscaled group or for each of the instances
        (if you are using gce_instance resource type). If multiple
        TimeSeries are returned upon the query execution, the autoscaler
        will sum their respective values to obtain its scaling value.
        """
        return pulumi.get(self, "filter")

    @filter.setter
    def filter(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "filter", value)

    @property
    @pulumi.getter(name="singleInstanceAssignment")
    def single_instance_assignment(self) -> Optional[pulumi.Input[float]]:
        """
        If scaling is based on a per-group metric value that represents the
        total amount of work to be done or resource usage, set this value to
        an amount assigned for a single instance of the scaled group.
        The autoscaler will keep the number of instances proportional to the
        value of this metric, the metric itself should not change value due
        to group resizing.
        For example, a good metric to use with the target is
        `pubsub.googleapis.com/subscription/num_undelivered_messages`
        or a custom metric exporting the total number of requests coming to
        your instances.
        A bad example would be a metric exporting an average or median
        latency, since this value can't include a chunk assignable to a
        single instance, it could be better used with utilization_target
        instead.
        """
        return pulumi.get(self, "single_instance_assignment")

    @single_instance_assignment.setter
    def single_instance_assignment(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "single_instance_assignment", value)

    @property
    @pulumi.getter
    def target(self) -> Optional[pulumi.Input[float]]:
        """
        Fraction of backend capacity utilization (set in HTTP(s) load
        balancing configuration) that autoscaler should maintain. Must
        be a positive float value. If not defined, the default is 0.8.
        """
        return pulumi.get(self, "target")

    @target.setter
    def target(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "target", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Defines how target utilization value is expressed for a
        Stackdriver Monitoring metric.
        Possible values are `GAUGE`, `DELTA_PER_SECOND`, and `DELTA_PER_MINUTE`.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class AutoscalarAutoscalingPolicyScaleDownControlArgs:
    def __init__(__self__, *,
                 max_scaled_down_replicas: Optional[pulumi.Input['AutoscalarAutoscalingPolicyScaleDownControlMaxScaledDownReplicasArgs']] = None,
                 time_window_sec: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input['AutoscalarAutoscalingPolicyScaleDownControlMaxScaledDownReplicasArgs'] max_scaled_down_replicas: A nested object resource
               Structure is documented below.
        :param pulumi.Input[int] time_window_sec: How long back autoscaling should look when computing recommendations
               to include directives regarding slower scale down, as described above.
        """
        if max_scaled_down_replicas is not None:
            pulumi.set(__self__, "max_scaled_down_replicas", max_scaled_down_replicas)
        if time_window_sec is not None:
            pulumi.set(__self__, "time_window_sec", time_window_sec)

    @property
    @pulumi.getter(name="maxScaledDownReplicas")
    def max_scaled_down_replicas(self) -> Optional[pulumi.Input['AutoscalarAutoscalingPolicyScaleDownControlMaxScaledDownReplicasArgs']]:
        """
        A nested object resource
        Structure is documented below.
        """
        return pulumi.get(self, "max_scaled_down_replicas")

    @max_scaled_down_replicas.setter
    def max_scaled_down_replicas(self, value: Optional[pulumi.Input['AutoscalarAutoscalingPolicyScaleDownControlMaxScaledDownReplicasArgs']]):
        pulumi.set(self, "max_scaled_down_replicas", value)

    @property
    @pulumi.getter(name="timeWindowSec")
    def time_window_sec(self) -> Optional[pulumi.Input[int]]:
        """
        How long back autoscaling should look when computing recommendations
        to include directives regarding slower scale down, as described above.
        """
        return pulumi.get(self, "time_window_sec")

    @time_window_sec.setter
    def time_window_sec(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "time_window_sec", value)


@pulumi.input_type
class AutoscalarAutoscalingPolicyScaleDownControlMaxScaledDownReplicasArgs:
    def __init__(__self__, *,
                 fixed: Optional[pulumi.Input[int]] = None,
                 percent: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] fixed: Specifies a fixed number of VM instances. This must be a positive
               integer.
        :param pulumi.Input[int] percent: Specifies a percentage of instances between 0 to 100%, inclusive.
               For example, specify 80 for 80%.
        """
        if fixed is not None:
            pulumi.set(__self__, "fixed", fixed)
        if percent is not None:
            pulumi.set(__self__, "percent", percent)

    @property
    @pulumi.getter
    def fixed(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies a fixed number of VM instances. This must be a positive
        integer.
        """
        return pulumi.get(self, "fixed")

    @fixed.setter
    def fixed(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "fixed", value)

    @property
    @pulumi.getter
    def percent(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies a percentage of instances between 0 to 100%, inclusive.
        For example, specify 80 for 80%.
        """
        return pulumi.get(self, "percent")

    @percent.setter
    def percent(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "percent", value)


@pulumi.input_type
class AutoscalarAutoscalingPolicyScaleInControlArgs:
    def __init__(__self__, *,
                 max_scaled_in_replicas: Optional[pulumi.Input['AutoscalarAutoscalingPolicyScaleInControlMaxScaledInReplicasArgs']] = None,
                 time_window_sec: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input['AutoscalarAutoscalingPolicyScaleInControlMaxScaledInReplicasArgs'] max_scaled_in_replicas: A nested object resource
               Structure is documented below.
        :param pulumi.Input[int] time_window_sec: How long back autoscaling should look when computing recommendations
               to include directives regarding slower scale down, as described above.
        """
        if max_scaled_in_replicas is not None:
            pulumi.set(__self__, "max_scaled_in_replicas", max_scaled_in_replicas)
        if time_window_sec is not None:
            pulumi.set(__self__, "time_window_sec", time_window_sec)

    @property
    @pulumi.getter(name="maxScaledInReplicas")
    def max_scaled_in_replicas(self) -> Optional[pulumi.Input['AutoscalarAutoscalingPolicyScaleInControlMaxScaledInReplicasArgs']]:
        """
        A nested object resource
        Structure is documented below.
        """
        return pulumi.get(self, "max_scaled_in_replicas")

    @max_scaled_in_replicas.setter
    def max_scaled_in_replicas(self, value: Optional[pulumi.Input['AutoscalarAutoscalingPolicyScaleInControlMaxScaledInReplicasArgs']]):
        pulumi.set(self, "max_scaled_in_replicas", value)

    @property
    @pulumi.getter(name="timeWindowSec")
    def time_window_sec(self) -> Optional[pulumi.Input[int]]:
        """
        How long back autoscaling should look when computing recommendations
        to include directives regarding slower scale down, as described above.
        """
        return pulumi.get(self, "time_window_sec")

    @time_window_sec.setter
    def time_window_sec(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "time_window_sec", value)


@pulumi.input_type
class AutoscalarAutoscalingPolicyScaleInControlMaxScaledInReplicasArgs:
    def __init__(__self__, *,
                 fixed: Optional[pulumi.Input[int]] = None,
                 percent: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] fixed: Specifies a fixed number of VM instances. This must be a positive
               integer.
        :param pulumi.Input[int] percent: Specifies a percentage of instances between 0 to 100%, inclusive.
               For example, specify 80 for 80%.
        """
        if fixed is not None:
            pulumi.set(__self__, "fixed", fixed)
        if percent is not None:
            pulumi.set(__self__, "percent", percent)

    @property
    @pulumi.getter
    def fixed(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies a fixed number of VM instances. This must be a positive
        integer.
        """
        return pulumi.get(self, "fixed")

    @fixed.setter
    def fixed(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "fixed", value)

    @property
    @pulumi.getter
    def percent(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies a percentage of instances between 0 to 100%, inclusive.
        For example, specify 80 for 80%.
        """
        return pulumi.get(self, "percent")

    @percent.setter
    def percent(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "percent", value)


@pulumi.input_type
class AutoscalarAutoscalingPolicyScalingScheduleArgs:
    def __init__(__self__, *,
                 duration_sec: pulumi.Input[int],
                 min_required_replicas: pulumi.Input[int],
                 name: pulumi.Input[str],
                 schedule: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None,
                 disabled: Optional[pulumi.Input[bool]] = None,
                 time_zone: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] duration_sec: The duration of time intervals (in seconds) for which this scaling schedule will be running. The minimum allowed value is 300.
        :param pulumi.Input[int] min_required_replicas: Minimum number of VM instances that autoscaler will recommend in time intervals starting according to schedule.
        :param pulumi.Input[str] name: The identifier for this object. Format specified above.
        :param pulumi.Input[str] schedule: The start timestamps of time intervals when this scaling schedule should provide a scaling signal. This field uses the extended cron format (with an optional year field).
        :param pulumi.Input[str] description: An optional description of this resource.
        :param pulumi.Input[bool] disabled: A boolean value that specifies if a scaling schedule can influence autoscaler recommendations. If set to true, then a scaling schedule has no effect.
        :param pulumi.Input[str] time_zone: The time zone to be used when interpreting the schedule. The value of this field must be a time zone name from the tz database: http://en.wikipedia.org/wiki/Tz_database.
        """
        pulumi.set(__self__, "duration_sec", duration_sec)
        pulumi.set(__self__, "min_required_replicas", min_required_replicas)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "schedule", schedule)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)
        if time_zone is not None:
            pulumi.set(__self__, "time_zone", time_zone)

    @property
    @pulumi.getter(name="durationSec")
    def duration_sec(self) -> pulumi.Input[int]:
        """
        The duration of time intervals (in seconds) for which this scaling schedule will be running. The minimum allowed value is 300.
        """
        return pulumi.get(self, "duration_sec")

    @duration_sec.setter
    def duration_sec(self, value: pulumi.Input[int]):
        pulumi.set(self, "duration_sec", value)

    @property
    @pulumi.getter(name="minRequiredReplicas")
    def min_required_replicas(self) -> pulumi.Input[int]:
        """
        Minimum number of VM instances that autoscaler will recommend in time intervals starting according to schedule.
        """
        return pulumi.get(self, "min_required_replicas")

    @min_required_replicas.setter
    def min_required_replicas(self, value: pulumi.Input[int]):
        pulumi.set(self, "min_required_replicas", value)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The identifier for this object. Format specified above.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def schedule(self) -> pulumi.Input[str]:
        """
        The start timestamps of time intervals when this scaling schedule should provide a scaling signal. This field uses the extended cron format (with an optional year field).
        """
        return pulumi.get(self, "schedule")

    @schedule.setter
    def schedule(self, value: pulumi.Input[str]):
        pulumi.set(self, "schedule", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        An optional description of this resource.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        A boolean value that specifies if a scaling schedule can influence autoscaler recommendations. If set to true, then a scaling schedule has no effect.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)

    @property
    @pulumi.getter(name="timeZone")
    def time_zone(self) -> Optional[pulumi.Input[str]]:
        """
        The time zone to be used when interpreting the schedule. The value of this field must be a time zone name from the tz database: http://en.wikipedia.org/wiki/Tz_database.
        """
        return pulumi.get(self, "time_zone")

    @time_zone.setter
    def time_zone(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "time_zone", value)


@pulumi.input_type
class AutoscalerAutoscalingPolicyArgs:
    def __init__(__self__, *,
                 max_replicas: pulumi.Input[int],
                 min_replicas: pulumi.Input[int],
                 cooldown_period: Optional[pulumi.Input[int]] = None,
                 cpu_utilization: Optional[pulumi.Input['AutoscalerAutoscalingPolicyCpuUtilizationArgs']] = None,
                 load_balancing_utilization: Optional[pulumi.Input['AutoscalerAutoscalingPolicyLoadBalancingUtilizationArgs']] = None,
                 metrics: Optional[pulumi.Input[Sequence[pulumi.Input['AutoscalerAutoscalingPolicyMetricArgs']]]] = None,
                 mode: Optional[pulumi.Input[str]] = None,
                 scale_down_control: Optional[pulumi.Input['AutoscalerAutoscalingPolicyScaleDownControlArgs']] = None,
                 scale_in_control: Optional[pulumi.Input['AutoscalerAutoscalingPolicyScaleInControlArgs']] = None,
                 scaling_schedules: Optional[pulumi.Input[Sequence[pulumi.Input['AutoscalerAutoscalingPolicyScalingScheduleArgs']]]] = None):
        """
        :param pulumi.Input[int] max_replicas: The maximum number of instances that the autoscaler can scale up
               to. This is required when creating or updating an autoscaler. The
               maximum number of replicas should not be lower than minimal number
               of replicas.
        :param pulumi.Input[int] min_replicas: The minimum number of replicas that the autoscaler can scale down
               to. This cannot be less than 0. If not provided, autoscaler will
               choose a default value depending on maximum number of instances
               allowed.
        :param pulumi.Input[int] cooldown_period: The number of seconds that the autoscaler should wait before it
               starts collecting information from a new instance. This prevents
               the autoscaler from collecting information when the instance is
               initializing, during which the collected usage would not be
               reliable. The default time autoscaler waits is 60 seconds.
               Virtual machine initialization times might vary because of
               numerous factors. We recommend that you test how long an
               instance may take to initialize. To do this, create an instance
               and time the startup process.
        :param pulumi.Input['AutoscalerAutoscalingPolicyCpuUtilizationArgs'] cpu_utilization: Defines the CPU utilization policy that allows the autoscaler to
               scale based on the average CPU utilization of a managed instance
               group.
               Structure is documented below.
        :param pulumi.Input['AutoscalerAutoscalingPolicyLoadBalancingUtilizationArgs'] load_balancing_utilization: Configuration parameters of autoscaling based on a load balancer.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['AutoscalerAutoscalingPolicyMetricArgs']]] metrics: Configuration parameters of autoscaling based on a custom metric.
               Structure is documented below.
        :param pulumi.Input[str] mode: Defines operating mode for this policy.
               Default value is `ON`.
               Possible values are `OFF`, `ONLY_UP`, and `ON`.
        :param pulumi.Input['AutoscalerAutoscalingPolicyScaleDownControlArgs'] scale_down_control: Defines scale down controls to reduce the risk of response latency
               and outages due to abrupt scale-in events
               Structure is documented below.
        :param pulumi.Input['AutoscalerAutoscalingPolicyScaleInControlArgs'] scale_in_control: Defines scale in controls to reduce the risk of response latency
               and outages due to abrupt scale-in events
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['AutoscalerAutoscalingPolicyScalingScheduleArgs']]] scaling_schedules: Scaling schedules defined for an autoscaler. Multiple schedules can be set on an autoscaler and they can overlap.
               Structure is documented below.
        """
        pulumi.set(__self__, "max_replicas", max_replicas)
        pulumi.set(__self__, "min_replicas", min_replicas)
        if cooldown_period is not None:
            pulumi.set(__self__, "cooldown_period", cooldown_period)
        if cpu_utilization is not None:
            pulumi.set(__self__, "cpu_utilization", cpu_utilization)
        if load_balancing_utilization is not None:
            pulumi.set(__self__, "load_balancing_utilization", load_balancing_utilization)
        if metrics is not None:
            pulumi.set(__self__, "metrics", metrics)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if scale_down_control is not None:
            pulumi.set(__self__, "scale_down_control", scale_down_control)
        if scale_in_control is not None:
            pulumi.set(__self__, "scale_in_control", scale_in_control)
        if scaling_schedules is not None:
            pulumi.set(__self__, "scaling_schedules", scaling_schedules)

    @property
    @pulumi.getter(name="maxReplicas")
    def max_replicas(self) -> pulumi.Input[int]:
        """
        The maximum number of instances that the autoscaler can scale up
        to. This is required when creating or updating an autoscaler. The
        maximum number of replicas should not be lower than minimal number
        of replicas.
        """
        return pulumi.get(self, "max_replicas")

    @max_replicas.setter
    def max_replicas(self, value: pulumi.Input[int]):
        pulumi.set(self, "max_replicas", value)

    @property
    @pulumi.getter(name="minReplicas")
    def min_replicas(self) -> pulumi.Input[int]:
        """
        The minimum number of replicas that the autoscaler can scale down
        to. This cannot be less than 0. If not provided, autoscaler will
        choose a default value depending on maximum number of instances
        allowed.
        """
        return pulumi.get(self, "min_replicas")

    @min_replicas.setter
    def min_replicas(self, value: pulumi.Input[int]):
        pulumi.set(self, "min_replicas", value)

    @property
    @pulumi.getter(name="cooldownPeriod")
    def cooldown_period(self) -> Optional[pulumi.Input[int]]:
        """
        The number of seconds that the autoscaler should wait before it
        starts collecting information from a new instance. This prevents
        the autoscaler from collecting information when the instance is
        initializing, during which the collected usage would not be
        reliable. The default time autoscaler waits is 60 seconds.
        Virtual machine initialization times might vary because of
        numerous factors. We recommend that you test how long an
        instance may take to initialize. To do this, create an instance
        and time the startup process.
        """
        return pulumi.get(self, "cooldown_period")

    @cooldown_period.setter
    def cooldown_period(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "cooldown_period", value)

    @property
    @pulumi.getter(name="cpuUtilization")
    def cpu_utilization(self) -> Optional[pulumi.Input['AutoscalerAutoscalingPolicyCpuUtilizationArgs']]:
        """
        Defines the CPU utilization policy that allows the autoscaler to
        scale based on the average CPU utilization of a managed instance
        group.
        Structure is documented below.
        """
        return pulumi.get(self, "cpu_utilization")

    @cpu_utilization.setter
    def cpu_utilization(self, value: Optional[pulumi.Input['AutoscalerAutoscalingPolicyCpuUtilizationArgs']]):
        pulumi.set(self, "cpu_utilization", value)

    @property
    @pulumi.getter(name="loadBalancingUtilization")
    def load_balancing_utilization(self) -> Optional[pulumi.Input['AutoscalerAutoscalingPolicyLoadBalancingUtilizationArgs']]:
        """
        Configuration parameters of autoscaling based on a load balancer.
        Structure is documented below.
        """
        return pulumi.get(self, "load_balancing_utilization")

    @load_balancing_utilization.setter
    def load_balancing_utilization(self, value: Optional[pulumi.Input['AutoscalerAutoscalingPolicyLoadBalancingUtilizationArgs']]):
        pulumi.set(self, "load_balancing_utilization", value)

    @property
    @pulumi.getter
    def metrics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AutoscalerAutoscalingPolicyMetricArgs']]]]:
        """
        Configuration parameters of autoscaling based on a custom metric.
        Structure is documented below.
        """
        return pulumi.get(self, "metrics")

    @metrics.setter
    def metrics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AutoscalerAutoscalingPolicyMetricArgs']]]]):
        pulumi.set(self, "metrics", value)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[str]]:
        """
        Defines operating mode for this policy.
        Default value is `ON`.
        Possible values are `OFF`, `ONLY_UP`, and `ON`.
        """
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mode", value)

    @property
    @pulumi.getter(name="scaleDownControl")
    def scale_down_control(self) -> Optional[pulumi.Input['AutoscalerAutoscalingPolicyScaleDownControlArgs']]:
        """
        Defines scale down controls to reduce the risk of response latency
        and outages due to abrupt scale-in events
        Structure is documented below.
        """
        return pulumi.get(self, "scale_down_control")

    @scale_down_control.setter
    def scale_down_control(self, value: Optional[pulumi.Input['AutoscalerAutoscalingPolicyScaleDownControlArgs']]):
        pulumi.set(self, "scale_down_control", value)

    @property
    @pulumi.getter(name="scaleInControl")
    def scale_in_control(self) -> Optional[pulumi.Input['AutoscalerAutoscalingPolicyScaleInControlArgs']]:
        """
        Defines scale in controls to reduce the risk of response latency
        and outages due to abrupt scale-in events
        Structure is documented below.
        """
        return pulumi.get(self, "scale_in_control")

    @scale_in_control.setter
    def scale_in_control(self, value: Optional[pulumi.Input['AutoscalerAutoscalingPolicyScaleInControlArgs']]):
        pulumi.set(self, "scale_in_control", value)

    @property
    @pulumi.getter(name="scalingSchedules")
    def scaling_schedules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AutoscalerAutoscalingPolicyScalingScheduleArgs']]]]:
        """
        Scaling schedules defined for an autoscaler. Multiple schedules can be set on an autoscaler and they can overlap.
        Structure is documented below.
        """
        return pulumi.get(self, "scaling_schedules")

    @scaling_schedules.setter
    def scaling_schedules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AutoscalerAutoscalingPolicyScalingScheduleArgs']]]]):
        pulumi.set(self, "scaling_schedules", value)


@pulumi.input_type
class AutoscalerAutoscalingPolicyCpuUtilizationArgs:
    def __init__(__self__, *,
                 target: pulumi.Input[float],
                 predictive_method: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[float] target: Fraction of backend capacity utilization (set in HTTP(s) load
               balancing configuration) that autoscaler should maintain. Must
               be a positive float value. If not defined, the default is 0.8.
        :param pulumi.Input[str] predictive_method: Indicates whether predictive autoscaling based on CPU metric is enabled. Valid values are:
               - NONE (default). No predictive method is used. The autoscaler scales the group to meet current demand based on real-time metrics.
               - OPTIMIZE_AVAILABILITY. Predictive autoscaling improves availability by monitoring daily and weekly load patterns and scaling out ahead of anticipated demand.
        """
        pulumi.set(__self__, "target", target)
        if predictive_method is not None:
            pulumi.set(__self__, "predictive_method", predictive_method)

    @property
    @pulumi.getter
    def target(self) -> pulumi.Input[float]:
        """
        Fraction of backend capacity utilization (set in HTTP(s) load
        balancing configuration) that autoscaler should maintain. Must
        be a positive float value. If not defined, the default is 0.8.
        """
        return pulumi.get(self, "target")

    @target.setter
    def target(self, value: pulumi.Input[float]):
        pulumi.set(self, "target", value)

    @property
    @pulumi.getter(name="predictiveMethod")
    def predictive_method(self) -> Optional[pulumi.Input[str]]:
        """
        Indicates whether predictive autoscaling based on CPU metric is enabled. Valid values are:
        - NONE (default). No predictive method is used. The autoscaler scales the group to meet current demand based on real-time metrics.
        - OPTIMIZE_AVAILABILITY. Predictive autoscaling improves availability by monitoring daily and weekly load patterns and scaling out ahead of anticipated demand.
        """
        return pulumi.get(self, "predictive_method")

    @predictive_method.setter
    def predictive_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "predictive_method", value)


@pulumi.input_type
class AutoscalerAutoscalingPolicyLoadBalancingUtilizationArgs:
    def __init__(__self__, *,
                 target: pulumi.Input[float]):
        """
        :param pulumi.Input[float] target: Fraction of backend capacity utilization (set in HTTP(s) load
               balancing configuration) that autoscaler should maintain. Must
               be a positive float value. If not defined, the default is 0.8.
        """
        pulumi.set(__self__, "target", target)

    @property
    @pulumi.getter
    def target(self) -> pulumi.Input[float]:
        """
        Fraction of backend capacity utilization (set in HTTP(s) load
        balancing configuration) that autoscaler should maintain. Must
        be a positive float value. If not defined, the default is 0.8.
        """
        return pulumi.get(self, "target")

    @target.setter
    def target(self, value: pulumi.Input[float]):
        pulumi.set(self, "target", value)


@pulumi.input_type
class AutoscalerAutoscalingPolicyMetricArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 filter: Optional[pulumi.Input[str]] = None,
                 single_instance_assignment: Optional[pulumi.Input[float]] = None,
                 target: Optional[pulumi.Input[float]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for this object. Format specified above.
        :param pulumi.Input[str] filter: A filter string to be used as the filter string for
               a Stackdriver Monitoring TimeSeries.list API call.
               This filter is used to select a specific TimeSeries for
               the purpose of autoscaling and to determine whether the metric
               is exporting per-instance or per-group data.
               You can only use the AND operator for joining selectors.
               You can only use direct equality comparison operator (=) without
               any functions for each selector.
               You can specify the metric in both the filter string and in the
               metric field. However, if specified in both places, the metric must
               be identical.
               The monitored resource type determines what kind of values are
               expected for the metric. If it is a gce_instance, the autoscaler
               expects the metric to include a separate TimeSeries for each
               instance in a group. In such a case, you cannot filter on resource
               labels.
               If the resource type is any other value, the autoscaler expects
               this metric to contain values that apply to the entire autoscaled
               instance group and resource label filtering can be performed to
               point autoscaler at the correct TimeSeries to scale upon.
               This is called a per-group metric for the purpose of autoscaling.
               If not specified, the type defaults to gce_instance.
               You should provide a filter that is selective enough to pick just
               one TimeSeries for the autoscaled group or for each of the instances
               (if you are using gce_instance resource type). If multiple
               TimeSeries are returned upon the query execution, the autoscaler
               will sum their respective values to obtain its scaling value.
        :param pulumi.Input[float] single_instance_assignment: If scaling is based on a per-group metric value that represents the
               total amount of work to be done or resource usage, set this value to
               an amount assigned for a single instance of the scaled group.
               The autoscaler will keep the number of instances proportional to the
               value of this metric, the metric itself should not change value due
               to group resizing.
               For example, a good metric to use with the target is
               `pubsub.googleapis.com/subscription/num_undelivered_messages`
               or a custom metric exporting the total number of requests coming to
               your instances.
               A bad example would be a metric exporting an average or median
               latency, since this value can't include a chunk assignable to a
               single instance, it could be better used with utilization_target
               instead.
        :param pulumi.Input[float] target: Fraction of backend capacity utilization (set in HTTP(s) load
               balancing configuration) that autoscaler should maintain. Must
               be a positive float value. If not defined, the default is 0.8.
        :param pulumi.Input[str] type: Defines how target utilization value is expressed for a
               Stackdriver Monitoring metric.
               Possible values are `GAUGE`, `DELTA_PER_SECOND`, and `DELTA_PER_MINUTE`.
        """
        pulumi.set(__self__, "name", name)
        if filter is not None:
            pulumi.set(__self__, "filter", filter)
        if single_instance_assignment is not None:
            pulumi.set(__self__, "single_instance_assignment", single_instance_assignment)
        if target is not None:
            pulumi.set(__self__, "target", target)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The identifier for this object. Format specified above.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def filter(self) -> Optional[pulumi.Input[str]]:
        """
        A filter string to be used as the filter string for
        a Stackdriver Monitoring TimeSeries.list API call.
        This filter is used to select a specific TimeSeries for
        the purpose of autoscaling and to determine whether the metric
        is exporting per-instance or per-group data.
        You can only use the AND operator for joining selectors.
        You can only use direct equality comparison operator (=) without
        any functions for each selector.
        You can specify the metric in both the filter string and in the
        metric field. However, if specified in both places, the metric must
        be identical.
        The monitored resource type determines what kind of values are
        expected for the metric. If it is a gce_instance, the autoscaler
        expects the metric to include a separate TimeSeries for each
        instance in a group. In such a case, you cannot filter on resource
        labels.
        If the resource type is any other value, the autoscaler expects
        this metric to contain values that apply to the entire autoscaled
        instance group and resource label filtering can be performed to
        point autoscaler at the correct TimeSeries to scale upon.
        This is called a per-group metric for the purpose of autoscaling.
        If not specified, the type defaults to gce_instance.
        You should provide a filter that is selective enough to pick just
        one TimeSeries for the autoscaled group or for each of the instances
        (if you are using gce_instance resource type). If multiple
        TimeSeries are returned upon the query execution, the autoscaler
        will sum their respective values to obtain its scaling value.
        """
        return pulumi.get(self, "filter")

    @filter.setter
    def filter(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "filter", value)

    @property
    @pulumi.getter(name="singleInstanceAssignment")
    def single_instance_assignment(self) -> Optional[pulumi.Input[float]]:
        """
        If scaling is based on a per-group metric value that represents the
        total amount of work to be done or resource usage, set this value to
        an amount assigned for a single instance of the scaled group.
        The autoscaler will keep the number of instances proportional to the
        value of this metric, the metric itself should not change value due
        to group resizing.
        For example, a good metric to use with the target is
        `pubsub.googleapis.com/subscription/num_undelivered_messages`
        or a custom metric exporting the total number of requests coming to
        your instances.
        A bad example would be a metric exporting an average or median
        latency, since this value can't include a chunk assignable to a
        single instance, it could be better used with utilization_target
        instead.
        """
        return pulumi.get(self, "single_instance_assignment")

    @single_instance_assignment.setter
    def single_instance_assignment(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "single_instance_assignment", value)

    @property
    @pulumi.getter
    def target(self) -> Optional[pulumi.Input[float]]:
        """
        Fraction of backend capacity utilization (set in HTTP(s) load
        balancing configuration) that autoscaler should maintain. Must
        be a positive float value. If not defined, the default is 0.8.
        """
        return pulumi.get(self, "target")

    @target.setter
    def target(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "target", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Defines how target utilization value is expressed for a
        Stackdriver Monitoring metric.
        Possible values are `GAUGE`, `DELTA_PER_SECOND`, and `DELTA_PER_MINUTE`.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class AutoscalerAutoscalingPolicyScaleDownControlArgs:
    def __init__(__self__, *,
                 max_scaled_down_replicas: Optional[pulumi.Input['AutoscalerAutoscalingPolicyScaleDownControlMaxScaledDownReplicasArgs']] = None,
                 time_window_sec: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input['AutoscalerAutoscalingPolicyScaleDownControlMaxScaledDownReplicasArgs'] max_scaled_down_replicas: A nested object resource
               Structure is documented below.
        :param pulumi.Input[int] time_window_sec: How long back autoscaling should look when computing recommendations
               to include directives regarding slower scale down, as described above.
        """
        if max_scaled_down_replicas is not None:
            pulumi.set(__self__, "max_scaled_down_replicas", max_scaled_down_replicas)
        if time_window_sec is not None:
            pulumi.set(__self__, "time_window_sec", time_window_sec)

    @property
    @pulumi.getter(name="maxScaledDownReplicas")
    def max_scaled_down_replicas(self) -> Optional[pulumi.Input['AutoscalerAutoscalingPolicyScaleDownControlMaxScaledDownReplicasArgs']]:
        """
        A nested object resource
        Structure is documented below.
        """
        return pulumi.get(self, "max_scaled_down_replicas")

    @max_scaled_down_replicas.setter
    def max_scaled_down_replicas(self, value: Optional[pulumi.Input['AutoscalerAutoscalingPolicyScaleDownControlMaxScaledDownReplicasArgs']]):
        pulumi.set(self, "max_scaled_down_replicas", value)

    @property
    @pulumi.getter(name="timeWindowSec")
    def time_window_sec(self) -> Optional[pulumi.Input[int]]:
        """
        How long back autoscaling should look when computing recommendations
        to include directives regarding slower scale down, as described above.
        """
        return pulumi.get(self, "time_window_sec")

    @time_window_sec.setter
    def time_window_sec(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "time_window_sec", value)


@pulumi.input_type
class AutoscalerAutoscalingPolicyScaleDownControlMaxScaledDownReplicasArgs:
    def __init__(__self__, *,
                 fixed: Optional[pulumi.Input[int]] = None,
                 percent: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] fixed: Specifies a fixed number of VM instances. This must be a positive
               integer.
        :param pulumi.Input[int] percent: Specifies a percentage of instances between 0 to 100%, inclusive.
               For example, specify 80 for 80%.
        """
        if fixed is not None:
            pulumi.set(__self__, "fixed", fixed)
        if percent is not None:
            pulumi.set(__self__, "percent", percent)

    @property
    @pulumi.getter
    def fixed(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies a fixed number of VM instances. This must be a positive
        integer.
        """
        return pulumi.get(self, "fixed")

    @fixed.setter
    def fixed(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "fixed", value)

    @property
    @pulumi.getter
    def percent(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies a percentage of instances between 0 to 100%, inclusive.
        For example, specify 80 for 80%.
        """
        return pulumi.get(self, "percent")

    @percent.setter
    def percent(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "percent", value)


@pulumi.input_type
class AutoscalerAutoscalingPolicyScaleInControlArgs:
    def __init__(__self__, *,
                 max_scaled_in_replicas: Optional[pulumi.Input['AutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicasArgs']] = None,
                 time_window_sec: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input['AutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicasArgs'] max_scaled_in_replicas: A nested object resource
               Structure is documented below.
        :param pulumi.Input[int] time_window_sec: How long back autoscaling should look when computing recommendations
               to include directives regarding slower scale down, as described above.
        """
        if max_scaled_in_replicas is not None:
            pulumi.set(__self__, "max_scaled_in_replicas", max_scaled_in_replicas)
        if time_window_sec is not None:
            pulumi.set(__self__, "time_window_sec", time_window_sec)

    @property
    @pulumi.getter(name="maxScaledInReplicas")
    def max_scaled_in_replicas(self) -> Optional[pulumi.Input['AutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicasArgs']]:
        """
        A nested object resource
        Structure is documented below.
        """
        return pulumi.get(self, "max_scaled_in_replicas")

    @max_scaled_in_replicas.setter
    def max_scaled_in_replicas(self, value: Optional[pulumi.Input['AutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicasArgs']]):
        pulumi.set(self, "max_scaled_in_replicas", value)

    @property
    @pulumi.getter(name="timeWindowSec")
    def time_window_sec(self) -> Optional[pulumi.Input[int]]:
        """
        How long back autoscaling should look when computing recommendations
        to include directives regarding slower scale down, as described above.
        """
        return pulumi.get(self, "time_window_sec")

    @time_window_sec.setter
    def time_window_sec(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "time_window_sec", value)


@pulumi.input_type
class AutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicasArgs:
    def __init__(__self__, *,
                 fixed: Optional[pulumi.Input[int]] = None,
                 percent: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] fixed: Specifies a fixed number of VM instances. This must be a positive
               integer.
        :param pulumi.Input[int] percent: Specifies a percentage of instances between 0 to 100%, inclusive.
               For example, specify 80 for 80%.
        """
        if fixed is not None:
            pulumi.set(__self__, "fixed", fixed)
        if percent is not None:
            pulumi.set(__self__, "percent", percent)

    @property
    @pulumi.getter
    def fixed(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies a fixed number of VM instances. This must be a positive
        integer.
        """
        return pulumi.get(self, "fixed")

    @fixed.setter
    def fixed(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "fixed", value)

    @property
    @pulumi.getter
    def percent(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies a percentage of instances between 0 to 100%, inclusive.
        For example, specify 80 for 80%.
        """
        return pulumi.get(self, "percent")

    @percent.setter
    def percent(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "percent", value)


@pulumi.input_type
class AutoscalerAutoscalingPolicyScalingScheduleArgs:
    def __init__(__self__, *,
                 duration_sec: pulumi.Input[int],
                 min_required_replicas: pulumi.Input[int],
                 name: pulumi.Input[str],
                 schedule: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None,
                 disabled: Optional[pulumi.Input[bool]] = None,
                 time_zone: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] duration_sec: The duration of time intervals (in seconds) for which this scaling schedule will be running. The minimum allowed value is 300.
        :param pulumi.Input[int] min_required_replicas: Minimum number of VM instances that autoscaler will recommend in time intervals starting according to schedule.
        :param pulumi.Input[str] name: The identifier for this object. Format specified above.
        :param pulumi.Input[str] schedule: The start timestamps of time intervals when this scaling schedule should provide a scaling signal. This field uses the extended cron format (with an optional year field).
        :param pulumi.Input[str] description: An optional description of this resource.
        :param pulumi.Input[bool] disabled: A boolean value that specifies if a scaling schedule can influence autoscaler recommendations. If set to true, then a scaling schedule has no effect.
        :param pulumi.Input[str] time_zone: The time zone to be used when interpreting the schedule. The value of this field must be a time zone name from the tz database: http://en.wikipedia.org/wiki/Tz_database.
        """
        pulumi.set(__self__, "duration_sec", duration_sec)
        pulumi.set(__self__, "min_required_replicas", min_required_replicas)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "schedule", schedule)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)
        if time_zone is not None:
            pulumi.set(__self__, "time_zone", time_zone)

    @property
    @pulumi.getter(name="durationSec")
    def duration_sec(self) -> pulumi.Input[int]:
        """
        The duration of time intervals (in seconds) for which this scaling schedule will be running. The minimum allowed value is 300.
        """
        return pulumi.get(self, "duration_sec")

    @duration_sec.setter
    def duration_sec(self, value: pulumi.Input[int]):
        pulumi.set(self, "duration_sec", value)

    @property
    @pulumi.getter(name="minRequiredReplicas")
    def min_required_replicas(self) -> pulumi.Input[int]:
        """
        Minimum number of VM instances that autoscaler will recommend in time intervals starting according to schedule.
        """
        return pulumi.get(self, "min_required_replicas")

    @min_required_replicas.setter
    def min_required_replicas(self, value: pulumi.Input[int]):
        pulumi.set(self, "min_required_replicas", value)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The identifier for this object. Format specified above.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def schedule(self) -> pulumi.Input[str]:
        """
        The start timestamps of time intervals when this scaling schedule should provide a scaling signal. This field uses the extended cron format (with an optional year field).
        """
        return pulumi.get(self, "schedule")

    @schedule.setter
    def schedule(self, value: pulumi.Input[str]):
        pulumi.set(self, "schedule", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        An optional description of this resource.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        A boolean value that specifies if a scaling schedule can influence autoscaler recommendations. If set to true, then a scaling schedule has no effect.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)

    @property
    @pulumi.getter(name="timeZone")
    def time_zone(self) -> Optional[pulumi.Input[str]]:
        """
        The time zone to be used when interpreting the schedule. The value of this field must be a time zone name from the tz database: http://en.wikipedia.org/wiki/Tz_database.
        """
        return pulumi.get(self, "time_zone")

    @time_zone.setter
    def time_zone(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "time_zone", value)


@pulumi.input_type
class BackendBucketCdnPolicyArgs:
    def __init__(__self__, *,
                 bypass_cache_on_request_headers: Optional[pulumi.Input[Sequence[pulumi.Input['BackendBucketCdnPolicyBypassCacheOnRequestHeaderArgs']]]] = None,
                 cache_key_policy: Optional[pulumi.Input['BackendBucketCdnPolicyCacheKeyPolicyArgs']] = None,
                 cache_mode: Optional[pulumi.Input[str]] = None,
                 client_ttl: Optional[pulumi.Input[int]] = None,
                 default_ttl: Optional[pulumi.Input[int]] = None,
                 max_ttl: Optional[pulumi.Input[int]] = None,
                 negative_caching: Optional[pulumi.Input[bool]] = None,
                 negative_caching_policies: Optional[pulumi.Input[Sequence[pulumi.Input['BackendBucketCdnPolicyNegativeCachingPolicyArgs']]]] = None,
                 request_coalescing: Optional[pulumi.Input[bool]] = None,
                 serve_while_stale: Optional[pulumi.Input[int]] = None,
                 signed_url_cache_max_age_sec: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['BackendBucketCdnPolicyBypassCacheOnRequestHeaderArgs']]] bypass_cache_on_request_headers: Bypass the cache when the specified request headers are matched - e.g. Pragma or Authorization headers. Up to 5 headers can be specified. The cache is bypassed for all cdnPolicy.cacheMode settings.
               Structure is documented below.
        :param pulumi.Input['BackendBucketCdnPolicyCacheKeyPolicyArgs'] cache_key_policy: The CacheKeyPolicy for this CdnPolicy.
               Structure is documented below.
        :param pulumi.Input[str] cache_mode: Specifies the cache setting for all responses from this backend.
               The possible values are: USE_ORIGIN_HEADERS, FORCE_CACHE_ALL and CACHE_ALL_STATIC
               Possible values are `USE_ORIGIN_HEADERS`, `FORCE_CACHE_ALL`, and `CACHE_ALL_STATIC`.
        :param pulumi.Input[int] client_ttl: Specifies the maximum allowed TTL for cached content served by this origin.
        :param pulumi.Input[int] default_ttl: Specifies the default TTL for cached content served by this origin for responses
               that do not have an existing valid TTL (max-age or s-max-age).
        :param pulumi.Input[int] max_ttl: Specifies the maximum allowed TTL for cached content served by this origin.
        :param pulumi.Input[bool] negative_caching: Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects.
        :param pulumi.Input[Sequence[pulumi.Input['BackendBucketCdnPolicyNegativeCachingPolicyArgs']]] negative_caching_policies: Sets a cache TTL for the specified HTTP status code. negativeCaching must be enabled to configure negativeCachingPolicy.
               Omitting the policy and leaving negativeCaching enabled will use Cloud CDN's default cache TTLs.
               Structure is documented below.
        :param pulumi.Input[bool] request_coalescing: If true then Cloud CDN will combine multiple concurrent cache fill requests into a small number of requests to the origin.
        :param pulumi.Input[int] serve_while_stale: Serve existing content from the cache (if available) when revalidating content with the origin, or when an error is encountered when refreshing the cache.
        :param pulumi.Input[int] signed_url_cache_max_age_sec: Maximum number of seconds the response to a signed URL request will
               be considered fresh. After this time period,
               the response will be revalidated before being served.
               When serving responses to signed URL requests,
               Cloud CDN will internally behave as though
               all responses from this backend had a "Cache-Control: public,
               max-age=[TTL]" header, regardless of any existing Cache-Control
               header. The actual headers served in responses will not be altered.
        """
        if bypass_cache_on_request_headers is not None:
            pulumi.set(__self__, "bypass_cache_on_request_headers", bypass_cache_on_request_headers)
        if cache_key_policy is not None:
            pulumi.set(__self__, "cache_key_policy", cache_key_policy)
        if cache_mode is not None:
            pulumi.set(__self__, "cache_mode", cache_mode)
        if client_ttl is not None:
            pulumi.set(__self__, "client_ttl", client_ttl)
        if default_ttl is not None:
            pulumi.set(__self__, "default_ttl", default_ttl)
        if max_ttl is not None:
            pulumi.set(__self__, "max_ttl", max_ttl)
        if negative_caching is not None:
            pulumi.set(__self__, "negative_caching", negative_caching)
        if negative_caching_policies is not None:
            pulumi.set(__self__, "negative_caching_policies", negative_caching_policies)
        if request_coalescing is not None:
            pulumi.set(__self__, "request_coalescing", request_coalescing)
        if serve_while_stale is not None:
            pulumi.set(__self__, "serve_while_stale", serve_while_stale)
        if signed_url_cache_max_age_sec is not None:
            pulumi.set(__self__, "signed_url_cache_max_age_sec", signed_url_cache_max_age_sec)

    @property
    @pulumi.getter(name="bypassCacheOnRequestHeaders")
    def bypass_cache_on_request_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BackendBucketCdnPolicyBypassCacheOnRequestHeaderArgs']]]]:
        """
        Bypass the cache when the specified request headers are matched - e.g. Pragma or Authorization headers. Up to 5 headers can be specified. The cache is bypassed for all cdnPolicy.cacheMode settings.
        Structure is documented below.
        """
        return pulumi.get(self, "bypass_cache_on_request_headers")

    @bypass_cache_on_request_headers.setter
    def bypass_cache_on_request_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['BackendBucketCdnPolicyBypassCacheOnRequestHeaderArgs']]]]):
        pulumi.set(self, "bypass_cache_on_request_headers", value)

    @property
    @pulumi.getter(name="cacheKeyPolicy")
    def cache_key_policy(self) -> Optional[pulumi.Input['BackendBucketCdnPolicyCacheKeyPolicyArgs']]:
        """
        The CacheKeyPolicy for this CdnPolicy.
        Structure is documented below.
        """
        return pulumi.get(self, "cache_key_policy")

    @cache_key_policy.setter
    def cache_key_policy(self, value: Optional[pulumi.Input['BackendBucketCdnPolicyCacheKeyPolicyArgs']]):
        pulumi.set(self, "cache_key_policy", value)

    @property
    @pulumi.getter(name="cacheMode")
    def cache_mode(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the cache setting for all responses from this backend.
        The possible values are: USE_ORIGIN_HEADERS, FORCE_CACHE_ALL and CACHE_ALL_STATIC
        Possible values are `USE_ORIGIN_HEADERS`, `FORCE_CACHE_ALL`, and `CACHE_ALL_STATIC`.
        """
        return pulumi.get(self, "cache_mode")

    @cache_mode.setter
    def cache_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cache_mode", value)

    @property
    @pulumi.getter(name="clientTtl")
    def client_ttl(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the maximum allowed TTL for cached content served by this origin.
        """
        return pulumi.get(self, "client_ttl")

    @client_ttl.setter
    def client_ttl(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "client_ttl", value)

    @property
    @pulumi.getter(name="defaultTtl")
    def default_ttl(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the default TTL for cached content served by this origin for responses
        that do not have an existing valid TTL (max-age or s-max-age).
        """
        return pulumi.get(self, "default_ttl")

    @default_ttl.setter
    def default_ttl(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "default_ttl", value)

    @property
    @pulumi.getter(name="maxTtl")
    def max_ttl(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the maximum allowed TTL for cached content served by this origin.
        """
        return pulumi.get(self, "max_ttl")

    @max_ttl.setter
    def max_ttl(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_ttl", value)

    @property
    @pulumi.getter(name="negativeCaching")
    def negative_caching(self) -> Optional[pulumi.Input[bool]]:
        """
        Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects.
        """
        return pulumi.get(self, "negative_caching")

    @negative_caching.setter
    def negative_caching(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "negative_caching", value)

    @property
    @pulumi.getter(name="negativeCachingPolicies")
    def negative_caching_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BackendBucketCdnPolicyNegativeCachingPolicyArgs']]]]:
        """
        Sets a cache TTL for the specified HTTP status code. negativeCaching must be enabled to configure negativeCachingPolicy.
        Omitting the policy and leaving negativeCaching enabled will use Cloud CDN's default cache TTLs.
        Structure is documented below.
        """
        return pulumi.get(self, "negative_caching_policies")

    @negative_caching_policies.setter
    def negative_caching_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['BackendBucketCdnPolicyNegativeCachingPolicyArgs']]]]):
        pulumi.set(self, "negative_caching_policies", value)

    @property
    @pulumi.getter(name="requestCoalescing")
    def request_coalescing(self) -> Optional[pulumi.Input[bool]]:
        """
        If true then Cloud CDN will combine multiple concurrent cache fill requests into a small number of requests to the origin.
        """
        return pulumi.get(self, "request_coalescing")

    @request_coalescing.setter
    def request_coalescing(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "request_coalescing", value)

    @property
    @pulumi.getter(name="serveWhileStale")
    def serve_while_stale(self) -> Optional[pulumi.Input[int]]:
        """
        Serve existing content from the cache (if available) when revalidating content with the origin, or when an error is encountered when refreshing the cache.
        """
        return pulumi.get(self, "serve_while_stale")

    @serve_while_stale.setter
    def serve_while_stale(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "serve_while_stale", value)

    @property
    @pulumi.getter(name="signedUrlCacheMaxAgeSec")
    def signed_url_cache_max_age_sec(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum number of seconds the response to a signed URL request will
        be considered fresh. After this time period,
        the response will be revalidated before being served.
        When serving responses to signed URL requests,
        Cloud CDN will internally behave as though
        all responses from this backend had a "Cache-Control: public,
        max-age=[TTL]" header, regardless of any existing Cache-Control
        header. The actual headers served in responses will not be altered.
        """
        return pulumi.get(self, "signed_url_cache_max_age_sec")

    @signed_url_cache_max_age_sec.setter
    def signed_url_cache_max_age_sec(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "signed_url_cache_max_age_sec", value)


@pulumi.input_type
class BackendBucketCdnPolicyBypassCacheOnRequestHeaderArgs:
    def __init__(__self__, *,
                 header_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] header_name: The header field name to match on when bypassing cache. Values are case-insensitive.
        """
        if header_name is not None:
            pulumi.set(__self__, "header_name", header_name)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> Optional[pulumi.Input[str]]:
        """
        The header field name to match on when bypassing cache. Values are case-insensitive.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "header_name", value)


@pulumi.input_type
class BackendBucketCdnPolicyCacheKeyPolicyArgs:
    def __init__(__self__, *,
                 include_http_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 query_string_whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] include_http_headers: Allows HTTP request headers (by name) to be used in the
               cache key.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] query_string_whitelists: Names of query string parameters to include in cache keys.
               Default parameters are always included. '&' and '=' will
               be percent encoded and not treated as delimiters.
        """
        if include_http_headers is not None:
            pulumi.set(__self__, "include_http_headers", include_http_headers)
        if query_string_whitelists is not None:
            pulumi.set(__self__, "query_string_whitelists", query_string_whitelists)

    @property
    @pulumi.getter(name="includeHttpHeaders")
    def include_http_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Allows HTTP request headers (by name) to be used in the
        cache key.
        """
        return pulumi.get(self, "include_http_headers")

    @include_http_headers.setter
    def include_http_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "include_http_headers", value)

    @property
    @pulumi.getter(name="queryStringWhitelists")
    def query_string_whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Names of query string parameters to include in cache keys.
        Default parameters are always included. '&' and '=' will
        be percent encoded and not treated as delimiters.
        """
        return pulumi.get(self, "query_string_whitelists")

    @query_string_whitelists.setter
    def query_string_whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "query_string_whitelists", value)


@pulumi.input_type
class BackendBucketCdnPolicyNegativeCachingPolicyArgs:
    def __init__(__self__, *,
                 code: Optional[pulumi.Input[int]] = None,
                 ttl: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] code: The HTTP status code to define a TTL against. Only HTTP status codes 300, 301, 308, 404, 405, 410, 421, 451 and 501
               can be specified as values, and you cannot specify a status code more than once.
        :param pulumi.Input[int] ttl: The TTL (in seconds) for which to cache responses with the corresponding status code. The maximum allowed value is 1800s
               (30 minutes), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
        """
        if code is not None:
            pulumi.set(__self__, "code", code)
        if ttl is not None:
            pulumi.set(__self__, "ttl", ttl)

    @property
    @pulumi.getter
    def code(self) -> Optional[pulumi.Input[int]]:
        """
        The HTTP status code to define a TTL against. Only HTTP status codes 300, 301, 308, 404, 405, 410, 421, 451 and 501
        can be specified as values, and you cannot specify a status code more than once.
        """
        return pulumi.get(self, "code")

    @code.setter
    def code(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "code", value)

    @property
    @pulumi.getter
    def ttl(self) -> Optional[pulumi.Input[int]]:
        """
        The TTL (in seconds) for which to cache responses with the corresponding status code. The maximum allowed value is 1800s
        (30 minutes), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
        """
        return pulumi.get(self, "ttl")

    @ttl.setter
    def ttl(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "ttl", value)


@pulumi.input_type
class BackendBucketIamBindingConditionArgs:
    def __init__(__self__, *,
                 expression: pulumi.Input[str],
                 title: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "title", title)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter
    def title(self) -> pulumi.Input[str]:
        return pulumi.get(self, "title")

    @title.setter
    def title(self, value: pulumi.Input[str]):
        pulumi.set(self, "title", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class BackendBucketIamMemberConditionArgs:
    def __init__(__self__, *,
                 expression: pulumi.Input[str],
                 title: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "title", title)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter
    def title(self) -> pulumi.Input[str]:
        return pulumi.get(self, "title")

    @title.setter
    def title(self, value: pulumi.Input[str]):
        pulumi.set(self, "title", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class BackendServiceBackendArgs:
    def __init__(__self__, *,
                 group: pulumi.Input[str],
                 balancing_mode: Optional[pulumi.Input[str]] = None,
                 capacity_scaler: Optional[pulumi.Input[float]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 max_connections: Optional[pulumi.Input[int]] = None,
                 max_connections_per_endpoint: Optional[pulumi.Input[int]] = None,
                 max_connections_per_instance: Optional[pulumi.Input[int]] = None,
                 max_rate: Optional[pulumi.Input[int]] = None,
                 max_rate_per_endpoint: Optional[pulumi.Input[float]] = None,
                 max_rate_per_instance: Optional[pulumi.Input[float]] = None,
                 max_utilization: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[str] group: The fully-qualified URL of an Instance Group or Network Endpoint
               Group resource. In case of instance group this defines the list
               of instances that serve traffic. Member virtual machine
               instances from each instance group must live in the same zone as
               the instance group itself. No two backends in a backend service
               are allowed to use same Instance Group resource.
               For Network Endpoint Groups this defines list of endpoints. All
               endpoints of Network Endpoint Group must be hosted on instances
               located in the same zone as the Network Endpoint Group.
               Backend services cannot mix Instance Group and
               Network Endpoint Group backends.
               Note that you must specify an Instance Group or Network Endpoint
               Group resource using the fully-qualified URL, rather than a
               partial URL.
        :param pulumi.Input[str] balancing_mode: Specifies the balancing mode for this backend.
               For global HTTP(S) or TCP/SSL load balancing, the default is
               UTILIZATION. Valid values are UTILIZATION, RATE (for HTTP(S))
               and CONNECTION (for TCP/SSL).
               See the [Backend Services Overview](https://cloud.google.com/load-balancing/docs/backend-service#balancing-mode)
               for an explanation of load balancing modes.
               Default value is `UTILIZATION`.
               Possible values are `UTILIZATION`, `RATE`, and `CONNECTION`.
        :param pulumi.Input[float] capacity_scaler: A multiplier applied to the group's maximum servicing capacity
               (based on UTILIZATION, RATE or CONNECTION).
               Default value is 1, which means the group will serve up to 100%
               of its configured capacity (depending on balancingMode). A
               setting of 0 means the group is completely drained, offering
               0% of its available Capacity. Valid range is [0.0,1.0].
        :param pulumi.Input[str] description: An optional description of this resource.
               Provide this property when you create the resource.
        :param pulumi.Input[int] max_connections: The maximum number of connections to the backend cluster.
               Defaults to 1024.
        :param pulumi.Input[int] max_connections_per_endpoint: The max number of simultaneous connections that a single backend
               network endpoint can handle. This is used to calculate the
               capacity of the group. Can be used in either CONNECTION or
               UTILIZATION balancing modes.
               For CONNECTION mode, either
               maxConnections or maxConnectionsPerEndpoint must be set.
        :param pulumi.Input[int] max_connections_per_instance: The max number of simultaneous connections that a single
               backend instance can handle. This is used to calculate the
               capacity of the group. Can be used in either CONNECTION or
               UTILIZATION balancing modes.
               For CONNECTION mode, either maxConnections or
               maxConnectionsPerInstance must be set.
        :param pulumi.Input[int] max_rate: The max requests per second (RPS) of the group.
               Can be used with either RATE or UTILIZATION balancing modes,
               but required if RATE mode. For RATE mode, either maxRate or one
               of maxRatePerInstance or maxRatePerEndpoint, as appropriate for
               group type, must be set.
        :param pulumi.Input[float] max_rate_per_endpoint: The max requests per second (RPS) that a single backend network
               endpoint can handle. This is used to calculate the capacity of
               the group. Can be used in either balancing mode. For RATE mode,
               either maxRate or maxRatePerEndpoint must be set.
        :param pulumi.Input[float] max_rate_per_instance: The max requests per second (RPS) that a single backend
               instance can handle. This is used to calculate the capacity of
               the group. Can be used in either balancing mode. For RATE mode,
               either maxRate or maxRatePerInstance must be set.
        :param pulumi.Input[float] max_utilization: Used when balancingMode is UTILIZATION. This ratio defines the
               CPU utilization target for the group. Valid range is [0.0, 1.0].
        """
        pulumi.set(__self__, "group", group)
        if balancing_mode is not None:
            pulumi.set(__self__, "balancing_mode", balancing_mode)
        if capacity_scaler is not None:
            pulumi.set(__self__, "capacity_scaler", capacity_scaler)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if max_connections is not None:
            pulumi.set(__self__, "max_connections", max_connections)
        if max_connections_per_endpoint is not None:
            pulumi.set(__self__, "max_connections_per_endpoint", max_connections_per_endpoint)
        if max_connections_per_instance is not None:
            pulumi.set(__self__, "max_connections_per_instance", max_connections_per_instance)
        if max_rate is not None:
            pulumi.set(__self__, "max_rate", max_rate)
        if max_rate_per_endpoint is not None:
            pulumi.set(__self__, "max_rate_per_endpoint", max_rate_per_endpoint)
        if max_rate_per_instance is not None:
            pulumi.set(__self__, "max_rate_per_instance", max_rate_per_instance)
        if max_utilization is not None:
            pulumi.set(__self__, "max_utilization", max_utilization)

    @property
    @pulumi.getter
    def group(self) -> pulumi.Input[str]:
        """
        The fully-qualified URL of an Instance Group or Network Endpoint
        Group resource. In case of instance group this defines the list
        of instances that serve traffic. Member virtual machine
        instances from each instance group must live in the same zone as
        the instance group itself. No two backends in a backend service
        are allowed to use same Instance Group resource.
        For Network Endpoint Groups this defines list of endpoints. All
        endpoints of Network Endpoint Group must be hosted on instances
        located in the same zone as the Network Endpoint Group.
        Backend services cannot mix Instance Group and
        Network Endpoint Group backends.
        Note that you must specify an Instance Group or Network Endpoint
        Group resource using the fully-qualified URL, rather than a
        partial URL.
        """
        return pulumi.get(self, "group")

    @group.setter
    def group(self, value: pulumi.Input[str]):
        pulumi.set(self, "group", value)

    @property
    @pulumi.getter(name="balancingMode")
    def balancing_mode(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the balancing mode for this backend.
        For global HTTP(S) or TCP/SSL load balancing, the default is
        UTILIZATION. Valid values are UTILIZATION, RATE (for HTTP(S))
        and CONNECTION (for TCP/SSL).
        See the [Backend Services Overview](https://cloud.google.com/load-balancing/docs/backend-service#balancing-mode)
        for an explanation of load balancing modes.
        Default value is `UTILIZATION`.
        Possible values are `UTILIZATION`, `RATE`, and `CONNECTION`.
        """
        return pulumi.get(self, "balancing_mode")

    @balancing_mode.setter
    def balancing_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "balancing_mode", value)

    @property
    @pulumi.getter(name="capacityScaler")
    def capacity_scaler(self) -> Optional[pulumi.Input[float]]:
        """
        A multiplier applied to the group's maximum servicing capacity
        (based on UTILIZATION, RATE or CONNECTION).
        Default value is 1, which means the group will serve up to 100%
        of its configured capacity (depending on balancingMode). A
        setting of 0 means the group is completely drained, offering
        0% of its available Capacity. Valid range is [0.0,1.0].
        """
        return pulumi.get(self, "capacity_scaler")

    @capacity_scaler.setter
    def capacity_scaler(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "capacity_scaler", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        An optional description of this resource.
        Provide this property when you create the resource.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)

    @property
    @pulumi.getter(name="maxConnections")
    def max_connections(self) -> Optional[pulumi.Input[int]]:
        """
        The maximum number of connections to the backend cluster.
        Defaults to 1024.
        """
        return pulumi.get(self, "max_connections")

    @max_connections.setter
    def max_connections(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_connections", value)

    @property
    @pulumi.getter(name="maxConnectionsPerEndpoint")
    def max_connections_per_endpoint(self) -> Optional[pulumi.Input[int]]:
        """
        The max number of simultaneous connections that a single backend
        network endpoint can handle. This is used to calculate the
        capacity of the group. Can be used in either CONNECTION or
        UTILIZATION balancing modes.
        For CONNECTION mode, either
        maxConnections or maxConnectionsPerEndpoint must be set.
        """
        return pulumi.get(self, "max_connections_per_endpoint")

    @max_connections_per_endpoint.setter
    def max_connections_per_endpoint(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_connections_per_endpoint", value)

    @property
    @pulumi.getter(name="maxConnectionsPerInstance")
    def max_connections_per_instance(self) -> Optional[pulumi.Input[int]]:
        """
        The max number of simultaneous connections that a single
        backend instance can handle. This is used to calculate the
        capacity of the group. Can be used in either CONNECTION or
        UTILIZATION balancing modes.
        For CONNECTION mode, either maxConnections or
        maxConnectionsPerInstance must be set.
        """
        return pulumi.get(self, "max_connections_per_instance")

    @max_connections_per_instance.setter
    def max_connections_per_instance(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_connections_per_instance", value)

    @property
    @pulumi.getter(name="maxRate")
    def max_rate(self) -> Optional[pulumi.Input[int]]:
        """
        The max requests per second (RPS) of the group.
        Can be used with either RATE or UTILIZATION balancing modes,
        but required if RATE mode. For RATE mode, either maxRate or one
        of maxRatePerInstance or maxRatePerEndpoint, as appropriate for
        group type, must be set.
        """
        return pulumi.get(self, "max_rate")

    @max_rate.setter
    def max_rate(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_rate", value)

    @property
    @pulumi.getter(name="maxRatePerEndpoint")
    def max_rate_per_endpoint(self) -> Optional[pulumi.Input[float]]:
        """
        The max requests per second (RPS) that a single backend network
        endpoint can handle. This is used to calculate the capacity of
        the group. Can be used in either balancing mode. For RATE mode,
        either maxRate or maxRatePerEndpoint must be set.
        """
        return pulumi.get(self, "max_rate_per_endpoint")

    @max_rate_per_endpoint.setter
    def max_rate_per_endpoint(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "max_rate_per_endpoint", value)

    @property
    @pulumi.getter(name="maxRatePerInstance")
    def max_rate_per_instance(self) -> Optional[pulumi.Input[float]]:
        """
        The max requests per second (RPS) that a single backend
        instance can handle. This is used to calculate the capacity of
        the group. Can be used in either balancing mode. For RATE mode,
        either maxRate or maxRatePerInstance must be set.
        """
        return pulumi.get(self, "max_rate_per_instance")

    @max_rate_per_instance.setter
    def max_rate_per_instance(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "max_rate_per_instance", value)

    @property
    @pulumi.getter(name="maxUtilization")
    def max_utilization(self) -> Optional[pulumi.Input[float]]:
        """
        Used when balancingMode is UTILIZATION. This ratio defines the
        CPU utilization target for the group. Valid range is [0.0, 1.0].
        """
        return pulumi.get(self, "max_utilization")

    @max_utilization.setter
    def max_utilization(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "max_utilization", value)


@pulumi.input_type
class BackendServiceCdnPolicyArgs:
    def __init__(__self__, *,
                 cache_key_policy: Optional[pulumi.Input['BackendServiceCdnPolicyCacheKeyPolicyArgs']] = None,
                 cache_mode: Optional[pulumi.Input[str]] = None,
                 client_ttl: Optional[pulumi.Input[int]] = None,
                 default_ttl: Optional[pulumi.Input[int]] = None,
                 max_ttl: Optional[pulumi.Input[int]] = None,
                 negative_caching: Optional[pulumi.Input[bool]] = None,
                 negative_caching_policies: Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceCdnPolicyNegativeCachingPolicyArgs']]]] = None,
                 serve_while_stale: Optional[pulumi.Input[int]] = None,
                 signed_url_cache_max_age_sec: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input['BackendServiceCdnPolicyCacheKeyPolicyArgs'] cache_key_policy: The CacheKeyPolicy for this CdnPolicy.
               Structure is documented below.
        :param pulumi.Input[str] cache_mode: Specifies the cache setting for all responses from this backend.
               The possible values are: USE_ORIGIN_HEADERS, FORCE_CACHE_ALL and CACHE_ALL_STATIC
               Possible values are `USE_ORIGIN_HEADERS`, `FORCE_CACHE_ALL`, and `CACHE_ALL_STATIC`.
        :param pulumi.Input[int] client_ttl: Specifies the maximum allowed TTL for cached content served by this origin.
        :param pulumi.Input[int] default_ttl: Specifies the default TTL for cached content served by this origin for responses
               that do not have an existing valid TTL (max-age or s-max-age).
        :param pulumi.Input[int] max_ttl: Specifies the maximum allowed TTL for cached content served by this origin.
        :param pulumi.Input[bool] negative_caching: Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects.
        :param pulumi.Input[Sequence[pulumi.Input['BackendServiceCdnPolicyNegativeCachingPolicyArgs']]] negative_caching_policies: Sets a cache TTL for the specified HTTP status code. negativeCaching must be enabled to configure negativeCachingPolicy.
               Omitting the policy and leaving negativeCaching enabled will use Cloud CDN's default cache TTLs.
               Structure is documented below.
        :param pulumi.Input[int] serve_while_stale: Serve existing content from the cache (if available) when revalidating content with the origin, or when an error is encountered when refreshing the cache.
        :param pulumi.Input[int] signed_url_cache_max_age_sec: Maximum number of seconds the response to a signed URL request
               will be considered fresh, defaults to 1hr (3600s). After this
               time period, the response will be revalidated before
               being served.
               When serving responses to signed URL requests, Cloud CDN will
               internally behave as though all responses from this backend had a
               "Cache-Control: public, max-age=[TTL]" header, regardless of any
               existing Cache-Control header. The actual headers served in
               responses will not be altered.
        """
        if cache_key_policy is not None:
            pulumi.set(__self__, "cache_key_policy", cache_key_policy)
        if cache_mode is not None:
            pulumi.set(__self__, "cache_mode", cache_mode)
        if client_ttl is not None:
            pulumi.set(__self__, "client_ttl", client_ttl)
        if default_ttl is not None:
            pulumi.set(__self__, "default_ttl", default_ttl)
        if max_ttl is not None:
            pulumi.set(__self__, "max_ttl", max_ttl)
        if negative_caching is not None:
            pulumi.set(__self__, "negative_caching", negative_caching)
        if negative_caching_policies is not None:
            pulumi.set(__self__, "negative_caching_policies", negative_caching_policies)
        if serve_while_stale is not None:
            pulumi.set(__self__, "serve_while_stale", serve_while_stale)
        if signed_url_cache_max_age_sec is not None:
            pulumi.set(__self__, "signed_url_cache_max_age_sec", signed_url_cache_max_age_sec)

    @property
    @pulumi.getter(name="cacheKeyPolicy")
    def cache_key_policy(self) -> Optional[pulumi.Input['BackendServiceCdnPolicyCacheKeyPolicyArgs']]:
        """
        The CacheKeyPolicy for this CdnPolicy.
        Structure is documented below.
        """
        return pulumi.get(self, "cache_key_policy")

    @cache_key_policy.setter
    def cache_key_policy(self, value: Optional[pulumi.Input['BackendServiceCdnPolicyCacheKeyPolicyArgs']]):
        pulumi.set(self, "cache_key_policy", value)

    @property
    @pulumi.getter(name="cacheMode")
    def cache_mode(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the cache setting for all responses from this backend.
        The possible values are: USE_ORIGIN_HEADERS, FORCE_CACHE_ALL and CACHE_ALL_STATIC
        Possible values are `USE_ORIGIN_HEADERS`, `FORCE_CACHE_ALL`, and `CACHE_ALL_STATIC`.
        """
        return pulumi.get(self, "cache_mode")

    @cache_mode.setter
    def cache_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cache_mode", value)

    @property
    @pulumi.getter(name="clientTtl")
    def client_ttl(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the maximum allowed TTL for cached content served by this origin.
        """
        return pulumi.get(self, "client_ttl")

    @client_ttl.setter
    def client_ttl(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "client_ttl", value)

    @property
    @pulumi.getter(name="defaultTtl")
    def default_ttl(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the default TTL for cached content served by this origin for responses
        that do not have an existing valid TTL (max-age or s-max-age).
        """
        return pulumi.get(self, "default_ttl")

    @default_ttl.setter
    def default_ttl(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "default_ttl", value)

    @property
    @pulumi.getter(name="maxTtl")
    def max_ttl(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the maximum allowed TTL for cached content served by this origin.
        """
        return pulumi.get(self, "max_ttl")

    @max_ttl.setter
    def max_ttl(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_ttl", value)

    @property
    @pulumi.getter(name="negativeCaching")
    def negative_caching(self) -> Optional[pulumi.Input[bool]]:
        """
        Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects.
        """
        return pulumi.get(self, "negative_caching")

    @negative_caching.setter
    def negative_caching(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "negative_caching", value)

    @property
    @pulumi.getter(name="negativeCachingPolicies")
    def negative_caching_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceCdnPolicyNegativeCachingPolicyArgs']]]]:
        """
        Sets a cache TTL for the specified HTTP status code. negativeCaching must be enabled to configure negativeCachingPolicy.
        Omitting the policy and leaving negativeCaching enabled will use Cloud CDN's default cache TTLs.
        Structure is documented below.
        """
        return pulumi.get(self, "negative_caching_policies")

    @negative_caching_policies.setter
    def negative_caching_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceCdnPolicyNegativeCachingPolicyArgs']]]]):
        pulumi.set(self, "negative_caching_policies", value)

    @property
    @pulumi.getter(name="serveWhileStale")
    def serve_while_stale(self) -> Optional[pulumi.Input[int]]:
        """
        Serve existing content from the cache (if available) when revalidating content with the origin, or when an error is encountered when refreshing the cache.
        """
        return pulumi.get(self, "serve_while_stale")

    @serve_while_stale.setter
    def serve_while_stale(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "serve_while_stale", value)

    @property
    @pulumi.getter(name="signedUrlCacheMaxAgeSec")
    def signed_url_cache_max_age_sec(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum number of seconds the response to a signed URL request
        will be considered fresh, defaults to 1hr (3600s). After this
        time period, the response will be revalidated before
        being served.
        When serving responses to signed URL requests, Cloud CDN will
        internally behave as though all responses from this backend had a
        "Cache-Control: public, max-age=[TTL]" header, regardless of any
        existing Cache-Control header. The actual headers served in
        responses will not be altered.
        """
        return pulumi.get(self, "signed_url_cache_max_age_sec")

    @signed_url_cache_max_age_sec.setter
    def signed_url_cache_max_age_sec(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "signed_url_cache_max_age_sec", value)


@pulumi.input_type
class BackendServiceCdnPolicyCacheKeyPolicyArgs:
    def __init__(__self__, *,
                 include_host: Optional[pulumi.Input[bool]] = None,
                 include_named_cookies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 include_protocol: Optional[pulumi.Input[bool]] = None,
                 include_query_string: Optional[pulumi.Input[bool]] = None,
                 query_string_blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 query_string_whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[bool] include_host: If true requests to different hosts will be cached separately.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] include_named_cookies: Names of cookies to include in cache keys.
        :param pulumi.Input[bool] include_protocol: If true, http and https requests will be cached separately.
        :param pulumi.Input[bool] include_query_string: If true, include query string parameters in the cache key
               according to query_string_whitelist and
               query_string_blacklist. If neither is set, the entire query
               string will be included.
               If false, the query string will be excluded from the cache
               key entirely.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] query_string_blacklists: Names of query string parameters to exclude in cache keys.
               All other parameters will be included. Either specify
               query_string_whitelist or query_string_blacklist, not both.
               '&' and '=' will be percent encoded and not treated as
               delimiters.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] query_string_whitelists: Names of query string parameters to include in cache keys.
               All other parameters will be excluded. Either specify
               query_string_whitelist or query_string_blacklist, not both.
               '&' and '=' will be percent encoded and not treated as
               delimiters.
        """
        if include_host is not None:
            pulumi.set(__self__, "include_host", include_host)
        if include_named_cookies is not None:
            pulumi.set(__self__, "include_named_cookies", include_named_cookies)
        if include_protocol is not None:
            pulumi.set(__self__, "include_protocol", include_protocol)
        if include_query_string is not None:
            pulumi.set(__self__, "include_query_string", include_query_string)
        if query_string_blacklists is not None:
            pulumi.set(__self__, "query_string_blacklists", query_string_blacklists)
        if query_string_whitelists is not None:
            pulumi.set(__self__, "query_string_whitelists", query_string_whitelists)

    @property
    @pulumi.getter(name="includeHost")
    def include_host(self) -> Optional[pulumi.Input[bool]]:
        """
        If true requests to different hosts will be cached separately.
        """
        return pulumi.get(self, "include_host")

    @include_host.setter
    def include_host(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "include_host", value)

    @property
    @pulumi.getter(name="includeNamedCookies")
    def include_named_cookies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Names of cookies to include in cache keys.
        """
        return pulumi.get(self, "include_named_cookies")

    @include_named_cookies.setter
    def include_named_cookies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "include_named_cookies", value)

    @property
    @pulumi.getter(name="includeProtocol")
    def include_protocol(self) -> Optional[pulumi.Input[bool]]:
        """
        If true, http and https requests will be cached separately.
        """
        return pulumi.get(self, "include_protocol")

    @include_protocol.setter
    def include_protocol(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "include_protocol", value)

    @property
    @pulumi.getter(name="includeQueryString")
    def include_query_string(self) -> Optional[pulumi.Input[bool]]:
        """
        If true, include query string parameters in the cache key
        according to query_string_whitelist and
        query_string_blacklist. If neither is set, the entire query
        string will be included.
        If false, the query string will be excluded from the cache
        key entirely.
        """
        return pulumi.get(self, "include_query_string")

    @include_query_string.setter
    def include_query_string(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "include_query_string", value)

    @property
    @pulumi.getter(name="queryStringBlacklists")
    def query_string_blacklists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Names of query string parameters to exclude in cache keys.
        All other parameters will be included. Either specify
        query_string_whitelist or query_string_blacklist, not both.
        '&' and '=' will be percent encoded and not treated as
        delimiters.
        """
        return pulumi.get(self, "query_string_blacklists")

    @query_string_blacklists.setter
    def query_string_blacklists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "query_string_blacklists", value)

    @property
    @pulumi.getter(name="queryStringWhitelists")
    def query_string_whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Names of query string parameters to include in cache keys.
        All other parameters will be excluded. Either specify
        query_string_whitelist or query_string_blacklist, not both.
        '&' and '=' will be percent encoded and not treated as
        delimiters.
        """
        return pulumi.get(self, "query_string_whitelists")

    @query_string_whitelists.setter
    def query_string_whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "query_string_whitelists", value)


@pulumi.input_type
class BackendServiceCdnPolicyNegativeCachingPolicyArgs:
    def __init__(__self__, *,
                 code: Optional[pulumi.Input[int]] = None,
                 ttl: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] code: The HTTP status code to define a TTL against. Only HTTP status codes 300, 301, 308, 404, 405, 410, 421, 451 and 501
               can be specified as values, and you cannot specify a status code more than once.
        :param pulumi.Input[int] ttl: The TTL (in seconds) for which to cache responses with the corresponding status code. The maximum allowed value is 1800s
               (30 minutes), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
        """
        if code is not None:
            pulumi.set(__self__, "code", code)
        if ttl is not None:
            pulumi.set(__self__, "ttl", ttl)

    @property
    @pulumi.getter
    def code(self) -> Optional[pulumi.Input[int]]:
        """
        The HTTP status code to define a TTL against. Only HTTP status codes 300, 301, 308, 404, 405, 410, 421, 451 and 501
        can be specified as values, and you cannot specify a status code more than once.
        """
        return pulumi.get(self, "code")

    @code.setter
    def code(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "code", value)

    @property
    @pulumi.getter
    def ttl(self) -> Optional[pulumi.Input[int]]:
        """
        The TTL (in seconds) for which to cache responses with the corresponding status code. The maximum allowed value is 1800s
        (30 minutes), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
        """
        return pulumi.get(self, "ttl")

    @ttl.setter
    def ttl(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "ttl", value)


@pulumi.input_type
class BackendServiceCircuitBreakersArgs:
    def __init__(__self__, *,
                 connect_timeout: Optional[pulumi.Input['BackendServiceCircuitBreakersConnectTimeoutArgs']] = None,
                 max_connections: Optional[pulumi.Input[int]] = None,
                 max_pending_requests: Optional[pulumi.Input[int]] = None,
                 max_requests: Optional[pulumi.Input[int]] = None,
                 max_requests_per_connection: Optional[pulumi.Input[int]] = None,
                 max_retries: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input['BackendServiceCircuitBreakersConnectTimeoutArgs'] connect_timeout: The timeout for new network connections to hosts.
               Structure is documented below.
        :param pulumi.Input[int] max_connections: The maximum number of connections to the backend cluster.
               Defaults to 1024.
        :param pulumi.Input[int] max_pending_requests: The maximum number of pending requests to the backend cluster.
               Defaults to 1024.
        :param pulumi.Input[int] max_requests: The maximum number of parallel requests to the backend cluster.
               Defaults to 1024.
        :param pulumi.Input[int] max_requests_per_connection: Maximum requests for a single backend connection. This parameter
               is respected by both the HTTP/1.1 and HTTP/2 implementations. If
               not specified, there is no limit. Setting this parameter to 1
               will effectively disable keep alive.
        :param pulumi.Input[int] max_retries: The maximum number of parallel retries to the backend cluster.
               Defaults to 3.
        """
        if connect_timeout is not None:
            pulumi.set(__self__, "connect_timeout", connect_timeout)
        if max_connections is not None:
            pulumi.set(__self__, "max_connections", max_connections)
        if max_pending_requests is not None:
            pulumi.set(__self__, "max_pending_requests", max_pending_requests)
        if max_requests is not None:
            pulumi.set(__self__, "max_requests", max_requests)
        if max_requests_per_connection is not None:
            pulumi.set(__self__, "max_requests_per_connection", max_requests_per_connection)
        if max_retries is not None:
            pulumi.set(__self__, "max_retries", max_retries)

    @property
    @pulumi.getter(name="connectTimeout")
    def connect_timeout(self) -> Optional[pulumi.Input['BackendServiceCircuitBreakersConnectTimeoutArgs']]:
        """
        The timeout for new network connections to hosts.
        Structure is documented below.
        """
        return pulumi.get(self, "connect_timeout")

    @connect_timeout.setter
    def connect_timeout(self, value: Optional[pulumi.Input['BackendServiceCircuitBreakersConnectTimeoutArgs']]):
        pulumi.set(self, "connect_timeout", value)

    @property
    @pulumi.getter(name="maxConnections")
    def max_connections(self) -> Optional[pulumi.Input[int]]:
        """
        The maximum number of connections to the backend cluster.
        Defaults to 1024.
        """
        return pulumi.get(self, "max_connections")

    @max_connections.setter
    def max_connections(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_connections", value)

    @property
    @pulumi.getter(name="maxPendingRequests")
    def max_pending_requests(self) -> Optional[pulumi.Input[int]]:
        """
        The maximum number of pending requests to the backend cluster.
        Defaults to 1024.
        """
        return pulumi.get(self, "max_pending_requests")

    @max_pending_requests.setter
    def max_pending_requests(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_pending_requests", value)

    @property
    @pulumi.getter(name="maxRequests")
    def max_requests(self) -> Optional[pulumi.Input[int]]:
        """
        The maximum number of parallel requests to the backend cluster.
        Defaults to 1024.
        """
        return pulumi.get(self, "max_requests")

    @max_requests.setter
    def max_requests(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_requests", value)

    @property
    @pulumi.getter(name="maxRequestsPerConnection")
    def max_requests_per_connection(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum requests for a single backend connection. This parameter
        is respected by both the HTTP/1.1 and HTTP/2 implementations. If
        not specified, there is no limit. Setting this parameter to 1
        will effectively disable keep alive.
        """
        return pulumi.get(self, "max_requests_per_connection")

    @max_requests_per_connection.setter
    def max_requests_per_connection(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_requests_per_connection", value)

    @property
    @pulumi.getter(name="maxRetries")
    def max_retries(self) -> Optional[pulumi.Input[int]]:
        """
        The maximum number of parallel retries to the backend cluster.
        Defaults to 3.
        """
        return pulumi.get(self, "max_retries")

    @max_retries.setter
    def max_retries(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_retries", value)


@pulumi.input_type
class BackendServiceCircuitBreakersConnectTimeoutArgs:
    def __init__(__self__, *,
                 seconds: pulumi.Input[int],
                 nanos: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
               inclusive.
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations
               less than one second are represented with a 0 `seconds` field and a positive
               `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        pulumi.set(__self__, "seconds", seconds)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)

    @property
    @pulumi.getter
    def seconds(self) -> pulumi.Input[int]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
        inclusive.
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: pulumi.Input[int]):
        pulumi.set(self, "seconds", value)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations
        less than one second are represented with a 0 `seconds` field and a positive
        `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)


@pulumi.input_type
class BackendServiceConsistentHashArgs:
    def __init__(__self__, *,
                 http_cookie: Optional[pulumi.Input['BackendServiceConsistentHashHttpCookieArgs']] = None,
                 http_header_name: Optional[pulumi.Input[str]] = None,
                 minimum_ring_size: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input['BackendServiceConsistentHashHttpCookieArgs'] http_cookie: Hash is based on HTTP Cookie. This field describes a HTTP cookie
               that will be used as the hash key for the consistent hash load
               balancer. If the cookie is not present, it will be generated.
               This field is applicable if the sessionAffinity is set to HTTP_COOKIE.
               Structure is documented below.
        :param pulumi.Input[str] http_header_name: The hash based on the value of the specified header field.
               This field is applicable if the sessionAffinity is set to HEADER_FIELD.
        :param pulumi.Input[int] minimum_ring_size: The minimum number of virtual nodes to use for the hash ring.
               Larger ring sizes result in more granular load
               distributions. If the number of hosts in the load balancing pool
               is larger than the ring size, each host will be assigned a single
               virtual node.
               Defaults to 1024.
        """
        if http_cookie is not None:
            pulumi.set(__self__, "http_cookie", http_cookie)
        if http_header_name is not None:
            pulumi.set(__self__, "http_header_name", http_header_name)
        if minimum_ring_size is not None:
            pulumi.set(__self__, "minimum_ring_size", minimum_ring_size)

    @property
    @pulumi.getter(name="httpCookie")
    def http_cookie(self) -> Optional[pulumi.Input['BackendServiceConsistentHashHttpCookieArgs']]:
        """
        Hash is based on HTTP Cookie. This field describes a HTTP cookie
        that will be used as the hash key for the consistent hash load
        balancer. If the cookie is not present, it will be generated.
        This field is applicable if the sessionAffinity is set to HTTP_COOKIE.
        Structure is documented below.
        """
        return pulumi.get(self, "http_cookie")

    @http_cookie.setter
    def http_cookie(self, value: Optional[pulumi.Input['BackendServiceConsistentHashHttpCookieArgs']]):
        pulumi.set(self, "http_cookie", value)

    @property
    @pulumi.getter(name="httpHeaderName")
    def http_header_name(self) -> Optional[pulumi.Input[str]]:
        """
        The hash based on the value of the specified header field.
        This field is applicable if the sessionAffinity is set to HEADER_FIELD.
        """
        return pulumi.get(self, "http_header_name")

    @http_header_name.setter
    def http_header_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "http_header_name", value)

    @property
    @pulumi.getter(name="minimumRingSize")
    def minimum_ring_size(self) -> Optional[pulumi.Input[int]]:
        """
        The minimum number of virtual nodes to use for the hash ring.
        Larger ring sizes result in more granular load
        distributions. If the number of hosts in the load balancing pool
        is larger than the ring size, each host will be assigned a single
        virtual node.
        Defaults to 1024.
        """
        return pulumi.get(self, "minimum_ring_size")

    @minimum_ring_size.setter
    def minimum_ring_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "minimum_ring_size", value)


@pulumi.input_type
class BackendServiceConsistentHashHttpCookieArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None,
                 path: Optional[pulumi.Input[str]] = None,
                 ttl: Optional[pulumi.Input['BackendServiceConsistentHashHttpCookieTtlArgs']] = None):
        """
        :param pulumi.Input[str] name: Name of the cookie.
        :param pulumi.Input[str] path: Path to set for the cookie.
        :param pulumi.Input['BackendServiceConsistentHashHttpCookieTtlArgs'] ttl: The TTL (in seconds) for which to cache responses with the corresponding status code. The maximum allowed value is 1800s
               (30 minutes), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if ttl is not None:
            pulumi.set(__self__, "ttl", ttl)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        Name of the cookie.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def path(self) -> Optional[pulumi.Input[str]]:
        """
        Path to set for the cookie.
        """
        return pulumi.get(self, "path")

    @path.setter
    def path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path", value)

    @property
    @pulumi.getter
    def ttl(self) -> Optional[pulumi.Input['BackendServiceConsistentHashHttpCookieTtlArgs']]:
        """
        The TTL (in seconds) for which to cache responses with the corresponding status code. The maximum allowed value is 1800s
        (30 minutes), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
        """
        return pulumi.get(self, "ttl")

    @ttl.setter
    def ttl(self, value: Optional[pulumi.Input['BackendServiceConsistentHashHttpCookieTtlArgs']]):
        pulumi.set(self, "ttl", value)


@pulumi.input_type
class BackendServiceConsistentHashHttpCookieTtlArgs:
    def __init__(__self__, *,
                 seconds: pulumi.Input[int],
                 nanos: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
               inclusive.
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations
               less than one second are represented with a 0 `seconds` field and a positive
               `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        pulumi.set(__self__, "seconds", seconds)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)

    @property
    @pulumi.getter
    def seconds(self) -> pulumi.Input[int]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
        inclusive.
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: pulumi.Input[int]):
        pulumi.set(self, "seconds", value)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations
        less than one second are represented with a 0 `seconds` field and a positive
        `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)


@pulumi.input_type
class BackendServiceIamBindingConditionArgs:
    def __init__(__self__, *,
                 expression: pulumi.Input[str],
                 title: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] expression: Textual representation of an expression in Common Expression Language syntax.
        :param pulumi.Input[str] title: A title for the expression, i.e. a short string describing its purpose.
        :param pulumi.Input[str] description: An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "title", title)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter
    def title(self) -> pulumi.Input[str]:
        """
        A title for the expression, i.e. a short string describing its purpose.
        """
        return pulumi.get(self, "title")

    @title.setter
    def title(self, value: pulumi.Input[str]):
        pulumi.set(self, "title", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class BackendServiceIamMemberConditionArgs:
    def __init__(__self__, *,
                 expression: pulumi.Input[str],
                 title: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] expression: Textual representation of an expression in Common Expression Language syntax.
        :param pulumi.Input[str] title: A title for the expression, i.e. a short string describing its purpose.
        :param pulumi.Input[str] description: An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "title", title)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter
    def title(self) -> pulumi.Input[str]:
        """
        A title for the expression, i.e. a short string describing its purpose.
        """
        return pulumi.get(self, "title")

    @title.setter
    def title(self, value: pulumi.Input[str]):
        pulumi.set(self, "title", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class BackendServiceIapArgs:
    def __init__(__self__, *,
                 oauth2_client_id: pulumi.Input[str],
                 oauth2_client_secret: pulumi.Input[str],
                 oauth2_client_secret_sha256: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] oauth2_client_id: OAuth2 Client ID for IAP
        :param pulumi.Input[str] oauth2_client_secret: OAuth2 Client Secret for IAP
               **Note**: This property is sensitive and will not be displayed in the plan.
        :param pulumi.Input[str] oauth2_client_secret_sha256: -
               OAuth2 Client Secret SHA-256 for IAP
               **Note**: This property is sensitive and will not be displayed in the plan.
        """
        pulumi.set(__self__, "oauth2_client_id", oauth2_client_id)
        pulumi.set(__self__, "oauth2_client_secret", oauth2_client_secret)
        if oauth2_client_secret_sha256 is not None:
            pulumi.set(__self__, "oauth2_client_secret_sha256", oauth2_client_secret_sha256)

    @property
    @pulumi.getter(name="oauth2ClientId")
    def oauth2_client_id(self) -> pulumi.Input[str]:
        """
        OAuth2 Client ID for IAP
        """
        return pulumi.get(self, "oauth2_client_id")

    @oauth2_client_id.setter
    def oauth2_client_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "oauth2_client_id", value)

    @property
    @pulumi.getter(name="oauth2ClientSecret")
    def oauth2_client_secret(self) -> pulumi.Input[str]:
        """
        OAuth2 Client Secret for IAP
        **Note**: This property is sensitive and will not be displayed in the plan.
        """
        return pulumi.get(self, "oauth2_client_secret")

    @oauth2_client_secret.setter
    def oauth2_client_secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "oauth2_client_secret", value)

    @property
    @pulumi.getter(name="oauth2ClientSecretSha256")
    def oauth2_client_secret_sha256(self) -> Optional[pulumi.Input[str]]:
        """
        -
        OAuth2 Client Secret SHA-256 for IAP
        **Note**: This property is sensitive and will not be displayed in the plan.
        """
        return pulumi.get(self, "oauth2_client_secret_sha256")

    @oauth2_client_secret_sha256.setter
    def oauth2_client_secret_sha256(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "oauth2_client_secret_sha256", value)


@pulumi.input_type
class BackendServiceLogConfigArgs:
    def __init__(__self__, *,
                 enable: Optional[pulumi.Input[bool]] = None,
                 sample_rate: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[bool] enable: Whether to enable logging for the load balancer traffic served by this backend service.
        :param pulumi.Input[float] sample_rate: This field can only be specified if logging is enabled for this backend service. The value of
               the field must be in [0, 1]. This configures the sampling rate of requests to the load balancer
               where 1.0 means all logged requests are reported and 0.0 means no logged requests are reported.
               The default value is 1.0.
        """
        if enable is not None:
            pulumi.set(__self__, "enable", enable)
        if sample_rate is not None:
            pulumi.set(__self__, "sample_rate", sample_rate)

    @property
    @pulumi.getter
    def enable(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to enable logging for the load balancer traffic served by this backend service.
        """
        return pulumi.get(self, "enable")

    @enable.setter
    def enable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable", value)

    @property
    @pulumi.getter(name="sampleRate")
    def sample_rate(self) -> Optional[pulumi.Input[float]]:
        """
        This field can only be specified if logging is enabled for this backend service. The value of
        the field must be in [0, 1]. This configures the sampling rate of requests to the load balancer
        where 1.0 means all logged requests are reported and 0.0 means no logged requests are reported.
        The default value is 1.0.
        """
        return pulumi.get(self, "sample_rate")

    @sample_rate.setter
    def sample_rate(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "sample_rate", value)


@pulumi.input_type
class BackendServiceOutlierDetectionArgs:
    def __init__(__self__, *,
                 base_ejection_time: Optional[pulumi.Input['BackendServiceOutlierDetectionBaseEjectionTimeArgs']] = None,
                 consecutive_errors: Optional[pulumi.Input[int]] = None,
                 consecutive_gateway_failure: Optional[pulumi.Input[int]] = None,
                 enforcing_consecutive_errors: Optional[pulumi.Input[int]] = None,
                 enforcing_consecutive_gateway_failure: Optional[pulumi.Input[int]] = None,
                 enforcing_success_rate: Optional[pulumi.Input[int]] = None,
                 interval: Optional[pulumi.Input['BackendServiceOutlierDetectionIntervalArgs']] = None,
                 max_ejection_percent: Optional[pulumi.Input[int]] = None,
                 success_rate_minimum_hosts: Optional[pulumi.Input[int]] = None,
                 success_rate_request_volume: Optional[pulumi.Input[int]] = None,
                 success_rate_stdev_factor: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input['BackendServiceOutlierDetectionBaseEjectionTimeArgs'] base_ejection_time: The base time that a host is ejected for. The real time is equal to the base
               time multiplied by the number of times the host has been ejected. Defaults to
               30000ms or 30s.
               Structure is documented below.
        :param pulumi.Input[int] consecutive_errors: Number of errors before a host is ejected from the connection pool. When the
               backend host is accessed over HTTP, a 5xx return code qualifies as an error.
               Defaults to 5.
        :param pulumi.Input[int] consecutive_gateway_failure: The number of consecutive gateway failures (502, 503, 504 status or connection
               errors that are mapped to one of those status codes) before a consecutive
               gateway failure ejection occurs. Defaults to 5.
        :param pulumi.Input[int] enforcing_consecutive_errors: The percentage chance that a host will be actually ejected when an outlier
               status is detected through consecutive 5xx. This setting can be used to disable
               ejection or to ramp it up slowly. Defaults to 100.
        :param pulumi.Input[int] enforcing_consecutive_gateway_failure: The percentage chance that a host will be actually ejected when an outlier
               status is detected through consecutive gateway failures. This setting can be
               used to disable ejection or to ramp it up slowly. Defaults to 0.
        :param pulumi.Input[int] enforcing_success_rate: The percentage chance that a host will be actually ejected when an outlier
               status is detected through success rate statistics. This setting can be used to
               disable ejection or to ramp it up slowly. Defaults to 100.
        :param pulumi.Input['BackendServiceOutlierDetectionIntervalArgs'] interval: Time interval between ejection sweep analysis. This can result in both new
               ejections as well as hosts being returned to service. Defaults to 10 seconds.
               Structure is documented below.
        :param pulumi.Input[int] max_ejection_percent: Maximum percentage of hosts in the load balancing pool for the backend service
               that can be ejected. Defaults to 10%.
        :param pulumi.Input[int] success_rate_minimum_hosts: The number of hosts in a cluster that must have enough request volume to detect
               success rate outliers. If the number of hosts is less than this setting, outlier
               detection via success rate statistics is not performed for any host in the
               cluster. Defaults to 5.
        :param pulumi.Input[int] success_rate_request_volume: The minimum number of total requests that must be collected in one interval (as
               defined by the interval duration above) to include this host in success rate
               based outlier detection. If the volume is lower than this setting, outlier
               detection via success rate statistics is not performed for that host. Defaults
               to 100.
        :param pulumi.Input[int] success_rate_stdev_factor: This factor is used to determine the ejection threshold for success rate outlier
               ejection. The ejection threshold is the difference between the mean success
               rate, and the product of this factor and the standard deviation of the mean
               success rate: mean - (stdev * success_rate_stdev_factor). This factor is divided
               by a thousand to get a double. That is, if the desired factor is 1.9, the
               runtime value should be 1900. Defaults to 1900.
        """
        if base_ejection_time is not None:
            pulumi.set(__self__, "base_ejection_time", base_ejection_time)
        if consecutive_errors is not None:
            pulumi.set(__self__, "consecutive_errors", consecutive_errors)
        if consecutive_gateway_failure is not None:
            pulumi.set(__self__, "consecutive_gateway_failure", consecutive_gateway_failure)
        if enforcing_consecutive_errors is not None:
            pulumi.set(__self__, "enforcing_consecutive_errors", enforcing_consecutive_errors)
        if enforcing_consecutive_gateway_failure is not None:
            pulumi.set(__self__, "enforcing_consecutive_gateway_failure", enforcing_consecutive_gateway_failure)
        if enforcing_success_rate is not None:
            pulumi.set(__self__, "enforcing_success_rate", enforcing_success_rate)
        if interval is not None:
            pulumi.set(__self__, "interval", interval)
        if max_ejection_percent is not None:
            pulumi.set(__self__, "max_ejection_percent", max_ejection_percent)
        if success_rate_minimum_hosts is not None:
            pulumi.set(__self__, "success_rate_minimum_hosts", success_rate_minimum_hosts)
        if success_rate_request_volume is not None:
            pulumi.set(__self__, "success_rate_request_volume", success_rate_request_volume)
        if success_rate_stdev_factor is not None:
            pulumi.set(__self__, "success_rate_stdev_factor", success_rate_stdev_factor)

    @property
    @pulumi.getter(name="baseEjectionTime")
    def base_ejection_time(self) -> Optional[pulumi.Input['BackendServiceOutlierDetectionBaseEjectionTimeArgs']]:
        """
        The base time that a host is ejected for. The real time is equal to the base
        time multiplied by the number of times the host has been ejected. Defaults to
        30000ms or 30s.
        Structure is documented below.
        """
        return pulumi.get(self, "base_ejection_time")

    @base_ejection_time.setter
    def base_ejection_time(self, value: Optional[pulumi.Input['BackendServiceOutlierDetectionBaseEjectionTimeArgs']]):
        pulumi.set(self, "base_ejection_time", value)

    @property
    @pulumi.getter(name="consecutiveErrors")
    def consecutive_errors(self) -> Optional[pulumi.Input[int]]:
        """
        Number of errors before a host is ejected from the connection pool. When the
        backend host is accessed over HTTP, a 5xx return code qualifies as an error.
        Defaults to 5.
        """
        return pulumi.get(self, "consecutive_errors")

    @consecutive_errors.setter
    def consecutive_errors(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "consecutive_errors", value)

    @property
    @pulumi.getter(name="consecutiveGatewayFailure")
    def consecutive_gateway_failure(self) -> Optional[pulumi.Input[int]]:
        """
        The number of consecutive gateway failures (502, 503, 504 status or connection
        errors that are mapped to one of those status codes) before a consecutive
        gateway failure ejection occurs. Defaults to 5.
        """
        return pulumi.get(self, "consecutive_gateway_failure")

    @consecutive_gateway_failure.setter
    def consecutive_gateway_failure(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "consecutive_gateway_failure", value)

    @property
    @pulumi.getter(name="enforcingConsecutiveErrors")
    def enforcing_consecutive_errors(self) -> Optional[pulumi.Input[int]]:
        """
        The percentage chance that a host will be actually ejected when an outlier
        status is detected through consecutive 5xx. This setting can be used to disable
        ejection or to ramp it up slowly. Defaults to 100.
        """
        return pulumi.get(self, "enforcing_consecutive_errors")

    @enforcing_consecutive_errors.setter
    def enforcing_consecutive_errors(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "enforcing_consecutive_errors", value)

    @property
    @pulumi.getter(name="enforcingConsecutiveGatewayFailure")
    def enforcing_consecutive_gateway_failure(self) -> Optional[pulumi.Input[int]]:
        """
        The percentage chance that a host will be actually ejected when an outlier
        status is detected through consecutive gateway failures. This setting can be
        used to disable ejection or to ramp it up slowly. Defaults to 0.
        """
        return pulumi.get(self, "enforcing_consecutive_gateway_failure")

    @enforcing_consecutive_gateway_failure.setter
    def enforcing_consecutive_gateway_failure(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "enforcing_consecutive_gateway_failure", value)

    @property
    @pulumi.getter(name="enforcingSuccessRate")
    def enforcing_success_rate(self) -> Optional[pulumi.Input[int]]:
        """
        The percentage chance that a host will be actually ejected when an outlier
        status is detected through success rate statistics. This setting can be used to
        disable ejection or to ramp it up slowly. Defaults to 100.
        """
        return pulumi.get(self, "enforcing_success_rate")

    @enforcing_success_rate.setter
    def enforcing_success_rate(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "enforcing_success_rate", value)

    @property
    @pulumi.getter
    def interval(self) -> Optional[pulumi.Input['BackendServiceOutlierDetectionIntervalArgs']]:
        """
        Time interval between ejection sweep analysis. This can result in both new
        ejections as well as hosts being returned to service. Defaults to 10 seconds.
        Structure is documented below.
        """
        return pulumi.get(self, "interval")

    @interval.setter
    def interval(self, value: Optional[pulumi.Input['BackendServiceOutlierDetectionIntervalArgs']]):
        pulumi.set(self, "interval", value)

    @property
    @pulumi.getter(name="maxEjectionPercent")
    def max_ejection_percent(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum percentage of hosts in the load balancing pool for the backend service
        that can be ejected. Defaults to 10%.
        """
        return pulumi.get(self, "max_ejection_percent")

    @max_ejection_percent.setter
    def max_ejection_percent(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_ejection_percent", value)

    @property
    @pulumi.getter(name="successRateMinimumHosts")
    def success_rate_minimum_hosts(self) -> Optional[pulumi.Input[int]]:
        """
        The number of hosts in a cluster that must have enough request volume to detect
        success rate outliers. If the number of hosts is less than this setting, outlier
        detection via success rate statistics is not performed for any host in the
        cluster. Defaults to 5.
        """
        return pulumi.get(self, "success_rate_minimum_hosts")

    @success_rate_minimum_hosts.setter
    def success_rate_minimum_hosts(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "success_rate_minimum_hosts", value)

    @property
    @pulumi.getter(name="successRateRequestVolume")
    def success_rate_request_volume(self) -> Optional[pulumi.Input[int]]:
        """
        The minimum number of total requests that must be collected in one interval (as
        defined by the interval duration above) to include this host in success rate
        based outlier detection. If the volume is lower than this setting, outlier
        detection via success rate statistics is not performed for that host. Defaults
        to 100.
        """
        return pulumi.get(self, "success_rate_request_volume")

    @success_rate_request_volume.setter
    def success_rate_request_volume(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "success_rate_request_volume", value)

    @property
    @pulumi.getter(name="successRateStdevFactor")
    def success_rate_stdev_factor(self) -> Optional[pulumi.Input[int]]:
        """
        This factor is used to determine the ejection threshold for success rate outlier
        ejection. The ejection threshold is the difference between the mean success
        rate, and the product of this factor and the standard deviation of the mean
        success rate: mean - (stdev * success_rate_stdev_factor). This factor is divided
        by a thousand to get a double. That is, if the desired factor is 1.9, the
        runtime value should be 1900. Defaults to 1900.
        """
        return pulumi.get(self, "success_rate_stdev_factor")

    @success_rate_stdev_factor.setter
    def success_rate_stdev_factor(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "success_rate_stdev_factor", value)


@pulumi.input_type
class BackendServiceOutlierDetectionBaseEjectionTimeArgs:
    def __init__(__self__, *,
                 seconds: pulumi.Input[int],
                 nanos: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
               inclusive.
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations
               less than one second are represented with a 0 `seconds` field and a positive
               `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        pulumi.set(__self__, "seconds", seconds)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)

    @property
    @pulumi.getter
    def seconds(self) -> pulumi.Input[int]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
        inclusive.
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: pulumi.Input[int]):
        pulumi.set(self, "seconds", value)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations
        less than one second are represented with a 0 `seconds` field and a positive
        `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)


@pulumi.input_type
class BackendServiceOutlierDetectionIntervalArgs:
    def __init__(__self__, *,
                 seconds: pulumi.Input[int],
                 nanos: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
               inclusive.
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations
               less than one second are represented with a 0 `seconds` field and a positive
               `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        pulumi.set(__self__, "seconds", seconds)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)

    @property
    @pulumi.getter
    def seconds(self) -> pulumi.Input[int]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
        inclusive.
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: pulumi.Input[int]):
        pulumi.set(self, "seconds", value)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations
        less than one second are represented with a 0 `seconds` field and a positive
        `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)


@pulumi.input_type
class BackendServiceSecuritySettingsArgs:
    def __init__(__self__, *,
                 client_tls_policy: pulumi.Input[str],
                 subject_alt_names: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        :param pulumi.Input[str] client_tls_policy: ClientTlsPolicy is a resource that specifies how a client should authenticate
               connections to backends of a service. This resource itself does not affect
               configuration unless it is attached to a backend service resource.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] subject_alt_names: A list of alternate names to verify the subject identity in the certificate.
               If specified, the client will verify that the server certificate's subject
               alt name matches one of the specified values.
        """
        pulumi.set(__self__, "client_tls_policy", client_tls_policy)
        pulumi.set(__self__, "subject_alt_names", subject_alt_names)

    @property
    @pulumi.getter(name="clientTlsPolicy")
    def client_tls_policy(self) -> pulumi.Input[str]:
        """
        ClientTlsPolicy is a resource that specifies how a client should authenticate
        connections to backends of a service. This resource itself does not affect
        configuration unless it is attached to a backend service resource.
        """
        return pulumi.get(self, "client_tls_policy")

    @client_tls_policy.setter
    def client_tls_policy(self, value: pulumi.Input[str]):
        pulumi.set(self, "client_tls_policy", value)

    @property
    @pulumi.getter(name="subjectAltNames")
    def subject_alt_names(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        A list of alternate names to verify the subject identity in the certificate.
        If specified, the client will verify that the server certificate's subject
        alt name matches one of the specified values.
        """
        return pulumi.get(self, "subject_alt_names")

    @subject_alt_names.setter
    def subject_alt_names(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "subject_alt_names", value)


@pulumi.input_type
class DiskDiskEncryptionKeyArgs:
    def __init__(__self__, *,
                 kms_key_self_link: Optional[pulumi.Input[str]] = None,
                 kms_key_service_account: Optional[pulumi.Input[str]] = None,
                 raw_key: Optional[pulumi.Input[str]] = None,
                 sha256: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] kms_key_self_link: The self link of the encryption key used to encrypt the disk. Also called KmsKeyName
               in the cloud console. Your project's Compute Engine System service account
               (`service-{{PROJECT_NUMBER}}@compute-system.iam.gserviceaccount.com`) must have
               `roles/cloudkms.cryptoKeyEncrypterDecrypter` to use this feature.
               See https://cloud.google.com/compute/docs/disks/customer-managed-encryption#encrypt_a_new_persistent_disk_with_your_own_keys
        :param pulumi.Input[str] kms_key_service_account: The service account used for the encryption request for the given KMS key.
               If absent, the Compute Engine Service Agent service account is used.
        :param pulumi.Input[str] raw_key: Specifies a 256-bit customer-supplied encryption key, encoded in
               RFC 4648 base64 to either encrypt or decrypt this resource.
        :param pulumi.Input[str] sha256: -
               The RFC 4648 base64 encoded SHA-256 hash of the customer-supplied
               encryption key that protects this resource.
        """
        if kms_key_self_link is not None:
            pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
        if kms_key_service_account is not None:
            pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
        if raw_key is not None:
            pulumi.set(__self__, "raw_key", raw_key)
        if sha256 is not None:
            pulumi.set(__self__, "sha256", sha256)

    @property
    @pulumi.getter(name="kmsKeySelfLink")
    def kms_key_self_link(self) -> Optional[pulumi.Input[str]]:
        """
        The self link of the encryption key used to encrypt the disk. Also called KmsKeyName
        in the cloud console. Your project's Compute Engine System service account
        (`service-{{PROJECT_NUMBER}}@compute-system.iam.gserviceaccount.com`) must have
        `roles/cloudkms.cryptoKeyEncrypterDecrypter` to use this feature.
        See https://cloud.google.com/compute/docs/disks/customer-managed-encryption#encrypt_a_new_persistent_disk_with_your_own_keys
        """
        return pulumi.get(self, "kms_key_self_link")

    @kms_key_self_link.setter
    def kms_key_self_link(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_self_link", value)

    @property
    @pulumi.getter(name="kmsKeyServiceAccount")
    def kms_key_service_account(self) -> Optional[pulumi.Input[str]]:
        """
        The service account used for the encryption request for the given KMS key.
        If absent, the Compute Engine Service Agent service account is used.
        """
        return pulumi.get(self, "kms_key_service_account")

    @kms_key_service_account.setter
    def kms_key_service_account(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_service_account", value)

    @property
    @pulumi.getter(name="rawKey")
    def raw_key(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies a 256-bit customer-supplied encryption key, encoded in
        RFC 4648 base64 to either encrypt or decrypt this resource.
        """
        return pulumi.get(self, "raw_key")

    @raw_key.setter
    def raw_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "raw_key", value)

    @property
    @pulumi.getter
    def sha256(self) -> Optional[pulumi.Input[str]]:
        """
        -
        The RFC 4648 base64 encoded SHA-256 hash of the customer-supplied
        encryption key that protects this resource.
        """
        return pulumi.get(self, "sha256")

    @sha256.setter
    def sha256(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sha256", value)


@pulumi.input_type
class DiskIamBindingConditionArgs:
    def __init__(__self__, *,
                 expression: pulumi.Input[str],
                 title: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "title", title)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter
    def title(self) -> pulumi.Input[str]:
        return pulumi.get(self, "title")

    @title.setter
    def title(self, value: pulumi.Input[str]):
        pulumi.set(self, "title", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class DiskIamMemberConditionArgs:
    def __init__(__self__, *,
                 expression: pulumi.Input[str],
                 title: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "title", title)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter
    def title(self) -> pulumi.Input[str]:
        return pulumi.get(self, "title")

    @title.setter
    def title(self, value: pulumi.Input[str]):
        pulumi.set(self, "title", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class DiskSourceImageEncryptionKeyArgs:
    def __init__(__self__, *,
                 kms_key_self_link: Optional[pulumi.Input[str]] = None,
                 kms_key_service_account: Optional[pulumi.Input[str]] = None,
                 raw_key: Optional[pulumi.Input[str]] = None,
                 sha256: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] kms_key_self_link: The self link of the encryption key used to encrypt the disk. Also called KmsKeyName
               in the cloud console. Your project's Compute Engine System service account
               (`service-{{PROJECT_NUMBER}}@compute-system.iam.gserviceaccount.com`) must have
               `roles/cloudkms.cryptoKeyEncrypterDecrypter` to use this feature.
               See https://cloud.google.com/compute/docs/disks/customer-managed-encryption#encrypt_a_new_persistent_disk_with_your_own_keys
        :param pulumi.Input[str] kms_key_service_account: The service account used for the encryption request for the given KMS key.
               If absent, the Compute Engine Service Agent service account is used.
        :param pulumi.Input[str] raw_key: Specifies a 256-bit customer-supplied encryption key, encoded in
               RFC 4648 base64 to either encrypt or decrypt this resource.
        :param pulumi.Input[str] sha256: -
               The RFC 4648 base64 encoded SHA-256 hash of the customer-supplied
               encryption key that protects this resource.
        """
        if kms_key_self_link is not None:
            pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
        if kms_key_service_account is not None:
            pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
        if raw_key is not None:
            pulumi.set(__self__, "raw_key", raw_key)
        if sha256 is not None:
            pulumi.set(__self__, "sha256", sha256)

    @property
    @pulumi.getter(name="kmsKeySelfLink")
    def kms_key_self_link(self) -> Optional[pulumi.Input[str]]:
        """
        The self link of the encryption key used to encrypt the disk. Also called KmsKeyName
        in the cloud console. Your project's Compute Engine System service account
        (`service-{{PROJECT_NUMBER}}@compute-system.iam.gserviceaccount.com`) must have
        `roles/cloudkms.cryptoKeyEncrypterDecrypter` to use this feature.
        See https://cloud.google.com/compute/docs/disks/customer-managed-encryption#encrypt_a_new_persistent_disk_with_your_own_keys
        """
        return pulumi.get(self, "kms_key_self_link")

    @kms_key_self_link.setter
    def kms_key_self_link(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_self_link", value)

    @property
    @pulumi.getter(name="kmsKeyServiceAccount")
    def kms_key_service_account(self) -> Optional[pulumi.Input[str]]:
        """
        The service account used for the encryption request for the given KMS key.
        If absent, the Compute Engine Service Agent service account is used.
        """
        return pulumi.get(self, "kms_key_service_account")

    @kms_key_service_account.setter
    def kms_key_service_account(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_service_account", value)

    @property
    @pulumi.getter(name="rawKey")
    def raw_key(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies a 256-bit customer-supplied encryption key, encoded in
        RFC 4648 base64 to either encrypt or decrypt this resource.
        """
        return pulumi.get(self, "raw_key")

    @raw_key.setter
    def raw_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "raw_key", value)

    @property
    @pulumi.getter
    def sha256(self) -> Optional[pulumi.Input[str]]:
        """
        -
        The RFC 4648 base64 encoded SHA-256 hash of the customer-supplied
        encryption key that protects this resource.
        """
        return pulumi.get(self, "sha256")

    @sha256.setter
    def sha256(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sha256", value)


@pulumi.input_type
class DiskSourceSnapshotEncryptionKeyArgs:
    def __init__(__self__, *,
                 kms_key_self_link: Optional[pulumi.Input[str]] = None,
                 kms_key_service_account: Optional[pulumi.Input[str]] = None,
                 raw_key: Optional[pulumi.Input[str]] = None,
                 sha256: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] kms_key_self_link: The self link of the encryption key used to encrypt the disk. Also called KmsKeyName
               in the cloud console. Your project's Compute Engine System service account
               (`service-{{PROJECT_NUMBER}}@compute-system.iam.gserviceaccount.com`) must have
               `roles/cloudkms.cryptoKeyEncrypterDecrypter` to use this feature.
               See https://cloud.google.com/compute/docs/disks/customer-managed-encryption#encrypt_a_new_persistent_disk_with_your_own_keys
        :param pulumi.Input[str] kms_key_service_account: The service account used for the encryption request for the given KMS key.
               If absent, the Compute Engine Service Agent service account is used.
        :param pulumi.Input[str] raw_key: Specifies a 256-bit customer-supplied encryption key, encoded in
               RFC 4648 base64 to either encrypt or decrypt this resource.
        :param pulumi.Input[str] sha256: -
               The RFC 4648 base64 encoded SHA-256 hash of the customer-supplied
               encryption key that protects this resource.
        """
        if kms_key_self_link is not None:
            pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
        if kms_key_service_account is not None:
            pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
        if raw_key is not None:
            pulumi.set(__self__, "raw_key", raw_key)
        if sha256 is not None:
            pulumi.set(__self__, "sha256", sha256)

    @property
    @pulumi.getter(name="kmsKeySelfLink")
    def kms_key_self_link(self) -> Optional[pulumi.Input[str]]:
        """
        The self link of the encryption key used to encrypt the disk. Also called KmsKeyName
        in the cloud console. Your project's Compute Engine System service account
        (`service-{{PROJECT_NUMBER}}@compute-system.iam.gserviceaccount.com`) must have
        `roles/cloudkms.cryptoKeyEncrypterDecrypter` to use this feature.
        See https://cloud.google.com/compute/docs/disks/customer-managed-encryption#encrypt_a_new_persistent_disk_with_your_own_keys
        """
        return pulumi.get(self, "kms_key_self_link")

    @kms_key_self_link.setter
    def kms_key_self_link(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_self_link", value)

    @property
    @pulumi.getter(name="kmsKeyServiceAccount")
    def kms_key_service_account(self) -> Optional[pulumi.Input[str]]:
        """
        The service account used for the encryption request for the given KMS key.
        If absent, the Compute Engine Service Agent service account is used.
        """
        return pulumi.get(self, "kms_key_service_account")

    @kms_key_service_account.setter
    def kms_key_service_account(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_service_account", value)

    @property
    @pulumi.getter(name="rawKey")
    def raw_key(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies a 256-bit customer-supplied encryption key, encoded in
        RFC 4648 base64 to either encrypt or decrypt this resource.
        """
        return pulumi.get(self, "raw_key")

    @raw_key.setter
    def raw_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "raw_key", value)

    @property
    @pulumi.getter
    def sha256(self) -> Optional[pulumi.Input[str]]:
        """
        -
        The RFC 4648 base64 encoded SHA-256 hash of the customer-supplied
        encryption key that protects this resource.
        """
        return pulumi.get(self, "sha256")

    @sha256.setter
    def sha256(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sha256", value)


@pulumi.input_type
class ExternalVpnGatewayInterfaceArgs:
    def __init__(__self__, *,
                 id: Optional[pulumi.Input[int]] = None,
                 ip_address: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] id: The numeric ID for this interface. Allowed values are based on the redundancy type
               of this external VPN gateway
               * `0 - SINGLE_IP_INTERNALLY_REDUNDANT`
               * `0, 1 - TWO_IPS_REDUNDANCY`
               * `0, 1, 2, 3 - FOUR_IPS_REDUNDANCY`
        :param pulumi.Input[str] ip_address: IP address of the interface in the external VPN gateway.
               Only IPv4 is supported. This IP address can be either from
               your on-premise gateway or another Cloud provider's VPN gateway,
               it cannot be an IP address from Google Compute Engine.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[int]]:
        """
        The numeric ID for this interface. Allowed values are based on the redundancy type
        of this external VPN gateway
        * `0 - SINGLE_IP_INTERNALLY_REDUNDANT`
        * `0, 1 - TWO_IPS_REDUNDANCY`
        * `0, 1, 2, 3 - FOUR_IPS_REDUNDANCY`
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> Optional[pulumi.Input[str]]:
        """
        IP address of the interface in the external VPN gateway.
        Only IPv4 is supported. This IP address can be either from
        your on-premise gateway or another Cloud provider's VPN gateway,
        it cannot be an IP address from Google Compute Engine.
        """
        return pulumi.get(self, "ip_address")

    @ip_address.setter
    def ip_address(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ip_address", value)


@pulumi.input_type
class FirewallAllowArgs:
    def __init__(__self__, *,
                 protocol: pulumi.Input[str],
                 ports: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] protocol: The IP protocol to which this rule applies. The protocol type is
               required when creating a firewall rule. This value can either be
               one of the following well known protocol strings (tcp, udp,
               icmp, esp, ah, sctp, ipip, all), or the IP protocol number.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ports: An optional list of ports to which this rule applies. This field
               is only applicable for UDP or TCP protocol. Each entry must be
               either an integer or a range. If not specified, this rule
               applies to connections through any port.
               Example inputs include: ["22"], ["80","443"], and
               ["12345-12349"].
        """
        pulumi.set(__self__, "protocol", protocol)
        if ports is not None:
            pulumi.set(__self__, "ports", ports)

    @property
    @pulumi.getter
    def protocol(self) -> pulumi.Input[str]:
        """
        The IP protocol to which this rule applies. The protocol type is
        required when creating a firewall rule. This value can either be
        one of the following well known protocol strings (tcp, udp,
        icmp, esp, ah, sctp, ipip, all), or the IP protocol number.
        """
        return pulumi.get(self, "protocol")

    @protocol.setter
    def protocol(self, value: pulumi.Input[str]):
        pulumi.set(self, "protocol", value)

    @property
    @pulumi.getter
    def ports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        An optional list of ports to which this rule applies. This field
        is only applicable for UDP or TCP protocol. Each entry must be
        either an integer or a range. If not specified, this rule
        applies to connections through any port.
        Example inputs include: ["22"], ["80","443"], and
        ["12345-12349"].
        """
        return pulumi.get(self, "ports")

    @ports.setter
    def ports(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ports", value)


@pulumi.input_type
class FirewallDenyArgs:
    def __init__(__self__, *,
                 protocol: pulumi.Input[str],
                 ports: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] protocol: The IP protocol to which this rule applies. The protocol type is
               required when creating a firewall rule. This value can either be
               one of the following well known protocol strings (tcp, udp,
               icmp, esp, ah, sctp, ipip, all), or the IP protocol number.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ports: An optional list of ports to which this rule applies. This field
               is only applicable for UDP or TCP protocol. Each entry must be
               either an integer or a range. If not specified, this rule
               applies to connections through any port.
               Example inputs include: ["22"], ["80","443"], and
               ["12345-12349"].
        """
        pulumi.set(__self__, "protocol", protocol)
        if ports is not None:
            pulumi.set(__self__, "ports", ports)

    @property
    @pulumi.getter
    def protocol(self) -> pulumi.Input[str]:
        """
        The IP protocol to which this rule applies. The protocol type is
        required when creating a firewall rule. This value can either be
        one of the following well known protocol strings (tcp, udp,
        icmp, esp, ah, sctp, ipip, all), or the IP protocol number.
        """
        return pulumi.get(self, "protocol")

    @protocol.setter
    def protocol(self, value: pulumi.Input[str]):
        pulumi.set(self, "protocol", value)

    @property
    @pulumi.getter
    def ports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        An optional list of ports to which this rule applies. This field
        is only applicable for UDP or TCP protocol. Each entry must be
        either an integer or a range. If not specified, this rule
        applies to connections through any port.
        Example inputs include: ["22"], ["80","443"], and
        ["12345-12349"].
        """
        return pulumi.get(self, "ports")

    @ports.setter
    def ports(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ports", value)


@pulumi.input_type
class FirewallLogConfigArgs:
    def __init__(__self__, *,
                 metadata: pulumi.Input[str]):
        """
        :param pulumi.Input[str] metadata: This field denotes whether to include or exclude metadata for firewall logs.
               Possible values are `EXCLUDE_ALL_METADATA` and `INCLUDE_ALL_METADATA`.
        """
        pulumi.set(__self__, "metadata", metadata)

    @property
    @pulumi.getter
    def metadata(self) -> pulumi.Input[str]:
        """
        This field denotes whether to include or exclude metadata for firewall logs.
        Possible values are `EXCLUDE_ALL_METADATA` and `INCLUDE_ALL_METADATA`.
        """
        return pulumi.get(self, "metadata")

    @metadata.setter
    def metadata(self, value: pulumi.Input[str]):
        pulumi.set(self, "metadata", value)


@pulumi.input_type
class FirewallPolicyRuleMatchArgs:
    def __init__(__self__, *,
                 layer4_configs: pulumi.Input[Sequence[pulumi.Input['FirewallPolicyRuleMatchLayer4ConfigArgs']]],
                 dest_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 src_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['FirewallPolicyRuleMatchLayer4ConfigArgs']]] layer4_configs: Pairs of IP protocols and ports that the rule should match. Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] dest_ip_ranges: CIDR IP address range. Maximum number of destination CIDR IP ranges allowed is 256.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] src_ip_ranges: CIDR IP address range. Maximum number of source CIDR IP ranges allowed is 256.
        """
        pulumi.set(__self__, "layer4_configs", layer4_configs)
        if dest_ip_ranges is not None:
            pulumi.set(__self__, "dest_ip_ranges", dest_ip_ranges)
        if src_ip_ranges is not None:
            pulumi.set(__self__, "src_ip_ranges", src_ip_ranges)

    @property
    @pulumi.getter(name="layer4Configs")
    def layer4_configs(self) -> pulumi.Input[Sequence[pulumi.Input['FirewallPolicyRuleMatchLayer4ConfigArgs']]]:
        """
        Pairs of IP protocols and ports that the rule should match. Structure is documented below.
        """
        return pulumi.get(self, "layer4_configs")

    @layer4_configs.setter
    def layer4_configs(self, value: pulumi.Input[Sequence[pulumi.Input['FirewallPolicyRuleMatchLayer4ConfigArgs']]]):
        pulumi.set(self, "layer4_configs", value)

    @property
    @pulumi.getter(name="destIpRanges")
    def dest_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        CIDR IP address range. Maximum number of destination CIDR IP ranges allowed is 256.
        """
        return pulumi.get(self, "dest_ip_ranges")

    @dest_ip_ranges.setter
    def dest_ip_ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "dest_ip_ranges", value)

    @property
    @pulumi.getter(name="srcIpRanges")
    def src_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        CIDR IP address range. Maximum number of source CIDR IP ranges allowed is 256.
        """
        return pulumi.get(self, "src_ip_ranges")

    @src_ip_ranges.setter
    def src_ip_ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "src_ip_ranges", value)


@pulumi.input_type
class FirewallPolicyRuleMatchLayer4ConfigArgs:
    def __init__(__self__, *,
                 ip_protocol: pulumi.Input[str],
                 ports: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] ip_protocol: The IP protocol to which this rule applies. The protocol type is required when creating a firewall rule. This value can either be one of the following well known protocol strings (`tcp`, `udp`, `icmp`, `esp`, `ah`, `ipip`, `sctp`), or the IP protocol number.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ports: An optional list of ports to which this rule applies. This field is only applicable for UDP or TCP protocol. Each entry must be either an integer or a range. If not specified, this rule applies to connections through any port. Example inputs include: ``.
        """
        pulumi.set(__self__, "ip_protocol", ip_protocol)
        if ports is not None:
            pulumi.set(__self__, "ports", ports)

    @property
    @pulumi.getter(name="ipProtocol")
    def ip_protocol(self) -> pulumi.Input[str]:
        """
        The IP protocol to which this rule applies. The protocol type is required when creating a firewall rule. This value can either be one of the following well known protocol strings (`tcp`, `udp`, `icmp`, `esp`, `ah`, `ipip`, `sctp`), or the IP protocol number.
        """
        return pulumi.get(self, "ip_protocol")

    @ip_protocol.setter
    def ip_protocol(self, value: pulumi.Input[str]):
        pulumi.set(self, "ip_protocol", value)

    @property
    @pulumi.getter
    def ports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        An optional list of ports to which this rule applies. This field is only applicable for UDP or TCP protocol. Each entry must be either an integer or a range. If not specified, this rule applies to connections through any port. Example inputs include: ``.
        """
        return pulumi.get(self, "ports")

    @ports.setter
    def ports(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ports", value)


@pulumi.input_type
class ForwardingRuleServiceDirectoryRegistrationArgs:
    def __init__(__self__, *,
                 namespace: Optional[pulumi.Input[str]] = None,
                 service: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] namespace: Service Directory namespace to register the forwarding rule under.
        :param pulumi.Input[str] service: Service Directory service to register the forwarding rule under.
        """
        if namespace is not None:
            pulumi.set(__self__, "namespace", namespace)
        if service is not None:
            pulumi.set(__self__, "service", service)

    @property
    @pulumi.getter
    def namespace(self) -> Optional[pulumi.Input[str]]:
        """
        Service Directory namespace to register the forwarding rule under.
        """
        return pulumi.get(self, "namespace")

    @namespace.setter
    def namespace(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "namespace", value)

    @property
    @pulumi.getter
    def service(self) -> Optional[pulumi.Input[str]]:
        """
        Service Directory service to register the forwarding rule under.
        """
        return pulumi.get(self, "service")

    @service.setter
    def service(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service", value)


@pulumi.input_type
class GlobalForwardingRuleMetadataFilterArgs:
    def __init__(__self__, *,
                 filter_labels: pulumi.Input[Sequence[pulumi.Input['GlobalForwardingRuleMetadataFilterFilterLabelArgs']]],
                 filter_match_criteria: pulumi.Input[str]):
        """
        :param pulumi.Input[Sequence[pulumi.Input['GlobalForwardingRuleMetadataFilterFilterLabelArgs']]] filter_labels: The list of label value pairs that must match labels in the
               provided metadata based on filterMatchCriteria
               This list must not be empty and can have at the most 64 entries.
               Structure is documented below.
        :param pulumi.Input[str] filter_match_criteria: Specifies how individual filterLabel matches within the list of
               filterLabels contribute towards the overall metadataFilter match.
               MATCH_ANY - At least one of the filterLabels must have a matching
               label in the provided metadata.
               MATCH_ALL - All filterLabels must have matching labels in the
               provided metadata.
               Possible values are `MATCH_ANY` and `MATCH_ALL`.
        """
        pulumi.set(__self__, "filter_labels", filter_labels)
        pulumi.set(__self__, "filter_match_criteria", filter_match_criteria)

    @property
    @pulumi.getter(name="filterLabels")
    def filter_labels(self) -> pulumi.Input[Sequence[pulumi.Input['GlobalForwardingRuleMetadataFilterFilterLabelArgs']]]:
        """
        The list of label value pairs that must match labels in the
        provided metadata based on filterMatchCriteria
        This list must not be empty and can have at the most 64 entries.
        Structure is documented below.
        """
        return pulumi.get(self, "filter_labels")

    @filter_labels.setter
    def filter_labels(self, value: pulumi.Input[Sequence[pulumi.Input['GlobalForwardingRuleMetadataFilterFilterLabelArgs']]]):
        pulumi.set(self, "filter_labels", value)

    @property
    @pulumi.getter(name="filterMatchCriteria")
    def filter_match_criteria(self) -> pulumi.Input[str]:
        """
        Specifies how individual filterLabel matches within the list of
        filterLabels contribute towards the overall metadataFilter match.
        MATCH_ANY - At least one of the filterLabels must have a matching
        label in the provided metadata.
        MATCH_ALL - All filterLabels must have matching labels in the
        provided metadata.
        Possible values are `MATCH_ANY` and `MATCH_ALL`.
        """
        return pulumi.get(self, "filter_match_criteria")

    @filter_match_criteria.setter
    def filter_match_criteria(self, value: pulumi.Input[str]):
        pulumi.set(self, "filter_match_criteria", value)


@pulumi.input_type
class GlobalForwardingRuleMetadataFilterFilterLabelArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] name: Name of the metadata label. The length must be between
               1 and 1024 characters, inclusive.
        :param pulumi.Input[str] value: The value that the label must match. The value has a maximum
               length of 1024 characters.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        Name of the metadata label. The length must be between
        1 and 1024 characters, inclusive.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        The value that the label must match. The value has a maximum
        length of 1024 characters.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class HaVpnGatewayVpnInterfaceArgs:
    def __init__(__self__, *,
                 id: Optional[pulumi.Input[int]] = None,
                 interconnect_attachment: Optional[pulumi.Input[str]] = None,
                 ip_address: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] id: The numeric ID of this VPN gateway interface.
        :param pulumi.Input[str] interconnect_attachment: URL of the interconnect attachment resource. When the value
               of this field is present, the VPN Gateway will be used for
               IPsec-encrypted Cloud Interconnect; all Egress or Ingress
               traffic for this VPN Gateway interface will go through the
               specified interconnect attachment resource.
               Not currently available publicly.
        :param pulumi.Input[str] ip_address: -
               The external IP address for this VPN gateway interface.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)
        if interconnect_attachment is not None:
            pulumi.set(__self__, "interconnect_attachment", interconnect_attachment)
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[int]]:
        """
        The numeric ID of this VPN gateway interface.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter(name="interconnectAttachment")
    def interconnect_attachment(self) -> Optional[pulumi.Input[str]]:
        """
        URL of the interconnect attachment resource. When the value
        of this field is present, the VPN Gateway will be used for
        IPsec-encrypted Cloud Interconnect; all Egress or Ingress
        traffic for this VPN Gateway interface will go through the
        specified interconnect attachment resource.
        Not currently available publicly.
        """
        return pulumi.get(self, "interconnect_attachment")

    @interconnect_attachment.setter
    def interconnect_attachment(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "interconnect_attachment", value)

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> Optional[pulumi.Input[str]]:
        """
        -
        The external IP address for this VPN gateway interface.
        """
        return pulumi.get(self, "ip_address")

    @ip_address.setter
    def ip_address(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ip_address", value)


@pulumi.input_type
class HealthCheckGrpcHealthCheckArgs:
    def __init__(__self__, *,
                 grpc_service_name: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 port_name: Optional[pulumi.Input[str]] = None,
                 port_specification: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] grpc_service_name: The gRPC service name for the health check.
               The value of grpcServiceName has the following meanings by convention:
               - Empty serviceName means the overall status of all services at the backend.
               - Non-empty serviceName means the health of that gRPC service, as defined by the owner of the service.
               The grpcServiceName can only be ASCII.
        :param pulumi.Input[int] port: The port number for the health check request.
               Must be specified if portName and portSpecification are not set
               or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        :param pulumi.Input[str] port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param pulumi.Input[str] port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
               * `USE_NAMED_PORT`: The `portName` is used for health checking.
               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
               network endpoint is used for health checking. For other backends, the
               port or named port specified in the Backend Service is used for health
               checking.
               If not specified, gRPC health check follows behavior specified in `port` and
               `portName` fields.
               Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        """
        if grpc_service_name is not None:
            pulumi.set(__self__, "grpc_service_name", grpc_service_name)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if port_name is not None:
            pulumi.set(__self__, "port_name", port_name)
        if port_specification is not None:
            pulumi.set(__self__, "port_specification", port_specification)

    @property
    @pulumi.getter(name="grpcServiceName")
    def grpc_service_name(self) -> Optional[pulumi.Input[str]]:
        """
        The gRPC service name for the health check.
        The value of grpcServiceName has the following meanings by convention:
        - Empty serviceName means the overall status of all services at the backend.
        - Non-empty serviceName means the health of that gRPC service, as defined by the owner of the service.
        The grpcServiceName can only be ASCII.
        """
        return pulumi.get(self, "grpc_service_name")

    @grpc_service_name.setter
    def grpc_service_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "grpc_service_name", value)

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[int]]:
        """
        The port number for the health check request.
        Must be specified if portName and portSpecification are not set
        or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> Optional[pulumi.Input[str]]:
        """
        Port name as defined in InstanceGroup#NamedPort#name. If both port and
        port_name are defined, port takes precedence.
        """
        return pulumi.get(self, "port_name")

    @port_name.setter
    def port_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_name", value)

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
        * `USE_NAMED_PORT`: The `portName` is used for health checking.
        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
        network endpoint is used for health checking. For other backends, the
        port or named port specified in the Backend Service is used for health
        checking.
        If not specified, gRPC health check follows behavior specified in `port` and
        `portName` fields.
        Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        """
        return pulumi.get(self, "port_specification")

    @port_specification.setter
    def port_specification(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_specification", value)


@pulumi.input_type
class HealthCheckHttp2HealthCheckArgs:
    def __init__(__self__, *,
                 host: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 port_name: Optional[pulumi.Input[str]] = None,
                 port_specification: Optional[pulumi.Input[str]] = None,
                 proxy_header: Optional[pulumi.Input[str]] = None,
                 request_path: Optional[pulumi.Input[str]] = None,
                 response: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host: The value of the host header in the HTTP2 health check request.
               If left empty (default value), the public IP on behalf of which this health
               check is performed will be used.
        :param pulumi.Input[int] port: The port number for the health check request.
               Must be specified if portName and portSpecification are not set
               or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        :param pulumi.Input[str] port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param pulumi.Input[str] port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
               * `USE_NAMED_PORT`: The `portName` is used for health checking.
               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
               network endpoint is used for health checking. For other backends, the
               port or named port specified in the Backend Service is used for health
               checking.
               If not specified, gRPC health check follows behavior specified in `port` and
               `portName` fields.
               Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        :param pulumi.Input[str] proxy_header: Specifies the type of proxy header to append before sending data to the
               backend.
               Default value is `NONE`.
               Possible values are `NONE` and `PROXY_V1`.
        :param pulumi.Input[str] request_path: The request path of the HTTP2 health check request.
               The default value is /.
        :param pulumi.Input[str] response: The bytes to match against the beginning of the response data. If left empty
               (the default value), any response will indicate health. The response data
               can only be ASCII.
        """
        if host is not None:
            pulumi.set(__self__, "host", host)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if port_name is not None:
            pulumi.set(__self__, "port_name", port_name)
        if port_specification is not None:
            pulumi.set(__self__, "port_specification", port_specification)
        if proxy_header is not None:
            pulumi.set(__self__, "proxy_header", proxy_header)
        if request_path is not None:
            pulumi.set(__self__, "request_path", request_path)
        if response is not None:
            pulumi.set(__self__, "response", response)

    @property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the host header in the HTTP2 health check request.
        If left empty (default value), the public IP on behalf of which this health
        check is performed will be used.
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host", value)

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[int]]:
        """
        The port number for the health check request.
        Must be specified if portName and portSpecification are not set
        or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> Optional[pulumi.Input[str]]:
        """
        Port name as defined in InstanceGroup#NamedPort#name. If both port and
        port_name are defined, port takes precedence.
        """
        return pulumi.get(self, "port_name")

    @port_name.setter
    def port_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_name", value)

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
        * `USE_NAMED_PORT`: The `portName` is used for health checking.
        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
        network endpoint is used for health checking. For other backends, the
        port or named port specified in the Backend Service is used for health
        checking.
        If not specified, gRPC health check follows behavior specified in `port` and
        `portName` fields.
        Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        """
        return pulumi.get(self, "port_specification")

    @port_specification.setter
    def port_specification(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_specification", value)

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the type of proxy header to append before sending data to the
        backend.
        Default value is `NONE`.
        Possible values are `NONE` and `PROXY_V1`.
        """
        return pulumi.get(self, "proxy_header")

    @proxy_header.setter
    def proxy_header(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "proxy_header", value)

    @property
    @pulumi.getter(name="requestPath")
    def request_path(self) -> Optional[pulumi.Input[str]]:
        """
        The request path of the HTTP2 health check request.
        The default value is /.
        """
        return pulumi.get(self, "request_path")

    @request_path.setter
    def request_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "request_path", value)

    @property
    @pulumi.getter
    def response(self) -> Optional[pulumi.Input[str]]:
        """
        The bytes to match against the beginning of the response data. If left empty
        (the default value), any response will indicate health. The response data
        can only be ASCII.
        """
        return pulumi.get(self, "response")

    @response.setter
    def response(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "response", value)


@pulumi.input_type
class HealthCheckHttpHealthCheckArgs:
    def __init__(__self__, *,
                 host: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 port_name: Optional[pulumi.Input[str]] = None,
                 port_specification: Optional[pulumi.Input[str]] = None,
                 proxy_header: Optional[pulumi.Input[str]] = None,
                 request_path: Optional[pulumi.Input[str]] = None,
                 response: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host: The value of the host header in the HTTP2 health check request.
               If left empty (default value), the public IP on behalf of which this health
               check is performed will be used.
        :param pulumi.Input[int] port: The port number for the health check request.
               Must be specified if portName and portSpecification are not set
               or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        :param pulumi.Input[str] port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param pulumi.Input[str] port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
               * `USE_NAMED_PORT`: The `portName` is used for health checking.
               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
               network endpoint is used for health checking. For other backends, the
               port or named port specified in the Backend Service is used for health
               checking.
               If not specified, gRPC health check follows behavior specified in `port` and
               `portName` fields.
               Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        :param pulumi.Input[str] proxy_header: Specifies the type of proxy header to append before sending data to the
               backend.
               Default value is `NONE`.
               Possible values are `NONE` and `PROXY_V1`.
        :param pulumi.Input[str] request_path: The request path of the HTTP2 health check request.
               The default value is /.
        :param pulumi.Input[str] response: The bytes to match against the beginning of the response data. If left empty
               (the default value), any response will indicate health. The response data
               can only be ASCII.
        """
        if host is not None:
            pulumi.set(__self__, "host", host)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if port_name is not None:
            pulumi.set(__self__, "port_name", port_name)
        if port_specification is not None:
            pulumi.set(__self__, "port_specification", port_specification)
        if proxy_header is not None:
            pulumi.set(__self__, "proxy_header", proxy_header)
        if request_path is not None:
            pulumi.set(__self__, "request_path", request_path)
        if response is not None:
            pulumi.set(__self__, "response", response)

    @property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the host header in the HTTP2 health check request.
        If left empty (default value), the public IP on behalf of which this health
        check is performed will be used.
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host", value)

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[int]]:
        """
        The port number for the health check request.
        Must be specified if portName and portSpecification are not set
        or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> Optional[pulumi.Input[str]]:
        """
        Port name as defined in InstanceGroup#NamedPort#name. If both port and
        port_name are defined, port takes precedence.
        """
        return pulumi.get(self, "port_name")

    @port_name.setter
    def port_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_name", value)

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
        * `USE_NAMED_PORT`: The `portName` is used for health checking.
        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
        network endpoint is used for health checking. For other backends, the
        port or named port specified in the Backend Service is used for health
        checking.
        If not specified, gRPC health check follows behavior specified in `port` and
        `portName` fields.
        Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        """
        return pulumi.get(self, "port_specification")

    @port_specification.setter
    def port_specification(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_specification", value)

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the type of proxy header to append before sending data to the
        backend.
        Default value is `NONE`.
        Possible values are `NONE` and `PROXY_V1`.
        """
        return pulumi.get(self, "proxy_header")

    @proxy_header.setter
    def proxy_header(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "proxy_header", value)

    @property
    @pulumi.getter(name="requestPath")
    def request_path(self) -> Optional[pulumi.Input[str]]:
        """
        The request path of the HTTP2 health check request.
        The default value is /.
        """
        return pulumi.get(self, "request_path")

    @request_path.setter
    def request_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "request_path", value)

    @property
    @pulumi.getter
    def response(self) -> Optional[pulumi.Input[str]]:
        """
        The bytes to match against the beginning of the response data. If left empty
        (the default value), any response will indicate health. The response data
        can only be ASCII.
        """
        return pulumi.get(self, "response")

    @response.setter
    def response(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "response", value)


@pulumi.input_type
class HealthCheckHttpsHealthCheckArgs:
    def __init__(__self__, *,
                 host: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 port_name: Optional[pulumi.Input[str]] = None,
                 port_specification: Optional[pulumi.Input[str]] = None,
                 proxy_header: Optional[pulumi.Input[str]] = None,
                 request_path: Optional[pulumi.Input[str]] = None,
                 response: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host: The value of the host header in the HTTP2 health check request.
               If left empty (default value), the public IP on behalf of which this health
               check is performed will be used.
        :param pulumi.Input[int] port: The port number for the health check request.
               Must be specified if portName and portSpecification are not set
               or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        :param pulumi.Input[str] port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param pulumi.Input[str] port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
               * `USE_NAMED_PORT`: The `portName` is used for health checking.
               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
               network endpoint is used for health checking. For other backends, the
               port or named port specified in the Backend Service is used for health
               checking.
               If not specified, gRPC health check follows behavior specified in `port` and
               `portName` fields.
               Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        :param pulumi.Input[str] proxy_header: Specifies the type of proxy header to append before sending data to the
               backend.
               Default value is `NONE`.
               Possible values are `NONE` and `PROXY_V1`.
        :param pulumi.Input[str] request_path: The request path of the HTTP2 health check request.
               The default value is /.
        :param pulumi.Input[str] response: The bytes to match against the beginning of the response data. If left empty
               (the default value), any response will indicate health. The response data
               can only be ASCII.
        """
        if host is not None:
            pulumi.set(__self__, "host", host)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if port_name is not None:
            pulumi.set(__self__, "port_name", port_name)
        if port_specification is not None:
            pulumi.set(__self__, "port_specification", port_specification)
        if proxy_header is not None:
            pulumi.set(__self__, "proxy_header", proxy_header)
        if request_path is not None:
            pulumi.set(__self__, "request_path", request_path)
        if response is not None:
            pulumi.set(__self__, "response", response)

    @property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the host header in the HTTP2 health check request.
        If left empty (default value), the public IP on behalf of which this health
        check is performed will be used.
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host", value)

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[int]]:
        """
        The port number for the health check request.
        Must be specified if portName and portSpecification are not set
        or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> Optional[pulumi.Input[str]]:
        """
        Port name as defined in InstanceGroup#NamedPort#name. If both port and
        port_name are defined, port takes precedence.
        """
        return pulumi.get(self, "port_name")

    @port_name.setter
    def port_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_name", value)

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
        * `USE_NAMED_PORT`: The `portName` is used for health checking.
        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
        network endpoint is used for health checking. For other backends, the
        port or named port specified in the Backend Service is used for health
        checking.
        If not specified, gRPC health check follows behavior specified in `port` and
        `portName` fields.
        Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        """
        return pulumi.get(self, "port_specification")

    @port_specification.setter
    def port_specification(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_specification", value)

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the type of proxy header to append before sending data to the
        backend.
        Default value is `NONE`.
        Possible values are `NONE` and `PROXY_V1`.
        """
        return pulumi.get(self, "proxy_header")

    @proxy_header.setter
    def proxy_header(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "proxy_header", value)

    @property
    @pulumi.getter(name="requestPath")
    def request_path(self) -> Optional[pulumi.Input[str]]:
        """
        The request path of the HTTP2 health check request.
        The default value is /.
        """
        return pulumi.get(self, "request_path")

    @request_path.setter
    def request_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "request_path", value)

    @property
    @pulumi.getter
    def response(self) -> Optional[pulumi.Input[str]]:
        """
        The bytes to match against the beginning of the response data. If left empty
        (the default value), any response will indicate health. The response data
        can only be ASCII.
        """
        return pulumi.get(self, "response")

    @response.setter
    def response(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "response", value)


@pulumi.input_type
class HealthCheckLogConfigArgs:
    def __init__(__self__, *,
                 enable: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] enable: Indicates whether or not to export logs. This is false by default,
               which means no health check logging will be done.
        """
        if enable is not None:
            pulumi.set(__self__, "enable", enable)

    @property
    @pulumi.getter
    def enable(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether or not to export logs. This is false by default,
        which means no health check logging will be done.
        """
        return pulumi.get(self, "enable")

    @enable.setter
    def enable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable", value)


@pulumi.input_type
class HealthCheckSslHealthCheckArgs:
    def __init__(__self__, *,
                 port: Optional[pulumi.Input[int]] = None,
                 port_name: Optional[pulumi.Input[str]] = None,
                 port_specification: Optional[pulumi.Input[str]] = None,
                 proxy_header: Optional[pulumi.Input[str]] = None,
                 request: Optional[pulumi.Input[str]] = None,
                 response: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] port: The port number for the health check request.
               Must be specified if portName and portSpecification are not set
               or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        :param pulumi.Input[str] port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param pulumi.Input[str] port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
               * `USE_NAMED_PORT`: The `portName` is used for health checking.
               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
               network endpoint is used for health checking. For other backends, the
               port or named port specified in the Backend Service is used for health
               checking.
               If not specified, gRPC health check follows behavior specified in `port` and
               `portName` fields.
               Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        :param pulumi.Input[str] proxy_header: Specifies the type of proxy header to append before sending data to the
               backend.
               Default value is `NONE`.
               Possible values are `NONE` and `PROXY_V1`.
        :param pulumi.Input[str] request: The application data to send once the SSL connection has been
               established (default value is empty). If both request and response are
               empty, the connection establishment alone will indicate health. The request
               data can only be ASCII.
        :param pulumi.Input[str] response: The bytes to match against the beginning of the response data. If left empty
               (the default value), any response will indicate health. The response data
               can only be ASCII.
        """
        if port is not None:
            pulumi.set(__self__, "port", port)
        if port_name is not None:
            pulumi.set(__self__, "port_name", port_name)
        if port_specification is not None:
            pulumi.set(__self__, "port_specification", port_specification)
        if proxy_header is not None:
            pulumi.set(__self__, "proxy_header", proxy_header)
        if request is not None:
            pulumi.set(__self__, "request", request)
        if response is not None:
            pulumi.set(__self__, "response", response)

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[int]]:
        """
        The port number for the health check request.
        Must be specified if portName and portSpecification are not set
        or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> Optional[pulumi.Input[str]]:
        """
        Port name as defined in InstanceGroup#NamedPort#name. If both port and
        port_name are defined, port takes precedence.
        """
        return pulumi.get(self, "port_name")

    @port_name.setter
    def port_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_name", value)

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
        * `USE_NAMED_PORT`: The `portName` is used for health checking.
        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
        network endpoint is used for health checking. For other backends, the
        port or named port specified in the Backend Service is used for health
        checking.
        If not specified, gRPC health check follows behavior specified in `port` and
        `portName` fields.
        Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        """
        return pulumi.get(self, "port_specification")

    @port_specification.setter
    def port_specification(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_specification", value)

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the type of proxy header to append before sending data to the
        backend.
        Default value is `NONE`.
        Possible values are `NONE` and `PROXY_V1`.
        """
        return pulumi.get(self, "proxy_header")

    @proxy_header.setter
    def proxy_header(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "proxy_header", value)

    @property
    @pulumi.getter
    def request(self) -> Optional[pulumi.Input[str]]:
        """
        The application data to send once the SSL connection has been
        established (default value is empty). If both request and response are
        empty, the connection establishment alone will indicate health. The request
        data can only be ASCII.
        """
        return pulumi.get(self, "request")

    @request.setter
    def request(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "request", value)

    @property
    @pulumi.getter
    def response(self) -> Optional[pulumi.Input[str]]:
        """
        The bytes to match against the beginning of the response data. If left empty
        (the default value), any response will indicate health. The response data
        can only be ASCII.
        """
        return pulumi.get(self, "response")

    @response.setter
    def response(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "response", value)


@pulumi.input_type
class HealthCheckTcpHealthCheckArgs:
    def __init__(__self__, *,
                 port: Optional[pulumi.Input[int]] = None,
                 port_name: Optional[pulumi.Input[str]] = None,
                 port_specification: Optional[pulumi.Input[str]] = None,
                 proxy_header: Optional[pulumi.Input[str]] = None,
                 request: Optional[pulumi.Input[str]] = None,
                 response: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] port: The port number for the health check request.
               Must be specified if portName and portSpecification are not set
               or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        :param pulumi.Input[str] port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param pulumi.Input[str] port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
               * `USE_NAMED_PORT`: The `portName` is used for health checking.
               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
               network endpoint is used for health checking. For other backends, the
               port or named port specified in the Backend Service is used for health
               checking.
               If not specified, gRPC health check follows behavior specified in `port` and
               `portName` fields.
               Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        :param pulumi.Input[str] proxy_header: Specifies the type of proxy header to append before sending data to the
               backend.
               Default value is `NONE`.
               Possible values are `NONE` and `PROXY_V1`.
        :param pulumi.Input[str] request: The application data to send once the SSL connection has been
               established (default value is empty). If both request and response are
               empty, the connection establishment alone will indicate health. The request
               data can only be ASCII.
        :param pulumi.Input[str] response: The bytes to match against the beginning of the response data. If left empty
               (the default value), any response will indicate health. The response data
               can only be ASCII.
        """
        if port is not None:
            pulumi.set(__self__, "port", port)
        if port_name is not None:
            pulumi.set(__self__, "port_name", port_name)
        if port_specification is not None:
            pulumi.set(__self__, "port_specification", port_specification)
        if proxy_header is not None:
            pulumi.set(__self__, "proxy_header", proxy_header)
        if request is not None:
            pulumi.set(__self__, "request", request)
        if response is not None:
            pulumi.set(__self__, "response", response)

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[int]]:
        """
        The port number for the health check request.
        Must be specified if portName and portSpecification are not set
        or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> Optional[pulumi.Input[str]]:
        """
        Port name as defined in InstanceGroup#NamedPort#name. If both port and
        port_name are defined, port takes precedence.
        """
        return pulumi.get(self, "port_name")

    @port_name.setter
    def port_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_name", value)

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
        * `USE_NAMED_PORT`: The `portName` is used for health checking.
        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
        network endpoint is used for health checking. For other backends, the
        port or named port specified in the Backend Service is used for health
        checking.
        If not specified, gRPC health check follows behavior specified in `port` and
        `portName` fields.
        Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        """
        return pulumi.get(self, "port_specification")

    @port_specification.setter
    def port_specification(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_specification", value)

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the type of proxy header to append before sending data to the
        backend.
        Default value is `NONE`.
        Possible values are `NONE` and `PROXY_V1`.
        """
        return pulumi.get(self, "proxy_header")

    @proxy_header.setter
    def proxy_header(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "proxy_header", value)

    @property
    @pulumi.getter
    def request(self) -> Optional[pulumi.Input[str]]:
        """
        The application data to send once the SSL connection has been
        established (default value is empty). If both request and response are
        empty, the connection establishment alone will indicate health. The request
        data can only be ASCII.
        """
        return pulumi.get(self, "request")

    @request.setter
    def request(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "request", value)

    @property
    @pulumi.getter
    def response(self) -> Optional[pulumi.Input[str]]:
        """
        The bytes to match against the beginning of the response data. If left empty
        (the default value), any response will indicate health. The response data
        can only be ASCII.
        """
        return pulumi.get(self, "response")

    @response.setter
    def response(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "response", value)


@pulumi.input_type
class ImageGuestOsFeatureArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str]):
        """
        :param pulumi.Input[str] type: The type of supported feature. Read [Enabling guest operating system features](https://cloud.google.com/compute/docs/images/create-delete-deprecate-private-images#guest-os-features) to see a list of available options.
               Possible values are `MULTI_IP_SUBNET`, `SECURE_BOOT`, `SEV_CAPABLE`, `UEFI_COMPATIBLE`, `VIRTIO_SCSI_MULTIQUEUE`, `WINDOWS`, and `GVNIC`.
        """
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        The type of supported feature. Read [Enabling guest operating system features](https://cloud.google.com/compute/docs/images/create-delete-deprecate-private-images#guest-os-features) to see a list of available options.
        Possible values are `MULTI_IP_SUBNET`, `SECURE_BOOT`, `SEV_CAPABLE`, `UEFI_COMPATIBLE`, `VIRTIO_SCSI_MULTIQUEUE`, `WINDOWS`, and `GVNIC`.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class ImageIamBindingConditionArgs:
    def __init__(__self__, *,
                 expression: pulumi.Input[str],
                 title: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] expression: Textual representation of an expression in Common Expression Language syntax.
        :param pulumi.Input[str] title: A title for the expression, i.e. a short string describing its purpose.
        :param pulumi.Input[str] description: An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "title", title)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter
    def title(self) -> pulumi.Input[str]:
        """
        A title for the expression, i.e. a short string describing its purpose.
        """
        return pulumi.get(self, "title")

    @title.setter
    def title(self, value: pulumi.Input[str]):
        pulumi.set(self, "title", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class ImageIamMemberConditionArgs:
    def __init__(__self__, *,
                 expression: pulumi.Input[str],
                 title: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] expression: Textual representation of an expression in Common Expression Language syntax.
        :param pulumi.Input[str] title: A title for the expression, i.e. a short string describing its purpose.
        :param pulumi.Input[str] description: An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "title", title)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter
    def title(self) -> pulumi.Input[str]:
        """
        A title for the expression, i.e. a short string describing its purpose.
        """
        return pulumi.get(self, "title")

    @title.setter
    def title(self, value: pulumi.Input[str]):
        pulumi.set(self, "title", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class ImageRawDiskArgs:
    def __init__(__self__, *,
                 source: pulumi.Input[str],
                 container_type: Optional[pulumi.Input[str]] = None,
                 sha1: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] source: The full Google Cloud Storage URL where disk storage is stored
               You must provide either this property or the sourceDisk property
               but not both.
        :param pulumi.Input[str] container_type: The format used to encode and transmit the block device, which
               should be TAR. This is just a container and transmission format
               and not a runtime format. Provided by the client when the disk
               image is created.
               Default value is `TAR`.
               Possible values are `TAR`.
        :param pulumi.Input[str] sha1: An optional SHA1 checksum of the disk image before unpackaging.
               This is provided by the client when the disk image is created.
        """
        pulumi.set(__self__, "source", source)
        if container_type is not None:
            pulumi.set(__self__, "container_type", container_type)
        if sha1 is not None:
            pulumi.set(__self__, "sha1", sha1)

    @property
    @pulumi.getter
    def source(self) -> pulumi.Input[str]:
        """
        The full Google Cloud Storage URL where disk storage is stored
        You must provide either this property or the sourceDisk property
        but not both.
        """
        return pulumi.get(self, "source")

    @source.setter
    def source(self, value: pulumi.Input[str]):
        pulumi.set(self, "source", value)

    @property
    @pulumi.getter(name="containerType")
    def container_type(self) -> Optional[pulumi.Input[str]]:
        """
        The format used to encode and transmit the block device, which
        should be TAR. This is just a container and transmission format
        and not a runtime format. Provided by the client when the disk
        image is created.
        Default value is `TAR`.
        Possible values are `TAR`.
        """
        return pulumi.get(self, "container_type")

    @container_type.setter
    def container_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "container_type", value)

    @property
    @pulumi.getter
    def sha1(self) -> Optional[pulumi.Input[str]]:
        """
        An optional SHA1 checksum of the disk image before unpackaging.
        This is provided by the client when the disk image is created.
        """
        return pulumi.get(self, "sha1")

    @sha1.setter
    def sha1(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sha1", value)


@pulumi.input_type
class InstanceAdvancedMachineFeaturesArgs:
    def __init__(__self__, *,
                 enable_nested_virtualization: Optional[pulumi.Input[bool]] = None,
                 threads_per_core: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[bool] enable_nested_virtualization: Defines whether the instance should have nested virtualization  enabled. Defaults to false.
        :param pulumi.Input[int] threads_per_core: he number of threads per physical core. To disable [simultaneous multithreading (SMT)](https://cloud.google.com/compute/docs/instances/disabling-smt) set this to 1.
        """
        if enable_nested_virtualization is not None:
            pulumi.set(__self__, "enable_nested_virtualization", enable_nested_virtualization)
        if threads_per_core is not None:
            pulumi.set(__self__, "threads_per_core", threads_per_core)

    @property
    @pulumi.getter(name="enableNestedVirtualization")
    def enable_nested_virtualization(self) -> Optional[pulumi.Input[bool]]:
        """
        Defines whether the instance should have nested virtualization  enabled. Defaults to false.
        """
        return pulumi.get(self, "enable_nested_virtualization")

    @enable_nested_virtualization.setter
    def enable_nested_virtualization(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_nested_virtualization", value)

    @property
    @pulumi.getter(name="threadsPerCore")
    def threads_per_core(self) -> Optional[pulumi.Input[int]]:
        """
        he number of threads per physical core. To disable [simultaneous multithreading (SMT)](https://cloud.google.com/compute/docs/instances/disabling-smt) set this to 1.
        """
        return pulumi.get(self, "threads_per_core")

    @threads_per_core.setter
    def threads_per_core(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "threads_per_core", value)


@pulumi.input_type
class InstanceAttachedDiskArgs:
    def __init__(__self__, *,
                 source: pulumi.Input[str],
                 device_name: Optional[pulumi.Input[str]] = None,
                 disk_encryption_key_raw: Optional[pulumi.Input[str]] = None,
                 disk_encryption_key_sha256: Optional[pulumi.Input[str]] = None,
                 kms_key_self_link: Optional[pulumi.Input[str]] = None,
                 mode: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] source: The name or self_link of the disk to attach to this instance.
        :param pulumi.Input[str] device_name: Name with which the attached disk will be accessible
               under `/dev/disk/by-id/google-*`
        :param pulumi.Input[str] disk_encryption_key_raw: A 256-bit [customer-supplied encryption key]
               (<https://cloud.google.com/compute/docs/disks/customer-supplied-encryption>),
               encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
               to encrypt this disk. Only one of `kms_key_self_link` and `disk_encryption_key_raw` may be set.
        :param pulumi.Input[str] kms_key_self_link: The self_link of the encryption key that is
               stored in Google Cloud KMS to encrypt this disk. Only one of `kms_key_self_link`
               and `disk_encryption_key_raw` may be set.
        :param pulumi.Input[str] mode: Either "READ_ONLY" or "READ_WRITE", defaults to "READ_WRITE"
               If you have a persistent disk with data that you want to share
               between multiple instances, detach it from any read-write instances and
               attach it to one or more instances in read-only mode.
        """
        pulumi.set(__self__, "source", source)
        if device_name is not None:
            pulumi.set(__self__, "device_name", device_name)
        if disk_encryption_key_raw is not None:
            pulumi.set(__self__, "disk_encryption_key_raw", disk_encryption_key_raw)
        if disk_encryption_key_sha256 is not None:
            pulumi.set(__self__, "disk_encryption_key_sha256", disk_encryption_key_sha256)
        if kms_key_self_link is not None:
            pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter
    def source(self) -> pulumi.Input[str]:
        """
        The name or self_link of the disk to attach to this instance.
        """
        return pulumi.get(self, "source")

    @source.setter
    def source(self, value: pulumi.Input[str]):
        pulumi.set(self, "source", value)

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> Optional[pulumi.Input[str]]:
        """
        Name with which the attached disk will be accessible
        under `/dev/disk/by-id/google-*`
        """
        return pulumi.get(self, "device_name")

    @device_name.setter
    def device_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "device_name", value)

    @property
    @pulumi.getter(name="diskEncryptionKeyRaw")
    def disk_encryption_key_raw(self) -> Optional[pulumi.Input[str]]:
        """
        A 256-bit [customer-supplied encryption key]
        (<https://cloud.google.com/compute/docs/disks/customer-supplied-encryption>),
        encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
        to encrypt this disk. Only one of `kms_key_self_link` and `disk_encryption_key_raw` may be set.
        """
        return pulumi.get(self, "disk_encryption_key_raw")

    @disk_encryption_key_raw.setter
    def disk_encryption_key_raw(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_encryption_key_raw", value)

    @property
    @pulumi.getter(name="diskEncryptionKeySha256")
    def disk_encryption_key_sha256(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "disk_encryption_key_sha256")

    @disk_encryption_key_sha256.setter
    def disk_encryption_key_sha256(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_encryption_key_sha256", value)

    @property
    @pulumi.getter(name="kmsKeySelfLink")
    def kms_key_self_link(self) -> Optional[pulumi.Input[str]]:
        """
        The self_link of the encryption key that is
        stored in Google Cloud KMS to encrypt this disk. Only one of `kms_key_self_link`
        and `disk_encryption_key_raw` may be set.
        """
        return pulumi.get(self, "kms_key_self_link")

    @kms_key_self_link.setter
    def kms_key_self_link(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_self_link", value)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[str]]:
        """
        Either "READ_ONLY" or "READ_WRITE", defaults to "READ_WRITE"
        If you have a persistent disk with data that you want to share
        between multiple instances, detach it from any read-write instances and
        attach it to one or more instances in read-only mode.
        """
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mode", value)


@pulumi.input_type
class InstanceBootDiskArgs:
    def __init__(__self__, *,
                 auto_delete: Optional[pulumi.Input[bool]] = None,
                 device_name: Optional[pulumi.Input[str]] = None,
                 disk_encryption_key_raw: Optional[pulumi.Input[str]] = None,
                 disk_encryption_key_sha256: Optional[pulumi.Input[str]] = None,
                 initialize_params: Optional[pulumi.Input['InstanceBootDiskInitializeParamsArgs']] = None,
                 kms_key_self_link: Optional[pulumi.Input[str]] = None,
                 mode: Optional[pulumi.Input[str]] = None,
                 source: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] auto_delete: Whether the disk will be auto-deleted when the instance
               is deleted. Defaults to true.
        :param pulumi.Input[str] device_name: Name with which the attached disk will be accessible
               under `/dev/disk/by-id/google-*`
        :param pulumi.Input[str] disk_encryption_key_raw: A 256-bit [customer-supplied encryption key]
               (<https://cloud.google.com/compute/docs/disks/customer-supplied-encryption>),
               encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
               to encrypt this disk. Only one of `kms_key_self_link` and `disk_encryption_key_raw` may be set.
        :param pulumi.Input['InstanceBootDiskInitializeParamsArgs'] initialize_params: Parameters for a new disk that will be created
               alongside the new instance. Either `initialize_params` or `source` must be set.
               Structure is documented below.
        :param pulumi.Input[str] kms_key_self_link: The self_link of the encryption key that is
               stored in Google Cloud KMS to encrypt this disk. Only one of `kms_key_self_link`
               and `disk_encryption_key_raw` may be set.
        :param pulumi.Input[str] mode: Either "READ_ONLY" or "READ_WRITE", defaults to "READ_WRITE"
               If you have a persistent disk with data that you want to share
               between multiple instances, detach it from any read-write instances and
               attach it to one or more instances in read-only mode.
        :param pulumi.Input[str] source: The name or self_link of the disk to attach to this instance.
        """
        if auto_delete is not None:
            pulumi.set(__self__, "auto_delete", auto_delete)
        if device_name is not None:
            pulumi.set(__self__, "device_name", device_name)
        if disk_encryption_key_raw is not None:
            pulumi.set(__self__, "disk_encryption_key_raw", disk_encryption_key_raw)
        if disk_encryption_key_sha256 is not None:
            pulumi.set(__self__, "disk_encryption_key_sha256", disk_encryption_key_sha256)
        if initialize_params is not None:
            pulumi.set(__self__, "initialize_params", initialize_params)
        if kms_key_self_link is not None:
            pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if source is not None:
            pulumi.set(__self__, "source", source)

    @property
    @pulumi.getter(name="autoDelete")
    def auto_delete(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the disk will be auto-deleted when the instance
        is deleted. Defaults to true.
        """
        return pulumi.get(self, "auto_delete")

    @auto_delete.setter
    def auto_delete(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "auto_delete", value)

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> Optional[pulumi.Input[str]]:
        """
        Name with which the attached disk will be accessible
        under `/dev/disk/by-id/google-*`
        """
        return pulumi.get(self, "device_name")

    @device_name.setter
    def device_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "device_name", value)

    @property
    @pulumi.getter(name="diskEncryptionKeyRaw")
    def disk_encryption_key_raw(self) -> Optional[pulumi.Input[str]]:
        """
        A 256-bit [customer-supplied encryption key]
        (<https://cloud.google.com/compute/docs/disks/customer-supplied-encryption>),
        encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
        to encrypt this disk. Only one of `kms_key_self_link` and `disk_encryption_key_raw` may be set.
        """
        return pulumi.get(self, "disk_encryption_key_raw")

    @disk_encryption_key_raw.setter
    def disk_encryption_key_raw(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_encryption_key_raw", value)

    @property
    @pulumi.getter(name="diskEncryptionKeySha256")
    def disk_encryption_key_sha256(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "disk_encryption_key_sha256")

    @disk_encryption_key_sha256.setter
    def disk_encryption_key_sha256(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_encryption_key_sha256", value)

    @property
    @pulumi.getter(name="initializeParams")
    def initialize_params(self) -> Optional[pulumi.Input['InstanceBootDiskInitializeParamsArgs']]:
        """
        Parameters for a new disk that will be created
        alongside the new instance. Either `initialize_params` or `source` must be set.
        Structure is documented below.
        """
        return pulumi.get(self, "initialize_params")

    @initialize_params.setter
    def initialize_params(self, value: Optional[pulumi.Input['InstanceBootDiskInitializeParamsArgs']]):
        pulumi.set(self, "initialize_params", value)

    @property
    @pulumi.getter(name="kmsKeySelfLink")
    def kms_key_self_link(self) -> Optional[pulumi.Input[str]]:
        """
        The self_link of the encryption key that is
        stored in Google Cloud KMS to encrypt this disk. Only one of `kms_key_self_link`
        and `disk_encryption_key_raw` may be set.
        """
        return pulumi.get(self, "kms_key_self_link")

    @kms_key_self_link.setter
    def kms_key_self_link(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_self_link", value)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[str]]:
        """
        Either "READ_ONLY" or "READ_WRITE", defaults to "READ_WRITE"
        If you have a persistent disk with data that you want to share
        between multiple instances, detach it from any read-write instances and
        attach it to one or more instances in read-only mode.
        """
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mode", value)

    @property
    @pulumi.getter
    def source(self) -> Optional[pulumi.Input[str]]:
        """
        The name or self_link of the disk to attach to this instance.
        """
        return pulumi.get(self, "source")

    @source.setter
    def source(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "source", value)


@pulumi.input_type
class InstanceBootDiskInitializeParamsArgs:
    def __init__(__self__, *,
                 image: Optional[pulumi.Input[str]] = None,
                 labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 size: Optional[pulumi.Input[int]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] image: The image from which to initialize this disk. This can be
               one of: the image's `self_link`, `projects/{project}/global/images/{image}`,
               `projects/{project}/global/images/family/{family}`, `global/images/{image}`,
               `global/images/family/{family}`, `family/{family}`, `{project}/{family}`,
               `{project}/{image}`, `{family}`, or `{image}`. If referred by family, the
               images names must include the family name. If they don't, use the
               [compute.Image data source](https://www.terraform.io/docs/providers/google/d/compute_image.html).
               For instance, the image `centos-6-v20180104` includes its family name `centos-6`.
               These images can be referred by family name here.
        :param pulumi.Input[Mapping[str, Any]] labels: A map of key/value label pairs to assign to the instance.
        :param pulumi.Input[int] size: The size of the image in gigabytes. If not specified, it
               will inherit the size of its base image.
        :param pulumi.Input[str] type: The type of reservation from which this instance can consume resources.
        """
        if image is not None:
            pulumi.set(__self__, "image", image)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        """
        The image from which to initialize this disk. This can be
        one of: the image's `self_link`, `projects/{project}/global/images/{image}`,
        `projects/{project}/global/images/family/{family}`, `global/images/{image}`,
        `global/images/family/{family}`, `family/{family}`, `{project}/{family}`,
        `{project}/{image}`, `{family}`, or `{image}`. If referred by family, the
        images names must include the family name. If they don't, use the
        [compute.Image data source](https://www.terraform.io/docs/providers/google/d/compute_image.html).
        For instance, the image `centos-6-v20180104` includes its family name `centos-6`.
        These images can be referred by family name here.
        """
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter
    def labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        A map of key/value label pairs to assign to the instance.
        """
        return pulumi.get(self, "labels")

    @labels.setter
    def labels(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "labels", value)

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[int]]:
        """
        The size of the image in gigabytes. If not specified, it
        will inherit the size of its base image.
        """
        return pulumi.get(self, "size")

    @size.setter
    def size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "size", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        The type of reservation from which this instance can consume resources.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class InstanceConfidentialInstanceConfigArgs:
    def __init__(__self__, *,
                 enable_confidential_compute: pulumi.Input[bool]):
        """
        :param pulumi.Input[bool] enable_confidential_compute: Defines whether the instance should have confidential compute enabled. `on_host_maintenance` has to be set to TERMINATE or this will fail to create the VM.
        """
        pulumi.set(__self__, "enable_confidential_compute", enable_confidential_compute)

    @property
    @pulumi.getter(name="enableConfidentialCompute")
    def enable_confidential_compute(self) -> pulumi.Input[bool]:
        """
        Defines whether the instance should have confidential compute enabled. `on_host_maintenance` has to be set to TERMINATE or this will fail to create the VM.
        """
        return pulumi.get(self, "enable_confidential_compute")

    @enable_confidential_compute.setter
    def enable_confidential_compute(self, value: pulumi.Input[bool]):
        pulumi.set(self, "enable_confidential_compute", value)


@pulumi.input_type
class InstanceFromMachineImageAdvancedMachineFeaturesArgs:
    def __init__(__self__, *,
                 enable_nested_virtualization: Optional[pulumi.Input[bool]] = None,
                 threads_per_core: Optional[pulumi.Input[int]] = None):
        if enable_nested_virtualization is not None:
            pulumi.set(__self__, "enable_nested_virtualization", enable_nested_virtualization)
        if threads_per_core is not None:
            pulumi.set(__self__, "threads_per_core", threads_per_core)

    @property
    @pulumi.getter(name="enableNestedVirtualization")
    def enable_nested_virtualization(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "enable_nested_virtualization")

    @enable_nested_virtualization.setter
    def enable_nested_virtualization(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_nested_virtualization", value)

    @property
    @pulumi.getter(name="threadsPerCore")
    def threads_per_core(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "threads_per_core")

    @threads_per_core.setter
    def threads_per_core(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "threads_per_core", value)


@pulumi.input_type
class InstanceFromMachineImageAttachedDiskArgs:
    def __init__(__self__, *,
                 source: pulumi.Input[str],
                 device_name: Optional[pulumi.Input[str]] = None,
                 disk_encryption_key_raw: Optional[pulumi.Input[str]] = None,
                 disk_encryption_key_sha256: Optional[pulumi.Input[str]] = None,
                 kms_key_self_link: Optional[pulumi.Input[str]] = None,
                 mode: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "source", source)
        if device_name is not None:
            pulumi.set(__self__, "device_name", device_name)
        if disk_encryption_key_raw is not None:
            pulumi.set(__self__, "disk_encryption_key_raw", disk_encryption_key_raw)
        if disk_encryption_key_sha256 is not None:
            pulumi.set(__self__, "disk_encryption_key_sha256", disk_encryption_key_sha256)
        if kms_key_self_link is not None:
            pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter
    def source(self) -> pulumi.Input[str]:
        return pulumi.get(self, "source")

    @source.setter
    def source(self, value: pulumi.Input[str]):
        pulumi.set(self, "source", value)

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "device_name")

    @device_name.setter
    def device_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "device_name", value)

    @property
    @pulumi.getter(name="diskEncryptionKeyRaw")
    def disk_encryption_key_raw(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "disk_encryption_key_raw")

    @disk_encryption_key_raw.setter
    def disk_encryption_key_raw(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_encryption_key_raw", value)

    @property
    @pulumi.getter(name="diskEncryptionKeySha256")
    def disk_encryption_key_sha256(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "disk_encryption_key_sha256")

    @disk_encryption_key_sha256.setter
    def disk_encryption_key_sha256(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_encryption_key_sha256", value)

    @property
    @pulumi.getter(name="kmsKeySelfLink")
    def kms_key_self_link(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "kms_key_self_link")

    @kms_key_self_link.setter
    def kms_key_self_link(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_self_link", value)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mode", value)


@pulumi.input_type
class InstanceFromMachineImageBootDiskArgs:
    def __init__(__self__, *,
                 auto_delete: Optional[pulumi.Input[bool]] = None,
                 device_name: Optional[pulumi.Input[str]] = None,
                 disk_encryption_key_raw: Optional[pulumi.Input[str]] = None,
                 disk_encryption_key_sha256: Optional[pulumi.Input[str]] = None,
                 initialize_params: Optional[pulumi.Input['InstanceFromMachineImageBootDiskInitializeParamsArgs']] = None,
                 kms_key_self_link: Optional[pulumi.Input[str]] = None,
                 mode: Optional[pulumi.Input[str]] = None,
                 source: Optional[pulumi.Input[str]] = None):
        if auto_delete is not None:
            pulumi.set(__self__, "auto_delete", auto_delete)
        if device_name is not None:
            pulumi.set(__self__, "device_name", device_name)
        if disk_encryption_key_raw is not None:
            pulumi.set(__self__, "disk_encryption_key_raw", disk_encryption_key_raw)
        if disk_encryption_key_sha256 is not None:
            pulumi.set(__self__, "disk_encryption_key_sha256", disk_encryption_key_sha256)
        if initialize_params is not None:
            pulumi.set(__self__, "initialize_params", initialize_params)
        if kms_key_self_link is not None:
            pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if source is not None:
            pulumi.set(__self__, "source", source)

    @property
    @pulumi.getter(name="autoDelete")
    def auto_delete(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "auto_delete")

    @auto_delete.setter
    def auto_delete(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "auto_delete", value)

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "device_name")

    @device_name.setter
    def device_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "device_name", value)

    @property
    @pulumi.getter(name="diskEncryptionKeyRaw")
    def disk_encryption_key_raw(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "disk_encryption_key_raw")

    @disk_encryption_key_raw.setter
    def disk_encryption_key_raw(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_encryption_key_raw", value)

    @property
    @pulumi.getter(name="diskEncryptionKeySha256")
    def disk_encryption_key_sha256(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "disk_encryption_key_sha256")

    @disk_encryption_key_sha256.setter
    def disk_encryption_key_sha256(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_encryption_key_sha256", value)

    @property
    @pulumi.getter(name="initializeParams")
    def initialize_params(self) -> Optional[pulumi.Input['InstanceFromMachineImageBootDiskInitializeParamsArgs']]:
        return pulumi.get(self, "initialize_params")

    @initialize_params.setter
    def initialize_params(self, value: Optional[pulumi.Input['InstanceFromMachineImageBootDiskInitializeParamsArgs']]):
        pulumi.set(self, "initialize_params", value)

    @property
    @pulumi.getter(name="kmsKeySelfLink")
    def kms_key_self_link(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "kms_key_self_link")

    @kms_key_self_link.setter
    def kms_key_self_link(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_self_link", value)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mode", value)

    @property
    @pulumi.getter
    def source(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "source")

    @source.setter
    def source(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "source", value)


@pulumi.input_type
class InstanceFromMachineImageBootDiskInitializeParamsArgs:
    def __init__(__self__, *,
                 image: Optional[pulumi.Input[str]] = None,
                 labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 size: Optional[pulumi.Input[int]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        if image is not None:
            pulumi.set(__self__, "image", image)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter
    def labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "labels")

    @labels.setter
    def labels(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "labels", value)

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "size")

    @size.setter
    def size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "size", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class InstanceFromMachineImageConfidentialInstanceConfigArgs:
    def __init__(__self__, *,
                 enable_confidential_compute: pulumi.Input[bool]):
        pulumi.set(__self__, "enable_confidential_compute", enable_confidential_compute)

    @property
    @pulumi.getter(name="enableConfidentialCompute")
    def enable_confidential_compute(self) -> pulumi.Input[bool]:
        return pulumi.get(self, "enable_confidential_compute")

    @enable_confidential_compute.setter
    def enable_confidential_compute(self, value: pulumi.Input[bool]):
        pulumi.set(self, "enable_confidential_compute", value)


@pulumi.input_type
class InstanceFromMachineImageGuestAcceleratorArgs:
    def __init__(__self__, *,
                 count: pulumi.Input[int],
                 type: pulumi.Input[str]):
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def count(self) -> pulumi.Input[int]:
        return pulumi.get(self, "count")

    @count.setter
    def count(self, value: pulumi.Input[int]):
        pulumi.set(self, "count", value)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class InstanceFromMachineImageNetworkInterfaceArgs:
    def __init__(__self__, *,
                 access_configs: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromMachineImageNetworkInterfaceAccessConfigArgs']]]] = None,
                 alias_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromMachineImageNetworkInterfaceAliasIpRangeArgs']]]] = None,
                 ipv6_access_configs: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromMachineImageNetworkInterfaceIpv6AccessConfigArgs']]]] = None,
                 ipv6_access_type: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 network: Optional[pulumi.Input[str]] = None,
                 network_ip: Optional[pulumi.Input[str]] = None,
                 nic_type: Optional[pulumi.Input[str]] = None,
                 queue_count: Optional[pulumi.Input[int]] = None,
                 stack_type: Optional[pulumi.Input[str]] = None,
                 subnetwork: Optional[pulumi.Input[str]] = None,
                 subnetwork_project: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: A unique name for the resource, required by GCE.
               Changing this forces a new resource to be created.
        """
        if access_configs is not None:
            pulumi.set(__self__, "access_configs", access_configs)
        if alias_ip_ranges is not None:
            pulumi.set(__self__, "alias_ip_ranges", alias_ip_ranges)
        if ipv6_access_configs is not None:
            pulumi.set(__self__, "ipv6_access_configs", ipv6_access_configs)
        if ipv6_access_type is not None:
            pulumi.set(__self__, "ipv6_access_type", ipv6_access_type)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if network is not None:
            pulumi.set(__self__, "network", network)
        if network_ip is not None:
            pulumi.set(__self__, "network_ip", network_ip)
        if nic_type is not None:
            pulumi.set(__self__, "nic_type", nic_type)
        if queue_count is not None:
            pulumi.set(__self__, "queue_count", queue_count)
        if stack_type is not None:
            pulumi.set(__self__, "stack_type", stack_type)
        if subnetwork is not None:
            pulumi.set(__self__, "subnetwork", subnetwork)
        if subnetwork_project is not None:
            pulumi.set(__self__, "subnetwork_project", subnetwork_project)

    @property
    @pulumi.getter(name="accessConfigs")
    def access_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromMachineImageNetworkInterfaceAccessConfigArgs']]]]:
        return pulumi.get(self, "access_configs")

    @access_configs.setter
    def access_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromMachineImageNetworkInterfaceAccessConfigArgs']]]]):
        pulumi.set(self, "access_configs", value)

    @property
    @pulumi.getter(name="aliasIpRanges")
    def alias_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromMachineImageNetworkInterfaceAliasIpRangeArgs']]]]:
        return pulumi.get(self, "alias_ip_ranges")

    @alias_ip_ranges.setter
    def alias_ip_ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromMachineImageNetworkInterfaceAliasIpRangeArgs']]]]):
        pulumi.set(self, "alias_ip_ranges", value)

    @property
    @pulumi.getter(name="ipv6AccessConfigs")
    def ipv6_access_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromMachineImageNetworkInterfaceIpv6AccessConfigArgs']]]]:
        return pulumi.get(self, "ipv6_access_configs")

    @ipv6_access_configs.setter
    def ipv6_access_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromMachineImageNetworkInterfaceIpv6AccessConfigArgs']]]]):
        pulumi.set(self, "ipv6_access_configs", value)

    @property
    @pulumi.getter(name="ipv6AccessType")
    def ipv6_access_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ipv6_access_type")

    @ipv6_access_type.setter
    def ipv6_access_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ipv6_access_type", value)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        A unique name for the resource, required by GCE.
        Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def network(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network", value)

    @property
    @pulumi.getter(name="networkIp")
    def network_ip(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "network_ip")

    @network_ip.setter
    def network_ip(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_ip", value)

    @property
    @pulumi.getter(name="nicType")
    def nic_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "nic_type")

    @nic_type.setter
    def nic_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "nic_type", value)

    @property
    @pulumi.getter(name="queueCount")
    def queue_count(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "queue_count")

    @queue_count.setter
    def queue_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "queue_count", value)

    @property
    @pulumi.getter(name="stackType")
    def stack_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "stack_type")

    @stack_type.setter
    def stack_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "stack_type", value)

    @property
    @pulumi.getter
    def subnetwork(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "subnetwork")

    @subnetwork.setter
    def subnetwork(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnetwork", value)

    @property
    @pulumi.getter(name="subnetworkProject")
    def subnetwork_project(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "subnetwork_project")

    @subnetwork_project.setter
    def subnetwork_project(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnetwork_project", value)


@pulumi.input_type
class InstanceFromMachineImageNetworkInterfaceAccessConfigArgs:
    def __init__(__self__, *,
                 nat_ip: Optional[pulumi.Input[str]] = None,
                 network_tier: Optional[pulumi.Input[str]] = None,
                 public_ptr_domain_name: Optional[pulumi.Input[str]] = None):
        if nat_ip is not None:
            pulumi.set(__self__, "nat_ip", nat_ip)
        if network_tier is not None:
            pulumi.set(__self__, "network_tier", network_tier)
        if public_ptr_domain_name is not None:
            pulumi.set(__self__, "public_ptr_domain_name", public_ptr_domain_name)

    @property
    @pulumi.getter(name="natIp")
    def nat_ip(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "nat_ip")

    @nat_ip.setter
    def nat_ip(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "nat_ip", value)

    @property
    @pulumi.getter(name="networkTier")
    def network_tier(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "network_tier")

    @network_tier.setter
    def network_tier(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_tier", value)

    @property
    @pulumi.getter(name="publicPtrDomainName")
    def public_ptr_domain_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "public_ptr_domain_name")

    @public_ptr_domain_name.setter
    def public_ptr_domain_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "public_ptr_domain_name", value)


@pulumi.input_type
class InstanceFromMachineImageNetworkInterfaceAliasIpRangeArgs:
    def __init__(__self__, *,
                 ip_cidr_range: pulumi.Input[str],
                 subnetwork_range_name: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "ip_cidr_range", ip_cidr_range)
        if subnetwork_range_name is not None:
            pulumi.set(__self__, "subnetwork_range_name", subnetwork_range_name)

    @property
    @pulumi.getter(name="ipCidrRange")
    def ip_cidr_range(self) -> pulumi.Input[str]:
        return pulumi.get(self, "ip_cidr_range")

    @ip_cidr_range.setter
    def ip_cidr_range(self, value: pulumi.Input[str]):
        pulumi.set(self, "ip_cidr_range", value)

    @property
    @pulumi.getter(name="subnetworkRangeName")
    def subnetwork_range_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "subnetwork_range_name")

    @subnetwork_range_name.setter
    def subnetwork_range_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnetwork_range_name", value)


@pulumi.input_type
class InstanceFromMachineImageNetworkInterfaceIpv6AccessConfigArgs:
    def __init__(__self__, *,
                 network_tier: pulumi.Input[str],
                 external_ipv6: Optional[pulumi.Input[str]] = None,
                 external_ipv6_prefix_length: Optional[pulumi.Input[str]] = None,
                 public_ptr_domain_name: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "network_tier", network_tier)
        if external_ipv6 is not None:
            pulumi.set(__self__, "external_ipv6", external_ipv6)
        if external_ipv6_prefix_length is not None:
            pulumi.set(__self__, "external_ipv6_prefix_length", external_ipv6_prefix_length)
        if public_ptr_domain_name is not None:
            pulumi.set(__self__, "public_ptr_domain_name", public_ptr_domain_name)

    @property
    @pulumi.getter(name="networkTier")
    def network_tier(self) -> pulumi.Input[str]:
        return pulumi.get(self, "network_tier")

    @network_tier.setter
    def network_tier(self, value: pulumi.Input[str]):
        pulumi.set(self, "network_tier", value)

    @property
    @pulumi.getter(name="externalIpv6")
    def external_ipv6(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "external_ipv6")

    @external_ipv6.setter
    def external_ipv6(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "external_ipv6", value)

    @property
    @pulumi.getter(name="externalIpv6PrefixLength")
    def external_ipv6_prefix_length(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "external_ipv6_prefix_length")

    @external_ipv6_prefix_length.setter
    def external_ipv6_prefix_length(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "external_ipv6_prefix_length", value)

    @property
    @pulumi.getter(name="publicPtrDomainName")
    def public_ptr_domain_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "public_ptr_domain_name")

    @public_ptr_domain_name.setter
    def public_ptr_domain_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "public_ptr_domain_name", value)


@pulumi.input_type
class InstanceFromMachineImageNetworkPerformanceConfigArgs:
    def __init__(__self__, *,
                 total_egress_bandwidth_tier: pulumi.Input[str]):
        pulumi.set(__self__, "total_egress_bandwidth_tier", total_egress_bandwidth_tier)

    @property
    @pulumi.getter(name="totalEgressBandwidthTier")
    def total_egress_bandwidth_tier(self) -> pulumi.Input[str]:
        return pulumi.get(self, "total_egress_bandwidth_tier")

    @total_egress_bandwidth_tier.setter
    def total_egress_bandwidth_tier(self, value: pulumi.Input[str]):
        pulumi.set(self, "total_egress_bandwidth_tier", value)


@pulumi.input_type
class InstanceFromMachineImageReservationAffinityArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str],
                 specific_reservation: Optional[pulumi.Input['InstanceFromMachineImageReservationAffinitySpecificReservationArgs']] = None):
        pulumi.set(__self__, "type", type)
        if specific_reservation is not None:
            pulumi.set(__self__, "specific_reservation", specific_reservation)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter(name="specificReservation")
    def specific_reservation(self) -> Optional[pulumi.Input['InstanceFromMachineImageReservationAffinitySpecificReservationArgs']]:
        return pulumi.get(self, "specific_reservation")

    @specific_reservation.setter
    def specific_reservation(self, value: Optional[pulumi.Input['InstanceFromMachineImageReservationAffinitySpecificReservationArgs']]):
        pulumi.set(self, "specific_reservation", value)


@pulumi.input_type
class InstanceFromMachineImageReservationAffinitySpecificReservationArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 values: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def values(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class InstanceFromMachineImageSchedulingArgs:
    def __init__(__self__, *,
                 automatic_restart: Optional[pulumi.Input[bool]] = None,
                 instance_termination_action: Optional[pulumi.Input[str]] = None,
                 min_node_cpus: Optional[pulumi.Input[int]] = None,
                 node_affinities: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromMachineImageSchedulingNodeAffinityArgs']]]] = None,
                 on_host_maintenance: Optional[pulumi.Input[str]] = None,
                 preemptible: Optional[pulumi.Input[bool]] = None,
                 provisioning_model: Optional[pulumi.Input[str]] = None):
        if automatic_restart is not None:
            pulumi.set(__self__, "automatic_restart", automatic_restart)
        if instance_termination_action is not None:
            pulumi.set(__self__, "instance_termination_action", instance_termination_action)
        if min_node_cpus is not None:
            pulumi.set(__self__, "min_node_cpus", min_node_cpus)
        if node_affinities is not None:
            pulumi.set(__self__, "node_affinities", node_affinities)
        if on_host_maintenance is not None:
            pulumi.set(__self__, "on_host_maintenance", on_host_maintenance)
        if preemptible is not None:
            pulumi.set(__self__, "preemptible", preemptible)
        if provisioning_model is not None:
            pulumi.set(__self__, "provisioning_model", provisioning_model)

    @property
    @pulumi.getter(name="automaticRestart")
    def automatic_restart(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "automatic_restart")

    @automatic_restart.setter
    def automatic_restart(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "automatic_restart", value)

    @property
    @pulumi.getter(name="instanceTerminationAction")
    def instance_termination_action(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "instance_termination_action")

    @instance_termination_action.setter
    def instance_termination_action(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "instance_termination_action", value)

    @property
    @pulumi.getter(name="minNodeCpus")
    def min_node_cpus(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "min_node_cpus")

    @min_node_cpus.setter
    def min_node_cpus(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_node_cpus", value)

    @property
    @pulumi.getter(name="nodeAffinities")
    def node_affinities(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromMachineImageSchedulingNodeAffinityArgs']]]]:
        return pulumi.get(self, "node_affinities")

    @node_affinities.setter
    def node_affinities(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromMachineImageSchedulingNodeAffinityArgs']]]]):
        pulumi.set(self, "node_affinities", value)

    @property
    @pulumi.getter(name="onHostMaintenance")
    def on_host_maintenance(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "on_host_maintenance")

    @on_host_maintenance.setter
    def on_host_maintenance(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "on_host_maintenance", value)

    @property
    @pulumi.getter
    def preemptible(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "preemptible")

    @preemptible.setter
    def preemptible(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "preemptible", value)

    @property
    @pulumi.getter(name="provisioningModel")
    def provisioning_model(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "provisioning_model")

    @provisioning_model.setter
    def provisioning_model(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "provisioning_model", value)


@pulumi.input_type
class InstanceFromMachineImageSchedulingNodeAffinityArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 operator: pulumi.Input[str],
                 values: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def operator(self) -> pulumi.Input[str]:
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: pulumi.Input[str]):
        pulumi.set(self, "operator", value)

    @property
    @pulumi.getter
    def values(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class InstanceFromMachineImageScratchDiskArgs:
    def __init__(__self__, *,
                 interface: pulumi.Input[str]):
        pulumi.set(__self__, "interface", interface)

    @property
    @pulumi.getter
    def interface(self) -> pulumi.Input[str]:
        return pulumi.get(self, "interface")

    @interface.setter
    def interface(self, value: pulumi.Input[str]):
        pulumi.set(self, "interface", value)


@pulumi.input_type
class InstanceFromMachineImageServiceAccountArgs:
    def __init__(__self__, *,
                 scopes: pulumi.Input[Sequence[pulumi.Input[str]]],
                 email: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "scopes", scopes)
        if email is not None:
            pulumi.set(__self__, "email", email)

    @property
    @pulumi.getter
    def scopes(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "scopes")

    @scopes.setter
    def scopes(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "scopes", value)

    @property
    @pulumi.getter
    def email(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "email")

    @email.setter
    def email(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "email", value)


@pulumi.input_type
class InstanceFromMachineImageShieldedInstanceConfigArgs:
    def __init__(__self__, *,
                 enable_integrity_monitoring: Optional[pulumi.Input[bool]] = None,
                 enable_secure_boot: Optional[pulumi.Input[bool]] = None,
                 enable_vtpm: Optional[pulumi.Input[bool]] = None):
        if enable_integrity_monitoring is not None:
            pulumi.set(__self__, "enable_integrity_monitoring", enable_integrity_monitoring)
        if enable_secure_boot is not None:
            pulumi.set(__self__, "enable_secure_boot", enable_secure_boot)
        if enable_vtpm is not None:
            pulumi.set(__self__, "enable_vtpm", enable_vtpm)

    @property
    @pulumi.getter(name="enableIntegrityMonitoring")
    def enable_integrity_monitoring(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "enable_integrity_monitoring")

    @enable_integrity_monitoring.setter
    def enable_integrity_monitoring(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_integrity_monitoring", value)

    @property
    @pulumi.getter(name="enableSecureBoot")
    def enable_secure_boot(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "enable_secure_boot")

    @enable_secure_boot.setter
    def enable_secure_boot(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_secure_boot", value)

    @property
    @pulumi.getter(name="enableVtpm")
    def enable_vtpm(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "enable_vtpm")

    @enable_vtpm.setter
    def enable_vtpm(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_vtpm", value)


@pulumi.input_type
class InstanceFromTemplateAdvancedMachineFeaturesArgs:
    def __init__(__self__, *,
                 enable_nested_virtualization: Optional[pulumi.Input[bool]] = None,
                 threads_per_core: Optional[pulumi.Input[int]] = None):
        if enable_nested_virtualization is not None:
            pulumi.set(__self__, "enable_nested_virtualization", enable_nested_virtualization)
        if threads_per_core is not None:
            pulumi.set(__self__, "threads_per_core", threads_per_core)

    @property
    @pulumi.getter(name="enableNestedVirtualization")
    def enable_nested_virtualization(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "enable_nested_virtualization")

    @enable_nested_virtualization.setter
    def enable_nested_virtualization(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_nested_virtualization", value)

    @property
    @pulumi.getter(name="threadsPerCore")
    def threads_per_core(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "threads_per_core")

    @threads_per_core.setter
    def threads_per_core(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "threads_per_core", value)


@pulumi.input_type
class InstanceFromTemplateAttachedDiskArgs:
    def __init__(__self__, *,
                 source: pulumi.Input[str],
                 device_name: Optional[pulumi.Input[str]] = None,
                 disk_encryption_key_raw: Optional[pulumi.Input[str]] = None,
                 disk_encryption_key_sha256: Optional[pulumi.Input[str]] = None,
                 kms_key_self_link: Optional[pulumi.Input[str]] = None,
                 mode: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "source", source)
        if device_name is not None:
            pulumi.set(__self__, "device_name", device_name)
        if disk_encryption_key_raw is not None:
            pulumi.set(__self__, "disk_encryption_key_raw", disk_encryption_key_raw)
        if disk_encryption_key_sha256 is not None:
            pulumi.set(__self__, "disk_encryption_key_sha256", disk_encryption_key_sha256)
        if kms_key_self_link is not None:
            pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter
    def source(self) -> pulumi.Input[str]:
        return pulumi.get(self, "source")

    @source.setter
    def source(self, value: pulumi.Input[str]):
        pulumi.set(self, "source", value)

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "device_name")

    @device_name.setter
    def device_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "device_name", value)

    @property
    @pulumi.getter(name="diskEncryptionKeyRaw")
    def disk_encryption_key_raw(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "disk_encryption_key_raw")

    @disk_encryption_key_raw.setter
    def disk_encryption_key_raw(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_encryption_key_raw", value)

    @property
    @pulumi.getter(name="diskEncryptionKeySha256")
    def disk_encryption_key_sha256(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "disk_encryption_key_sha256")

    @disk_encryption_key_sha256.setter
    def disk_encryption_key_sha256(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_encryption_key_sha256", value)

    @property
    @pulumi.getter(name="kmsKeySelfLink")
    def kms_key_self_link(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "kms_key_self_link")

    @kms_key_self_link.setter
    def kms_key_self_link(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_self_link", value)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mode", value)


@pulumi.input_type
class InstanceFromTemplateBootDiskArgs:
    def __init__(__self__, *,
                 auto_delete: Optional[pulumi.Input[bool]] = None,
                 device_name: Optional[pulumi.Input[str]] = None,
                 disk_encryption_key_raw: Optional[pulumi.Input[str]] = None,
                 disk_encryption_key_sha256: Optional[pulumi.Input[str]] = None,
                 initialize_params: Optional[pulumi.Input['InstanceFromTemplateBootDiskInitializeParamsArgs']] = None,
                 kms_key_self_link: Optional[pulumi.Input[str]] = None,
                 mode: Optional[pulumi.Input[str]] = None,
                 source: Optional[pulumi.Input[str]] = None):
        if auto_delete is not None:
            pulumi.set(__self__, "auto_delete", auto_delete)
        if device_name is not None:
            pulumi.set(__self__, "device_name", device_name)
        if disk_encryption_key_raw is not None:
            pulumi.set(__self__, "disk_encryption_key_raw", disk_encryption_key_raw)
        if disk_encryption_key_sha256 is not None:
            pulumi.set(__self__, "disk_encryption_key_sha256", disk_encryption_key_sha256)
        if initialize_params is not None:
            pulumi.set(__self__, "initialize_params", initialize_params)
        if kms_key_self_link is not None:
            pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if source is not None:
            pulumi.set(__self__, "source", source)

    @property
    @pulumi.getter(name="autoDelete")
    def auto_delete(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "auto_delete")

    @auto_delete.setter
    def auto_delete(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "auto_delete", value)

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "device_name")

    @device_name.setter
    def device_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "device_name", value)

    @property
    @pulumi.getter(name="diskEncryptionKeyRaw")
    def disk_encryption_key_raw(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "disk_encryption_key_raw")

    @disk_encryption_key_raw.setter
    def disk_encryption_key_raw(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_encryption_key_raw", value)

    @property
    @pulumi.getter(name="diskEncryptionKeySha256")
    def disk_encryption_key_sha256(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "disk_encryption_key_sha256")

    @disk_encryption_key_sha256.setter
    def disk_encryption_key_sha256(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_encryption_key_sha256", value)

    @property
    @pulumi.getter(name="initializeParams")
    def initialize_params(self) -> Optional[pulumi.Input['InstanceFromTemplateBootDiskInitializeParamsArgs']]:
        return pulumi.get(self, "initialize_params")

    @initialize_params.setter
    def initialize_params(self, value: Optional[pulumi.Input['InstanceFromTemplateBootDiskInitializeParamsArgs']]):
        pulumi.set(self, "initialize_params", value)

    @property
    @pulumi.getter(name="kmsKeySelfLink")
    def kms_key_self_link(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "kms_key_self_link")

    @kms_key_self_link.setter
    def kms_key_self_link(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_self_link", value)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mode", value)

    @property
    @pulumi.getter
    def source(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "source")

    @source.setter
    def source(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "source", value)


@pulumi.input_type
class InstanceFromTemplateBootDiskInitializeParamsArgs:
    def __init__(__self__, *,
                 image: Optional[pulumi.Input[str]] = None,
                 labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 size: Optional[pulumi.Input[int]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        if image is not None:
            pulumi.set(__self__, "image", image)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter
    def labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "labels")

    @labels.setter
    def labels(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "labels", value)

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "size")

    @size.setter
    def size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "size", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class InstanceFromTemplateConfidentialInstanceConfigArgs:
    def __init__(__self__, *,
                 enable_confidential_compute: pulumi.Input[bool]):
        pulumi.set(__self__, "enable_confidential_compute", enable_confidential_compute)

    @property
    @pulumi.getter(name="enableConfidentialCompute")
    def enable_confidential_compute(self) -> pulumi.Input[bool]:
        return pulumi.get(self, "enable_confidential_compute")

    @enable_confidential_compute.setter
    def enable_confidential_compute(self, value: pulumi.Input[bool]):
        pulumi.set(self, "enable_confidential_compute", value)


@pulumi.input_type
class InstanceFromTemplateGuestAcceleratorArgs:
    def __init__(__self__, *,
                 count: pulumi.Input[int],
                 type: pulumi.Input[str]):
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def count(self) -> pulumi.Input[int]:
        return pulumi.get(self, "count")

    @count.setter
    def count(self, value: pulumi.Input[int]):
        pulumi.set(self, "count", value)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class InstanceFromTemplateNetworkInterfaceArgs:
    def __init__(__self__, *,
                 access_configs: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromTemplateNetworkInterfaceAccessConfigArgs']]]] = None,
                 alias_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromTemplateNetworkInterfaceAliasIpRangeArgs']]]] = None,
                 ipv6_access_configs: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromTemplateNetworkInterfaceIpv6AccessConfigArgs']]]] = None,
                 ipv6_access_type: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 network: Optional[pulumi.Input[str]] = None,
                 network_ip: Optional[pulumi.Input[str]] = None,
                 nic_type: Optional[pulumi.Input[str]] = None,
                 queue_count: Optional[pulumi.Input[int]] = None,
                 stack_type: Optional[pulumi.Input[str]] = None,
                 subnetwork: Optional[pulumi.Input[str]] = None,
                 subnetwork_project: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: A unique name for the resource, required by GCE.
               Changing this forces a new resource to be created.
        """
        if access_configs is not None:
            pulumi.set(__self__, "access_configs", access_configs)
        if alias_ip_ranges is not None:
            pulumi.set(__self__, "alias_ip_ranges", alias_ip_ranges)
        if ipv6_access_configs is not None:
            pulumi.set(__self__, "ipv6_access_configs", ipv6_access_configs)
        if ipv6_access_type is not None:
            pulumi.set(__self__, "ipv6_access_type", ipv6_access_type)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if network is not None:
            pulumi.set(__self__, "network", network)
        if network_ip is not None:
            pulumi.set(__self__, "network_ip", network_ip)
        if nic_type is not None:
            pulumi.set(__self__, "nic_type", nic_type)
        if queue_count is not None:
            pulumi.set(__self__, "queue_count", queue_count)
        if stack_type is not None:
            pulumi.set(__self__, "stack_type", stack_type)
        if subnetwork is not None:
            pulumi.set(__self__, "subnetwork", subnetwork)
        if subnetwork_project is not None:
            pulumi.set(__self__, "subnetwork_project", subnetwork_project)

    @property
    @pulumi.getter(name="accessConfigs")
    def access_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromTemplateNetworkInterfaceAccessConfigArgs']]]]:
        return pulumi.get(self, "access_configs")

    @access_configs.setter
    def access_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromTemplateNetworkInterfaceAccessConfigArgs']]]]):
        pulumi.set(self, "access_configs", value)

    @property
    @pulumi.getter(name="aliasIpRanges")
    def alias_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromTemplateNetworkInterfaceAliasIpRangeArgs']]]]:
        return pulumi.get(self, "alias_ip_ranges")

    @alias_ip_ranges.setter
    def alias_ip_ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromTemplateNetworkInterfaceAliasIpRangeArgs']]]]):
        pulumi.set(self, "alias_ip_ranges", value)

    @property
    @pulumi.getter(name="ipv6AccessConfigs")
    def ipv6_access_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromTemplateNetworkInterfaceIpv6AccessConfigArgs']]]]:
        return pulumi.get(self, "ipv6_access_configs")

    @ipv6_access_configs.setter
    def ipv6_access_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromTemplateNetworkInterfaceIpv6AccessConfigArgs']]]]):
        pulumi.set(self, "ipv6_access_configs", value)

    @property
    @pulumi.getter(name="ipv6AccessType")
    def ipv6_access_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ipv6_access_type")

    @ipv6_access_type.setter
    def ipv6_access_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ipv6_access_type", value)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        A unique name for the resource, required by GCE.
        Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def network(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network", value)

    @property
    @pulumi.getter(name="networkIp")
    def network_ip(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "network_ip")

    @network_ip.setter
    def network_ip(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_ip", value)

    @property
    @pulumi.getter(name="nicType")
    def nic_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "nic_type")

    @nic_type.setter
    def nic_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "nic_type", value)

    @property
    @pulumi.getter(name="queueCount")
    def queue_count(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "queue_count")

    @queue_count.setter
    def queue_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "queue_count", value)

    @property
    @pulumi.getter(name="stackType")
    def stack_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "stack_type")

    @stack_type.setter
    def stack_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "stack_type", value)

    @property
    @pulumi.getter
    def subnetwork(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "subnetwork")

    @subnetwork.setter
    def subnetwork(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnetwork", value)

    @property
    @pulumi.getter(name="subnetworkProject")
    def subnetwork_project(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "subnetwork_project")

    @subnetwork_project.setter
    def subnetwork_project(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnetwork_project", value)


@pulumi.input_type
class InstanceFromTemplateNetworkInterfaceAccessConfigArgs:
    def __init__(__self__, *,
                 nat_ip: Optional[pulumi.Input[str]] = None,
                 network_tier: Optional[pulumi.Input[str]] = None,
                 public_ptr_domain_name: Optional[pulumi.Input[str]] = None):
        if nat_ip is not None:
            pulumi.set(__self__, "nat_ip", nat_ip)
        if network_tier is not None:
            pulumi.set(__self__, "network_tier", network_tier)
        if public_ptr_domain_name is not None:
            pulumi.set(__self__, "public_ptr_domain_name", public_ptr_domain_name)

    @property
    @pulumi.getter(name="natIp")
    def nat_ip(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "nat_ip")

    @nat_ip.setter
    def nat_ip(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "nat_ip", value)

    @property
    @pulumi.getter(name="networkTier")
    def network_tier(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "network_tier")

    @network_tier.setter
    def network_tier(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_tier", value)

    @property
    @pulumi.getter(name="publicPtrDomainName")
    def public_ptr_domain_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "public_ptr_domain_name")

    @public_ptr_domain_name.setter
    def public_ptr_domain_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "public_ptr_domain_name", value)


@pulumi.input_type
class InstanceFromTemplateNetworkInterfaceAliasIpRangeArgs:
    def __init__(__self__, *,
                 ip_cidr_range: pulumi.Input[str],
                 subnetwork_range_name: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "ip_cidr_range", ip_cidr_range)
        if subnetwork_range_name is not None:
            pulumi.set(__self__, "subnetwork_range_name", subnetwork_range_name)

    @property
    @pulumi.getter(name="ipCidrRange")
    def ip_cidr_range(self) -> pulumi.Input[str]:
        return pulumi.get(self, "ip_cidr_range")

    @ip_cidr_range.setter
    def ip_cidr_range(self, value: pulumi.Input[str]):
        pulumi.set(self, "ip_cidr_range", value)

    @property
    @pulumi.getter(name="subnetworkRangeName")
    def subnetwork_range_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "subnetwork_range_name")

    @subnetwork_range_name.setter
    def subnetwork_range_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnetwork_range_name", value)


@pulumi.input_type
class InstanceFromTemplateNetworkInterfaceIpv6AccessConfigArgs:
    def __init__(__self__, *,
                 network_tier: pulumi.Input[str],
                 external_ipv6: Optional[pulumi.Input[str]] = None,
                 external_ipv6_prefix_length: Optional[pulumi.Input[str]] = None,
                 public_ptr_domain_name: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "network_tier", network_tier)
        if external_ipv6 is not None:
            pulumi.set(__self__, "external_ipv6", external_ipv6)
        if external_ipv6_prefix_length is not None:
            pulumi.set(__self__, "external_ipv6_prefix_length", external_ipv6_prefix_length)
        if public_ptr_domain_name is not None:
            pulumi.set(__self__, "public_ptr_domain_name", public_ptr_domain_name)

    @property
    @pulumi.getter(name="networkTier")
    def network_tier(self) -> pulumi.Input[str]:
        return pulumi.get(self, "network_tier")

    @network_tier.setter
    def network_tier(self, value: pulumi.Input[str]):
        pulumi.set(self, "network_tier", value)

    @property
    @pulumi.getter(name="externalIpv6")
    def external_ipv6(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "external_ipv6")

    @external_ipv6.setter
    def external_ipv6(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "external_ipv6", value)

    @property
    @pulumi.getter(name="externalIpv6PrefixLength")
    def external_ipv6_prefix_length(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "external_ipv6_prefix_length")

    @external_ipv6_prefix_length.setter
    def external_ipv6_prefix_length(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "external_ipv6_prefix_length", value)

    @property
    @pulumi.getter(name="publicPtrDomainName")
    def public_ptr_domain_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "public_ptr_domain_name")

    @public_ptr_domain_name.setter
    def public_ptr_domain_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "public_ptr_domain_name", value)


@pulumi.input_type
class InstanceFromTemplateNetworkPerformanceConfigArgs:
    def __init__(__self__, *,
                 total_egress_bandwidth_tier: pulumi.Input[str]):
        pulumi.set(__self__, "total_egress_bandwidth_tier", total_egress_bandwidth_tier)

    @property
    @pulumi.getter(name="totalEgressBandwidthTier")
    def total_egress_bandwidth_tier(self) -> pulumi.Input[str]:
        return pulumi.get(self, "total_egress_bandwidth_tier")

    @total_egress_bandwidth_tier.setter
    def total_egress_bandwidth_tier(self, value: pulumi.Input[str]):
        pulumi.set(self, "total_egress_bandwidth_tier", value)


@pulumi.input_type
class InstanceFromTemplateReservationAffinityArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str],
                 specific_reservation: Optional[pulumi.Input['InstanceFromTemplateReservationAffinitySpecificReservationArgs']] = None):
        pulumi.set(__self__, "type", type)
        if specific_reservation is not None:
            pulumi.set(__self__, "specific_reservation", specific_reservation)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter(name="specificReservation")
    def specific_reservation(self) -> Optional[pulumi.Input['InstanceFromTemplateReservationAffinitySpecificReservationArgs']]:
        return pulumi.get(self, "specific_reservation")

    @specific_reservation.setter
    def specific_reservation(self, value: Optional[pulumi.Input['InstanceFromTemplateReservationAffinitySpecificReservationArgs']]):
        pulumi.set(self, "specific_reservation", value)


@pulumi.input_type
class InstanceFromTemplateReservationAffinitySpecificReservationArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 values: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def values(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class InstanceFromTemplateSchedulingArgs:
    def __init__(__self__, *,
                 automatic_restart: Optional[pulumi.Input[bool]] = None,
                 instance_termination_action: Optional[pulumi.Input[str]] = None,
                 min_node_cpus: Optional[pulumi.Input[int]] = None,
                 node_affinities: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromTemplateSchedulingNodeAffinityArgs']]]] = None,
                 on_host_maintenance: Optional[pulumi.Input[str]] = None,
                 preemptible: Optional[pulumi.Input[bool]] = None,
                 provisioning_model: Optional[pulumi.Input[str]] = None):
        if automatic_restart is not None:
            pulumi.set(__self__, "automatic_restart", automatic_restart)
        if instance_termination_action is not None:
            pulumi.set(__self__, "instance_termination_action", instance_termination_action)
        if min_node_cpus is not None:
            pulumi.set(__self__, "min_node_cpus", min_node_cpus)
        if node_affinities is not None:
            pulumi.set(__self__, "node_affinities", node_affinities)
        if on_host_maintenance is not None:
            pulumi.set(__self__, "on_host_maintenance", on_host_maintenance)
        if preemptible is not None:
            pulumi.set(__self__, "preemptible", preemptible)
        if provisioning_model is not None:
            pulumi.set(__self__, "provisioning_model", provisioning_model)

    @property
    @pulumi.getter(name="automaticRestart")
    def automatic_restart(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "automatic_restart")

    @automatic_restart.setter
    def automatic_restart(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "automatic_restart", value)

    @property
    @pulumi.getter(name="instanceTerminationAction")
    def instance_termination_action(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "instance_termination_action")

    @instance_termination_action.setter
    def instance_termination_action(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "instance_termination_action", value)

    @property
    @pulumi.getter(name="minNodeCpus")
    def min_node_cpus(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "min_node_cpus")

    @min_node_cpus.setter
    def min_node_cpus(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_node_cpus", value)

    @property
    @pulumi.getter(name="nodeAffinities")
    def node_affinities(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromTemplateSchedulingNodeAffinityArgs']]]]:
        return pulumi.get(self, "node_affinities")

    @node_affinities.setter
    def node_affinities(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFromTemplateSchedulingNodeAffinityArgs']]]]):
        pulumi.set(self, "node_affinities", value)

    @property
    @pulumi.getter(name="onHostMaintenance")
    def on_host_maintenance(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "on_host_maintenance")

    @on_host_maintenance.setter
    def on_host_maintenance(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "on_host_maintenance", value)

    @property
    @pulumi.getter
    def preemptible(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "preemptible")

    @preemptible.setter
    def preemptible(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "preemptible", value)

    @property
    @pulumi.getter(name="provisioningModel")
    def provisioning_model(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "provisioning_model")

    @provisioning_model.setter
    def provisioning_model(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "provisioning_model", value)


@pulumi.input_type
class InstanceFromTemplateSchedulingNodeAffinityArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 operator: pulumi.Input[str],
                 values: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def operator(self) -> pulumi.Input[str]:
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: pulumi.Input[str]):
        pulumi.set(self, "operator", value)

    @property
    @pulumi.getter
    def values(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class InstanceFromTemplateScratchDiskArgs:
    def __init__(__self__, *,
                 interface: pulumi.Input[str]):
        pulumi.set(__self__, "interface", interface)

    @property
    @pulumi.getter
    def interface(self) -> pulumi.Input[str]:
        return pulumi.get(self, "interface")

    @interface.setter
    def interface(self, value: pulumi.Input[str]):
        pulumi.set(self, "interface", value)


@pulumi.input_type
class InstanceFromTemplateServiceAccountArgs:
    def __init__(__self__, *,
                 scopes: pulumi.Input[Sequence[pulumi.Input[str]]],
                 email: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "scopes", scopes)
        if email is not None:
            pulumi.set(__self__, "email", email)

    @property
    @pulumi.getter
    def scopes(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "scopes")

    @scopes.setter
    def scopes(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "scopes", value)

    @property
    @pulumi.getter
    def email(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "email")

    @email.setter
    def email(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "email", value)


@pulumi.input_type
class InstanceFromTemplateShieldedInstanceConfigArgs:
    def __init__(__self__, *,
                 enable_integrity_monitoring: Optional[pulumi.Input[bool]] = None,
                 enable_secure_boot: Optional[pulumi.Input[bool]] = None,
                 enable_vtpm: Optional[pulumi.Input[bool]] = None):
        if enable_integrity_monitoring is not None:
            pulumi.set(__self__, "enable_integrity_monitoring", enable_integrity_monitoring)
        if enable_secure_boot is not None:
            pulumi.set(__self__, "enable_secure_boot", enable_secure_boot)
        if enable_vtpm is not None:
            pulumi.set(__self__, "enable_vtpm", enable_vtpm)

    @property
    @pulumi.getter(name="enableIntegrityMonitoring")
    def enable_integrity_monitoring(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "enable_integrity_monitoring")

    @enable_integrity_monitoring.setter
    def enable_integrity_monitoring(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_integrity_monitoring", value)

    @property
    @pulumi.getter(name="enableSecureBoot")
    def enable_secure_boot(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "enable_secure_boot")

    @enable_secure_boot.setter
    def enable_secure_boot(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_secure_boot", value)

    @property
    @pulumi.getter(name="enableVtpm")
    def enable_vtpm(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "enable_vtpm")

    @enable_vtpm.setter
    def enable_vtpm(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_vtpm", value)


@pulumi.input_type
class InstanceGroupManagerAllInstancesConfigArgs:
    def __init__(__self__, *,
                 labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 metadata: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: ), The label key-value pairs that you want to patch onto the instance.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] metadata: ), The metadata key-value pairs that you want to patch onto the instance. For more information, see [Project and instance metadata](https://cloud.google.com/compute/docs/metadata#project_and_instance_metadata).
        """
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if metadata is not None:
            pulumi.set(__self__, "metadata", metadata)

    @property
    @pulumi.getter
    def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        ), The label key-value pairs that you want to patch onto the instance.
        """
        return pulumi.get(self, "labels")

    @labels.setter
    def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "labels", value)

    @property
    @pulumi.getter
    def metadata(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        ), The metadata key-value pairs that you want to patch onto the instance. For more information, see [Project and instance metadata](https://cloud.google.com/compute/docs/metadata#project_and_instance_metadata).
        """
        return pulumi.get(self, "metadata")

    @metadata.setter
    def metadata(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "metadata", value)


@pulumi.input_type
class InstanceGroupManagerAutoHealingPoliciesArgs:
    def __init__(__self__, *,
                 health_check: pulumi.Input[str],
                 initial_delay_sec: pulumi.Input[int]):
        """
        :param pulumi.Input[str] health_check: The health check resource that signals autohealing.
        :param pulumi.Input[int] initial_delay_sec: The number of seconds that the managed instance group waits before
               it applies autohealing policies to new instances or recently recreated instances. Between 0 and 3600.
        """
        pulumi.set(__self__, "health_check", health_check)
        pulumi.set(__self__, "initial_delay_sec", initial_delay_sec)

    @property
    @pulumi.getter(name="healthCheck")
    def health_check(self) -> pulumi.Input[str]:
        """
        The health check resource that signals autohealing.
        """
        return pulumi.get(self, "health_check")

    @health_check.setter
    def health_check(self, value: pulumi.Input[str]):
        pulumi.set(self, "health_check", value)

    @property
    @pulumi.getter(name="initialDelaySec")
    def initial_delay_sec(self) -> pulumi.Input[int]:
        """
        The number of seconds that the managed instance group waits before
        it applies autohealing policies to new instances or recently recreated instances. Between 0 and 3600.
        """
        return pulumi.get(self, "initial_delay_sec")

    @initial_delay_sec.setter
    def initial_delay_sec(self, value: pulumi.Input[int]):
        pulumi.set(self, "initial_delay_sec", value)


@pulumi.input_type
class InstanceGroupManagerNamedPortArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 port: pulumi.Input[int]):
        """
        :param pulumi.Input[str] name: - Version name.
        :param pulumi.Input[int] port: The port number.
               - - -
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        - Version name.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[int]:
        """
        The port number.
        - - -
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: pulumi.Input[int]):
        pulumi.set(self, "port", value)


@pulumi.input_type
class InstanceGroupManagerStatefulDiskArgs:
    def __init__(__self__, *,
                 device_name: pulumi.Input[str],
                 delete_rule: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] device_name: , The device name of the disk to be attached.
        :param pulumi.Input[str] delete_rule: , A value that prescribes what should happen to the stateful disk when the VM instance is deleted. The available options are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`. `NEVER` - detach the disk when the VM is deleted, but do not delete the disk. `ON_PERMANENT_INSTANCE_DELETION` will delete the stateful disk when the VM is permanently deleted from the instance group. The default is `NEVER`.
        """
        pulumi.set(__self__, "device_name", device_name)
        if delete_rule is not None:
            pulumi.set(__self__, "delete_rule", delete_rule)

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> pulumi.Input[str]:
        """
        , The device name of the disk to be attached.
        """
        return pulumi.get(self, "device_name")

    @device_name.setter
    def device_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "device_name", value)

    @property
    @pulumi.getter(name="deleteRule")
    def delete_rule(self) -> Optional[pulumi.Input[str]]:
        """
        , A value that prescribes what should happen to the stateful disk when the VM instance is deleted. The available options are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`. `NEVER` - detach the disk when the VM is deleted, but do not delete the disk. `ON_PERMANENT_INSTANCE_DELETION` will delete the stateful disk when the VM is permanently deleted from the instance group. The default is `NEVER`.
        """
        return pulumi.get(self, "delete_rule")

    @delete_rule.setter
    def delete_rule(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "delete_rule", value)


@pulumi.input_type
class InstanceGroupManagerStatusArgs:
    def __init__(__self__, *,
                 all_instances_configs: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceGroupManagerStatusAllInstancesConfigArgs']]]] = None,
                 is_stable: Optional[pulumi.Input[bool]] = None,
                 statefuls: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceGroupManagerStatusStatefulArgs']]]] = None,
                 version_targets: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceGroupManagerStatusVersionTargetArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['InstanceGroupManagerStatusAllInstancesConfigArgs']]] all_instances_configs: )
               Properties to set on all instances in the group. After setting
               allInstancesConfig on the group, you must update the group's instances to
               apply the configuration.
        :param pulumi.Input[bool] is_stable: A bit indicating whether the managed instance group is in a stable state. A stable state means that: none of the instances in the managed instance group is currently undergoing any type of change (for example, creation, restart, or deletion); no future changes are scheduled for instances in the managed instance group; and the managed instance group itself is not being modified.
        :param pulumi.Input[Sequence[pulumi.Input['InstanceGroupManagerStatusStatefulArgs']]] statefuls: Stateful status of the given Instance Group Manager.
        :param pulumi.Input[Sequence[pulumi.Input['InstanceGroupManagerStatusVersionTargetArgs']]] version_targets: A bit indicating whether version target has been reached in this managed instance group, i.e. all instances are in their target version. Instances' target version are specified by version field on Instance Group Manager.
        """
        if all_instances_configs is not None:
            pulumi.set(__self__, "all_instances_configs", all_instances_configs)
        if is_stable is not None:
            pulumi.set(__self__, "is_stable", is_stable)
        if statefuls is not None:
            pulumi.set(__self__, "statefuls", statefuls)
        if version_targets is not None:
            pulumi.set(__self__, "version_targets", version_targets)

    @property
    @pulumi.getter(name="allInstancesConfigs")
    def all_instances_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceGroupManagerStatusAllInstancesConfigArgs']]]]:
        """
        )
        Properties to set on all instances in the group. After setting
        allInstancesConfig on the group, you must update the group's instances to
        apply the configuration.
        """
        return pulumi.get(self, "all_instances_configs")

    @all_instances_configs.setter
    def all_instances_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceGroupManagerStatusAllInstancesConfigArgs']]]]):
        pulumi.set(self, "all_instances_configs", value)

    @property
    @pulumi.getter(name="isStable")
    def is_stable(self) -> Optional[pulumi.Input[bool]]:
        """
        A bit indicating whether the managed instance group is in a stable state. A stable state means that: none of the instances in the managed instance group is currently undergoing any type of change (for example, creation, restart, or deletion); no future changes are scheduled for instances in the managed instance group; and the managed instance group itself is not being modified.
        """
        return pulumi.get(self, "is_stable")

    @is_stable.setter
    def is_stable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "is_stable", value)

    @property
    @pulumi.getter
    def statefuls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceGroupManagerStatusStatefulArgs']]]]:
        """
        Stateful status of the given Instance Group Manager.
        """
        return pulumi.get(self, "statefuls")

    @statefuls.setter
    def statefuls(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceGroupManagerStatusStatefulArgs']]]]):
        pulumi.set(self, "statefuls", value)

    @property
    @pulumi.getter(name="versionTargets")
    def version_targets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceGroupManagerStatusVersionTargetArgs']]]]:
        """
        A bit indicating whether version target has been reached in this managed instance group, i.e. all instances are in their target version. Instances' target version are specified by version field on Instance Group Manager.
        """
        return pulumi.get(self, "version_targets")

    @version_targets.setter
    def version_targets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceGroupManagerStatusVersionTargetArgs']]]]):
        pulumi.set(self, "version_targets", value)


@pulumi.input_type
class InstanceGroupManagerStatusAllInstancesConfigArgs:
    def __init__(__self__, *,
                 effective: Optional[pulumi.Input[bool]] = None):
        if effective is not None:
            pulumi.set(__self__, "effective", effective)

    @property
    @pulumi.getter
    def effective(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "effective")

    @effective.setter
    def effective(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "effective", value)


@pulumi.input_type
class InstanceGroupManagerStatusStatefulArgs:
    def __init__(__self__, *,
                 has_stateful_config: Optional[pulumi.Input[bool]] = None,
                 per_instance_configs: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceGroupManagerStatusStatefulPerInstanceConfigArgs']]]] = None):
        """
        :param pulumi.Input[bool] has_stateful_config: A bit indicating whether the managed instance group has stateful configuration, that is, if you have configured any items in a stateful policy or in per-instance configs. The group might report that it has no stateful config even when there is still some preserved state on a managed instance, for example, if you have deleted all PICs but not yet applied those deletions.
        :param pulumi.Input[Sequence[pulumi.Input['InstanceGroupManagerStatusStatefulPerInstanceConfigArgs']]] per_instance_configs: Status of per-instance configs on the instance.
        """
        if has_stateful_config is not None:
            pulumi.set(__self__, "has_stateful_config", has_stateful_config)
        if per_instance_configs is not None:
            pulumi.set(__self__, "per_instance_configs", per_instance_configs)

    @property
    @pulumi.getter(name="hasStatefulConfig")
    def has_stateful_config(self) -> Optional[pulumi.Input[bool]]:
        """
        A bit indicating whether the managed instance group has stateful configuration, that is, if you have configured any items in a stateful policy or in per-instance configs. The group might report that it has no stateful config even when there is still some preserved state on a managed instance, for example, if you have deleted all PICs but not yet applied those deletions.
        """
        return pulumi.get(self, "has_stateful_config")

    @has_stateful_config.setter
    def has_stateful_config(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "has_stateful_config", value)

    @property
    @pulumi.getter(name="perInstanceConfigs")
    def per_instance_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceGroupManagerStatusStatefulPerInstanceConfigArgs']]]]:
        """
        Status of per-instance configs on the instance.
        """
        return pulumi.get(self, "per_instance_configs")

    @per_instance_configs.setter
    def per_instance_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceGroupManagerStatusStatefulPerInstanceConfigArgs']]]]):
        pulumi.set(self, "per_instance_configs", value)


@pulumi.input_type
class InstanceGroupManagerStatusStatefulPerInstanceConfigArgs:
    def __init__(__self__, *,
                 all_effective: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] all_effective: A bit indicating if all of the group's per-instance configs (listed in the output of a listPerInstanceConfigs API call) have status `EFFECTIVE` or there are no per-instance-configs.
        """
        if all_effective is not None:
            pulumi.set(__self__, "all_effective", all_effective)

    @property
    @pulumi.getter(name="allEffective")
    def all_effective(self) -> Optional[pulumi.Input[bool]]:
        """
        A bit indicating if all of the group's per-instance configs (listed in the output of a listPerInstanceConfigs API call) have status `EFFECTIVE` or there are no per-instance-configs.
        """
        return pulumi.get(self, "all_effective")

    @all_effective.setter
    def all_effective(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "all_effective", value)


@pulumi.input_type
class InstanceGroupManagerStatusVersionTargetArgs:
    def __init__(__self__, *,
                 is_reached: Optional[pulumi.Input[bool]] = None):
        if is_reached is not None:
            pulumi.set(__self__, "is_reached", is_reached)

    @property
    @pulumi.getter(name="isReached")
    def is_reached(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "is_reached")

    @is_reached.setter
    def is_reached(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "is_reached", value)


@pulumi.input_type
class InstanceGroupManagerUpdatePolicyArgs:
    def __init__(__self__, *,
                 minimal_action: pulumi.Input[str],
                 type: pulumi.Input[str],
                 max_surge_fixed: Optional[pulumi.Input[int]] = None,
                 max_surge_percent: Optional[pulumi.Input[int]] = None,
                 max_unavailable_fixed: Optional[pulumi.Input[int]] = None,
                 max_unavailable_percent: Optional[pulumi.Input[int]] = None,
                 min_ready_sec: Optional[pulumi.Input[int]] = None,
                 most_disruptive_allowed_action: Optional[pulumi.Input[str]] = None,
                 replacement_method: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] minimal_action: - Minimal action to be taken on an instance. You can specify either `REFRESH` to update without stopping instances, `RESTART` to restart existing instances or `REPLACE` to delete and create new instances from the target template. If you specify a `REFRESH`, the Updater will attempt to perform that action only. However, if the Updater determines that the minimal action you specify is not enough to perform the update, it might perform a more disruptive action.
        :param pulumi.Input[str] type: - The type of update process. You can specify either `PROACTIVE` so that the instance group manager proactively executes actions in order to bring instances to their target versions or `OPPORTUNISTIC` so that no action is proactively executed but the update will be performed as part of other actions (for example, resizes or recreateInstances calls).
        :param pulumi.Input[int] max_surge_fixed: , The maximum number of instances that can be created above the specified targetSize during the update process. Conflicts with `max_surge_percent`. If neither is set, defaults to 1
        :param pulumi.Input[int] max_surge_percent: , The maximum number of instances(calculated as percentage) that can be created above the specified targetSize during the update process. Conflicts with `max_surge_fixed`.
        :param pulumi.Input[int] max_unavailable_fixed: , The maximum number of instances that can be unavailable during the update process. Conflicts with `max_unavailable_percent`. If neither is set, defaults to 1
        :param pulumi.Input[int] max_unavailable_percent: , The maximum number of instances(calculated as percentage) that can be unavailable during the update process. Conflicts with `max_unavailable_fixed`.
        :param pulumi.Input[int] min_ready_sec: ), Minimum number of seconds to wait for after a newly created instance becomes available. This value must be from range [0, 3600]
        :param pulumi.Input[str] most_disruptive_allowed_action: - Most disruptive action that is allowed to be taken on an instance. You can specify either NONE to forbid any actions, REFRESH to allow actions that do not need instance restart, RESTART to allow actions that can be applied without instance replacing or REPLACE to allow all possible actions. If the Updater determines that the minimal update action needed is more disruptive than most disruptive allowed action you specify it will not perform the update at all.
        :param pulumi.Input[str] replacement_method: , The instance replacement method for managed instance groups. Valid values are: "RECREATE", "SUBSTITUTE". If SUBSTITUTE (default), the group replaces VM instances with new instances that have randomly generated names. If RECREATE, instance names are preserved.  You must also set max_unavailable_fixed or max_unavailable_percent to be greater than 0.
               - - -
        """
        pulumi.set(__self__, "minimal_action", minimal_action)
        pulumi.set(__self__, "type", type)
        if max_surge_fixed is not None:
            pulumi.set(__self__, "max_surge_fixed", max_surge_fixed)
        if max_surge_percent is not None:
            pulumi.set(__self__, "max_surge_percent", max_surge_percent)
        if max_unavailable_fixed is not None:
            pulumi.set(__self__, "max_unavailable_fixed", max_unavailable_fixed)
        if max_unavailable_percent is not None:
            pulumi.set(__self__, "max_unavailable_percent", max_unavailable_percent)
        if min_ready_sec is not None:
            pulumi.set(__self__, "min_ready_sec", min_ready_sec)
        if most_disruptive_allowed_action is not None:
            pulumi.set(__self__, "most_disruptive_allowed_action", most_disruptive_allowed_action)
        if replacement_method is not None:
            pulumi.set(__self__, "replacement_method", replacement_method)

    @property
    @pulumi.getter(name="minimalAction")
    def minimal_action(self) -> pulumi.Input[str]:
        """
        - Minimal action to be taken on an instance. You can specify either `REFRESH` to update without stopping instances, `RESTART` to restart existing instances or `REPLACE` to delete and create new instances from the target template. If you specify a `REFRESH`, the Updater will attempt to perform that action only. However, if the Updater determines that the minimal action you specify is not enough to perform the update, it might perform a more disruptive action.
        """
        return pulumi.get(self, "minimal_action")

    @minimal_action.setter
    def minimal_action(self, value: pulumi.Input[str]):
        pulumi.set(self, "minimal_action", value)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        - The type of update process. You can specify either `PROACTIVE` so that the instance group manager proactively executes actions in order to bring instances to their target versions or `OPPORTUNISTIC` so that no action is proactively executed but the update will be performed as part of other actions (for example, resizes or recreateInstances calls).
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter(name="maxSurgeFixed")
    def max_surge_fixed(self) -> Optional[pulumi.Input[int]]:
        """
        , The maximum number of instances that can be created above the specified targetSize during the update process. Conflicts with `max_surge_percent`. If neither is set, defaults to 1
        """
        return pulumi.get(self, "max_surge_fixed")

    @max_surge_fixed.setter
    def max_surge_fixed(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_surge_fixed", value)

    @property
    @pulumi.getter(name="maxSurgePercent")
    def max_surge_percent(self) -> Optional[pulumi.Input[int]]:
        """
        , The maximum number of instances(calculated as percentage) that can be created above the specified targetSize during the update process. Conflicts with `max_surge_fixed`.
        """
        return pulumi.get(self, "max_surge_percent")

    @max_surge_percent.setter
    def max_surge_percent(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_surge_percent", value)

    @property
    @pulumi.getter(name="maxUnavailableFixed")
    def max_unavailable_fixed(self) -> Optional[pulumi.Input[int]]:
        """
        , The maximum number of instances that can be unavailable during the update process. Conflicts with `max_unavailable_percent`. If neither is set, defaults to 1
        """
        return pulumi.get(self, "max_unavailable_fixed")

    @max_unavailable_fixed.setter
    def max_unavailable_fixed(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_unavailable_fixed", value)

    @property
    @pulumi.getter(name="maxUnavailablePercent")
    def max_unavailable_percent(self) -> Optional[pulumi.Input[int]]:
        """
        , The maximum number of instances(calculated as percentage) that can be unavailable during the update process. Conflicts with `max_unavailable_fixed`.
        """
        return pulumi.get(self, "max_unavailable_percent")

    @max_unavailable_percent.setter
    def max_unavailable_percent(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_unavailable_percent", value)

    @property
    @pulumi.getter(name="minReadySec")
    def min_ready_sec(self) -> Optional[pulumi.Input[int]]:
        """
        ), Minimum number of seconds to wait for after a newly created instance becomes available. This value must be from range [0, 3600]
        """
        return pulumi.get(self, "min_ready_sec")

    @min_ready_sec.setter
    def min_ready_sec(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_ready_sec", value)

    @property
    @pulumi.getter(name="mostDisruptiveAllowedAction")
    def most_disruptive_allowed_action(self) -> Optional[pulumi.Input[str]]:
        """
        - Most disruptive action that is allowed to be taken on an instance. You can specify either NONE to forbid any actions, REFRESH to allow actions that do not need instance restart, RESTART to allow actions that can be applied without instance replacing or REPLACE to allow all possible actions. If the Updater determines that the minimal update action needed is more disruptive than most disruptive allowed action you specify it will not perform the update at all.
        """
        return pulumi.get(self, "most_disruptive_allowed_action")

    @most_disruptive_allowed_action.setter
    def most_disruptive_allowed_action(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "most_disruptive_allowed_action", value)

    @property
    @pulumi.getter(name="replacementMethod")
    def replacement_method(self) -> Optional[pulumi.Input[str]]:
        """
        , The instance replacement method for managed instance groups. Valid values are: "RECREATE", "SUBSTITUTE". If SUBSTITUTE (default), the group replaces VM instances with new instances that have randomly generated names. If RECREATE, instance names are preserved.  You must also set max_unavailable_fixed or max_unavailable_percent to be greater than 0.
        - - -
        """
        return pulumi.get(self, "replacement_method")

    @replacement_method.setter
    def replacement_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "replacement_method", value)


@pulumi.input_type
class InstanceGroupManagerVersionArgs:
    def __init__(__self__, *,
                 instance_template: pulumi.Input[str],
                 name: Optional[pulumi.Input[str]] = None,
                 target_size: Optional[pulumi.Input['InstanceGroupManagerVersionTargetSizeArgs']] = None):
        """
        :param pulumi.Input[str] instance_template: - The full URL to an instance template from which all new instances of this version will be created.
        :param pulumi.Input[str] name: - Version name.
        :param pulumi.Input['InstanceGroupManagerVersionTargetSizeArgs'] target_size: - The number of instances calculated as a fixed number or a percentage depending on the settings. Structure is documented below.
        """
        pulumi.set(__self__, "instance_template", instance_template)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if target_size is not None:
            pulumi.set(__self__, "target_size", target_size)

    @property
    @pulumi.getter(name="instanceTemplate")
    def instance_template(self) -> pulumi.Input[str]:
        """
        - The full URL to an instance template from which all new instances of this version will be created.
        """
        return pulumi.get(self, "instance_template")

    @instance_template.setter
    def instance_template(self, value: pulumi.Input[str]):
        pulumi.set(self, "instance_template", value)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        - Version name.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="targetSize")
    def target_size(self) -> Optional[pulumi.Input['InstanceGroupManagerVersionTargetSizeArgs']]:
        """
        - The number of instances calculated as a fixed number or a percentage depending on the settings. Structure is documented below.
        """
        return pulumi.get(self, "target_size")

    @target_size.setter
    def target_size(self, value: Optional[pulumi.Input['InstanceGroupManagerVersionTargetSizeArgs']]):
        pulumi.set(self, "target_size", value)


@pulumi.input_type
class InstanceGroupManagerVersionTargetSizeArgs:
    def __init__(__self__, *,
                 fixed: Optional[pulumi.Input[int]] = None,
                 percent: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] fixed: , The number of instances which are managed for this version. Conflicts with `percent`.
        :param pulumi.Input[int] percent: , The number of instances (calculated as percentage) which are managed for this version. Conflicts with `fixed`.
               Note that when using `percent`, rounding will be in favor of explicitly set `target_size` values; a managed instance group with 2 instances and 2 `version`s,
               one of which has a `target_size.percent` of `60` will create 2 instances of that `version`.
        """
        if fixed is not None:
            pulumi.set(__self__, "fixed", fixed)
        if percent is not None:
            pulumi.set(__self__, "percent", percent)

    @property
    @pulumi.getter
    def fixed(self) -> Optional[pulumi.Input[int]]:
        """
        , The number of instances which are managed for this version. Conflicts with `percent`.
        """
        return pulumi.get(self, "fixed")

    @fixed.setter
    def fixed(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "fixed", value)

    @property
    @pulumi.getter
    def percent(self) -> Optional[pulumi.Input[int]]:
        """
        , The number of instances (calculated as percentage) which are managed for this version. Conflicts with `fixed`.
        Note that when using `percent`, rounding will be in favor of explicitly set `target_size` values; a managed instance group with 2 instances and 2 `version`s,
        one of which has a `target_size.percent` of `60` will create 2 instances of that `version`.
        """
        return pulumi.get(self, "percent")

    @percent.setter
    def percent(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "percent", value)


@pulumi.input_type
class InstanceGroupNamedPortArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 port: pulumi.Input[int]):
        """
        :param pulumi.Input[str] name: The name which the port will be mapped to.
        :param pulumi.Input[int] port: The port number to map the name to.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name which the port will be mapped to.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[int]:
        """
        The port number to map the name to.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: pulumi.Input[int]):
        pulumi.set(self, "port", value)


@pulumi.input_type
class InstanceGuestAcceleratorArgs:
    def __init__(__self__, *,
                 count: pulumi.Input[int],
                 type: pulumi.Input[str]):
        """
        :param pulumi.Input[int] count: The number of the guest accelerator cards exposed to this instance.
        :param pulumi.Input[str] type: The type of reservation from which this instance can consume resources.
        """
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def count(self) -> pulumi.Input[int]:
        """
        The number of the guest accelerator cards exposed to this instance.
        """
        return pulumi.get(self, "count")

    @count.setter
    def count(self, value: pulumi.Input[int]):
        pulumi.set(self, "count", value)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        The type of reservation from which this instance can consume resources.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class InstanceIAMBindingConditionArgs:
    def __init__(__self__, *,
                 expression: pulumi.Input[str],
                 title: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] expression: Textual representation of an expression in Common Expression Language syntax.
        :param pulumi.Input[str] title: A title for the expression, i.e. a short string describing its purpose.
        :param pulumi.Input[str] description: An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "title", title)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter
    def title(self) -> pulumi.Input[str]:
        """
        A title for the expression, i.e. a short string describing its purpose.
        """
        return pulumi.get(self, "title")

    @title.setter
    def title(self, value: pulumi.Input[str]):
        pulumi.set(self, "title", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class InstanceIAMMemberConditionArgs:
    def __init__(__self__, *,
                 expression: pulumi.Input[str],
                 title: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] expression: Textual representation of an expression in Common Expression Language syntax.
        :param pulumi.Input[str] title: A title for the expression, i.e. a short string describing its purpose.
        :param pulumi.Input[str] description: An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "title", title)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter
    def title(self) -> pulumi.Input[str]:
        """
        A title for the expression, i.e. a short string describing its purpose.
        """
        return pulumi.get(self, "title")

    @title.setter
    def title(self, value: pulumi.Input[str]):
        pulumi.set(self, "title", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class InstanceNetworkInterfaceArgs:
    def __init__(__self__, *,
                 access_configs: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceNetworkInterfaceAccessConfigArgs']]]] = None,
                 alias_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceNetworkInterfaceAliasIpRangeArgs']]]] = None,
                 ipv6_access_configs: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceNetworkInterfaceIpv6AccessConfigArgs']]]] = None,
                 ipv6_access_type: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 network: Optional[pulumi.Input[str]] = None,
                 network_ip: Optional[pulumi.Input[str]] = None,
                 nic_type: Optional[pulumi.Input[str]] = None,
                 queue_count: Optional[pulumi.Input[int]] = None,
                 stack_type: Optional[pulumi.Input[str]] = None,
                 subnetwork: Optional[pulumi.Input[str]] = None,
                 subnetwork_project: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['InstanceNetworkInterfaceAccessConfigArgs']]] access_configs: Access configurations, i.e. IPs via which this
               instance can be accessed via the Internet. Omit to ensure that the instance
               is not accessible from the Internet. If omitted, ssh will not
               work unless this provider can send traffic to the instance's network (e.g. via
               tunnel or because it is running on another cloud instance on that network).
               This block can be repeated multiple times. Structure documented below.
        :param pulumi.Input[Sequence[pulumi.Input['InstanceNetworkInterfaceAliasIpRangeArgs']]] alias_ip_ranges: An
               array of alias IP ranges for this network interface. Can only be specified for network
               interfaces on subnet-mode networks. Structure documented below.
        :param pulumi.Input[Sequence[pulumi.Input['InstanceNetworkInterfaceIpv6AccessConfigArgs']]] ipv6_access_configs: An array of IPv6 access configurations for this interface.
               Currently, only one IPv6 access config, DIRECT_IPV6, is supported. If there is no ipv6AccessConfig
               specified, then this instance will have no external IPv6 Internet access. Structure documented below.
        :param pulumi.Input[str] ipv6_access_type: One of EXTERNAL, INTERNAL to indicate whether the IP can be accessed from the Internet.
               This field is always inherited from its subnetwork.
        :param pulumi.Input[str] name: A unique name for the resource, required by GCE.
               Changing this forces a new resource to be created.
        :param pulumi.Input[str] network: The name or self_link of the network to attach this interface to.
               Either `network` or `subnetwork` must be provided. If network isn't provided it will
               be inferred from the subnetwork.
        :param pulumi.Input[str] network_ip: The private IP address to assign to the instance. If
               empty, the address will be automatically assigned.
        :param pulumi.Input[str] nic_type: The type of vNIC to be used on this interface. Possible values: GVNIC, VIRTIO_NET.
        :param pulumi.Input[int] queue_count: The networking queue count that's specified by users for the network interface. Both Rx and Tx queues will be set to this number. It will be empty if not specified.
        :param pulumi.Input[str] stack_type: The stack type for this network interface to identify whether the IPv6 feature is enabled or not. Values are IPV4_IPV6 or IPV4_ONLY. If not specified, IPV4_ONLY will be used.
        :param pulumi.Input[str] subnetwork: The name or self_link of the subnetwork to attach this
               interface to. Either `network` or `subnetwork` must be provided. If network isn't provided
               it will be inferred from the subnetwork. The subnetwork must exist in the same region this
               instance will be created in. If the network resource is in
               [legacy](https://cloud.google.com/vpc/docs/legacy) mode, do not specify this field. If the
               network is in auto subnet mode, specifying the subnetwork is optional. If the network is
               in custom subnet mode, specifying the subnetwork is required.
        :param pulumi.Input[str] subnetwork_project: The project in which the subnetwork belongs.
               If the `subnetwork` is a self_link, this field is ignored in favor of the project
               defined in the subnetwork self_link. If the `subnetwork` is a name and this
               field is not provided, the provider project is used.
        """
        if access_configs is not None:
            pulumi.set(__self__, "access_configs", access_configs)
        if alias_ip_ranges is not None:
            pulumi.set(__self__, "alias_ip_ranges", alias_ip_ranges)
        if ipv6_access_configs is not None:
            pulumi.set(__self__, "ipv6_access_configs", ipv6_access_configs)
        if ipv6_access_type is not None:
            pulumi.set(__self__, "ipv6_access_type", ipv6_access_type)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if network is not None:
            pulumi.set(__self__, "network", network)
        if network_ip is not None:
            pulumi.set(__self__, "network_ip", network_ip)
        if nic_type is not None:
            pulumi.set(__self__, "nic_type", nic_type)
        if queue_count is not None:
            pulumi.set(__self__, "queue_count", queue_count)
        if stack_type is not None:
            pulumi.set(__self__, "stack_type", stack_type)
        if subnetwork is not None:
            pulumi.set(__self__, "subnetwork", subnetwork)
        if subnetwork_project is not None:
            pulumi.set(__self__, "subnetwork_project", subnetwork_project)

    @property
    @pulumi.getter(name="accessConfigs")
    def access_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceNetworkInterfaceAccessConfigArgs']]]]:
        """
        Access configurations, i.e. IPs via which this
        instance can be accessed via the Internet. Omit to ensure that the instance
        is not accessible from the Internet. If omitted, ssh will not
        work unless this provider can send traffic to the instance's network (e.g. via
        tunnel or because it is running on another cloud instance on that network).
        This block can be repeated multiple times. Structure documented below.
        """
        return pulumi.get(self, "access_configs")

    @access_configs.setter
    def access_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceNetworkInterfaceAccessConfigArgs']]]]):
        pulumi.set(self, "access_configs", value)

    @property
    @pulumi.getter(name="aliasIpRanges")
    def alias_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceNetworkInterfaceAliasIpRangeArgs']]]]:
        """
        An
        array of alias IP ranges for this network interface. Can only be specified for network
        interfaces on subnet-mode networks. Structure documented below.
        """
        return pulumi.get(self, "alias_ip_ranges")

    @alias_ip_ranges.setter
    def alias_ip_ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceNetworkInterfaceAliasIpRangeArgs']]]]):
        pulumi.set(self, "alias_ip_ranges", value)

    @property
    @pulumi.getter(name="ipv6AccessConfigs")
    def ipv6_access_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceNetworkInterfaceIpv6AccessConfigArgs']]]]:
        """
        An array of IPv6 access configurations for this interface.
        Currently, only one IPv6 access config, DIRECT_IPV6, is supported. If there is no ipv6AccessConfig
        specified, then this instance will have no external IPv6 Internet access. Structure documented below.
        """
        return pulumi.get(self, "ipv6_access_configs")

    @ipv6_access_configs.setter
    def ipv6_access_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceNetworkInterfaceIpv6AccessConfigArgs']]]]):
        pulumi.set(self, "ipv6_access_configs", value)

    @property
    @pulumi.getter(name="ipv6AccessType")
    def ipv6_access_type(self) -> Optional[pulumi.Input[str]]:
        """
        One of EXTERNAL, INTERNAL to indicate whether the IP can be accessed from the Internet.
        This field is always inherited from its subnetwork.
        """
        return pulumi.get(self, "ipv6_access_type")

    @ipv6_access_type.setter
    def ipv6_access_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ipv6_access_type", value)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        A unique name for the resource, required by GCE.
        Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def network(self) -> Optional[pulumi.Input[str]]:
        """
        The name or self_link of the network to attach this interface to.
        Either `network` or `subnetwork` must be provided. If network isn't provided it will
        be inferred from the subnetwork.
        """
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network", value)

    @property
    @pulumi.getter(name="networkIp")
    def network_ip(self) -> Optional[pulumi.Input[str]]:
        """
        The private IP address to assign to the instance. If
        empty, the address will be automatically assigned.
        """
        return pulumi.get(self, "network_ip")

    @network_ip.setter
    def network_ip(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_ip", value)

    @property
    @pulumi.getter(name="nicType")
    def nic_type(self) -> Optional[pulumi.Input[str]]:
        """
        The type of vNIC to be used on this interface. Possible values: GVNIC, VIRTIO_NET.
        """
        return pulumi.get(self, "nic_type")

    @nic_type.setter
    def nic_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "nic_type", value)

    @property
    @pulumi.getter(name="queueCount")
    def queue_count(self) -> Optional[pulumi.Input[int]]:
        """
        The networking queue count that's specified by users for the network interface. Both Rx and Tx queues will be set to this number. It will be empty if not specified.
        """
        return pulumi.get(self, "queue_count")

    @queue_count.setter
    def queue_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "queue_count", value)

    @property
    @pulumi.getter(name="stackType")
    def stack_type(self) -> Optional[pulumi.Input[str]]:
        """
        The stack type for this network interface to identify whether the IPv6 feature is enabled or not. Values are IPV4_IPV6 or IPV4_ONLY. If not specified, IPV4_ONLY will be used.
        """
        return pulumi.get(self, "stack_type")

    @stack_type.setter
    def stack_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "stack_type", value)

    @property
    @pulumi.getter
    def subnetwork(self) -> Optional[pulumi.Input[str]]:
        """
        The name or self_link of the subnetwork to attach this
        interface to. Either `network` or `subnetwork` must be provided. If network isn't provided
        it will be inferred from the subnetwork. The subnetwork must exist in the same region this
        instance will be created in. If the network resource is in
        [legacy](https://cloud.google.com/vpc/docs/legacy) mode, do not specify this field. If the
        network is in auto subnet mode, specifying the subnetwork is optional. If the network is
        in custom subnet mode, specifying the subnetwork is required.
        """
        return pulumi.get(self, "subnetwork")

    @subnetwork.setter
    def subnetwork(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnetwork", value)

    @property
    @pulumi.getter(name="subnetworkProject")
    def subnetwork_project(self) -> Optional[pulumi.Input[str]]:
        """
        The project in which the subnetwork belongs.
        If the `subnetwork` is a self_link, this field is ignored in favor of the project
        defined in the subnetwork self_link. If the `subnetwork` is a name and this
        field is not provided, the provider project is used.
        """
        return pulumi.get(self, "subnetwork_project")

    @subnetwork_project.setter
    def subnetwork_project(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnetwork_project", value)


@pulumi.input_type
class InstanceNetworkInterfaceAccessConfigArgs:
    def __init__(__self__, *,
                 nat_ip: Optional[pulumi.Input[str]] = None,
                 network_tier: Optional[pulumi.Input[str]] = None,
                 public_ptr_domain_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] nat_ip: The IP address that will be 1:1 mapped to the instance's
               network ip. If not given, one will be generated.
        :param pulumi.Input[str] network_tier: The service-level to be provided for IPv6 traffic when the
               subnet has an external subnet. Only PREMIUM or STANDARD tier is valid for IPv6.
        :param pulumi.Input[str] public_ptr_domain_name: The domain name to be used when creating DNSv6
               records for the external IPv6 ranges..
        """
        if nat_ip is not None:
            pulumi.set(__self__, "nat_ip", nat_ip)
        if network_tier is not None:
            pulumi.set(__self__, "network_tier", network_tier)
        if public_ptr_domain_name is not None:
            pulumi.set(__self__, "public_ptr_domain_name", public_ptr_domain_name)

    @property
    @pulumi.getter(name="natIp")
    def nat_ip(self) -> Optional[pulumi.Input[str]]:
        """
        The IP address that will be 1:1 mapped to the instance's
        network ip. If not given, one will be generated.
        """
        return pulumi.get(self, "nat_ip")

    @nat_ip.setter
    def nat_ip(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "nat_ip", value)

    @property
    @pulumi.getter(name="networkTier")
    def network_tier(self) -> Optional[pulumi.Input[str]]:
        """
        The service-level to be provided for IPv6 traffic when the
        subnet has an external subnet. Only PREMIUM or STANDARD tier is valid for IPv6.
        """
        return pulumi.get(self, "network_tier")

    @network_tier.setter
    def network_tier(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_tier", value)

    @property
    @pulumi.getter(name="publicPtrDomainName")
    def public_ptr_domain_name(self) -> Optional[pulumi.Input[str]]:
        """
        The domain name to be used when creating DNSv6
        records for the external IPv6 ranges..
        """
        return pulumi.get(self, "public_ptr_domain_name")

    @public_ptr_domain_name.setter
    def public_ptr_domain_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "public_ptr_domain_name", value)


@pulumi.input_type
class InstanceNetworkInterfaceAliasIpRangeArgs:
    def __init__(__self__, *,
                 ip_cidr_range: pulumi.Input[str],
                 subnetwork_range_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] ip_cidr_range: The IP CIDR range represented by this alias IP range. This IP CIDR range
               must belong to the specified subnetwork and cannot contain IP addresses reserved by
               system or used by other network interfaces. This range may be a single IP address
               (e.g. 10.2.3.4), a netmask (e.g. /24) or a CIDR format string (e.g. 10.1.2.0/24).
        :param pulumi.Input[str] subnetwork_range_name: The subnetwork secondary range name specifying
               the secondary range from which to allocate the IP CIDR range for this alias IP
               range. If left unspecified, the primary range of the subnetwork will be used.
        """
        pulumi.set(__self__, "ip_cidr_range", ip_cidr_range)
        if subnetwork_range_name is not None:
            pulumi.set(__self__, "subnetwork_range_name", subnetwork_range_name)

    @property
    @pulumi.getter(name="ipCidrRange")
    def ip_cidr_range(self) -> pulumi.Input[str]:
        """
        The IP CIDR range represented by this alias IP range. This IP CIDR range
        must belong to the specified subnetwork and cannot contain IP addresses reserved by
        system or used by other network interfaces. This range may be a single IP address
        (e.g. 10.2.3.4), a netmask (e.g. /24) or a CIDR format string (e.g. 10.1.2.0/24).
        """
        return pulumi.get(self, "ip_cidr_range")

    @ip_cidr_range.setter
    def ip_cidr_range(self, value: pulumi.Input[str]):
        pulumi.set(self, "ip_cidr_range", value)

    @property
    @pulumi.getter(name="subnetworkRangeName")
    def subnetwork_range_name(self) -> Optional[pulumi.Input[str]]:
        """
        The subnetwork secondary range name specifying
        the secondary range from which to allocate the IP CIDR range for this alias IP
        range. If left unspecified, the primary range of the subnetwork will be used.
        """
        return pulumi.get(self, "subnetwork_range_name")

    @subnetwork_range_name.setter
    def subnetwork_range_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnetwork_range_name", value)


@pulumi.input_type
class InstanceNetworkInterfaceIpv6AccessConfigArgs:
    def __init__(__self__, *,
                 network_tier: pulumi.Input[str],
                 external_ipv6: Optional[pulumi.Input[str]] = None,
                 external_ipv6_prefix_length: Optional[pulumi.Input[str]] = None,
                 public_ptr_domain_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] network_tier: The service-level to be provided for IPv6 traffic when the
               subnet has an external subnet. Only PREMIUM or STANDARD tier is valid for IPv6.
        :param pulumi.Input[str] public_ptr_domain_name: The domain name to be used when creating DNSv6
               records for the external IPv6 ranges..
        """
        pulumi.set(__self__, "network_tier", network_tier)
        if external_ipv6 is not None:
            pulumi.set(__self__, "external_ipv6", external_ipv6)
        if external_ipv6_prefix_length is not None:
            pulumi.set(__self__, "external_ipv6_prefix_length", external_ipv6_prefix_length)
        if public_ptr_domain_name is not None:
            pulumi.set(__self__, "public_ptr_domain_name", public_ptr_domain_name)

    @property
    @pulumi.getter(name="networkTier")
    def network_tier(self) -> pulumi.Input[str]:
        """
        The service-level to be provided for IPv6 traffic when the
        subnet has an external subnet. Only PREMIUM or STANDARD tier is valid for IPv6.
        """
        return pulumi.get(self, "network_tier")

    @network_tier.setter
    def network_tier(self, value: pulumi.Input[str]):
        pulumi.set(self, "network_tier", value)

    @property
    @pulumi.getter(name="externalIpv6")
    def external_ipv6(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "external_ipv6")

    @external_ipv6.setter
    def external_ipv6(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "external_ipv6", value)

    @property
    @pulumi.getter(name="externalIpv6PrefixLength")
    def external_ipv6_prefix_length(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "external_ipv6_prefix_length")

    @external_ipv6_prefix_length.setter
    def external_ipv6_prefix_length(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "external_ipv6_prefix_length", value)

    @property
    @pulumi.getter(name="publicPtrDomainName")
    def public_ptr_domain_name(self) -> Optional[pulumi.Input[str]]:
        """
        The domain name to be used when creating DNSv6
        records for the external IPv6 ranges..
        """
        return pulumi.get(self, "public_ptr_domain_name")

    @public_ptr_domain_name.setter
    def public_ptr_domain_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "public_ptr_domain_name", value)


@pulumi.input_type
class InstanceNetworkPerformanceConfigArgs:
    def __init__(__self__, *,
                 total_egress_bandwidth_tier: pulumi.Input[str]):
        """
        :param pulumi.Input[str] total_egress_bandwidth_tier: The egress bandwidth tier to enable.
               Possible values: TIER_1, DEFAULT
        """
        pulumi.set(__self__, "total_egress_bandwidth_tier", total_egress_bandwidth_tier)

    @property
    @pulumi.getter(name="totalEgressBandwidthTier")
    def total_egress_bandwidth_tier(self) -> pulumi.Input[str]:
        """
        The egress bandwidth tier to enable.
        Possible values: TIER_1, DEFAULT
        """
        return pulumi.get(self, "total_egress_bandwidth_tier")

    @total_egress_bandwidth_tier.setter
    def total_egress_bandwidth_tier(self, value: pulumi.Input[str]):
        pulumi.set(self, "total_egress_bandwidth_tier", value)


@pulumi.input_type
class InstanceReservationAffinityArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str],
                 specific_reservation: Optional[pulumi.Input['InstanceReservationAffinitySpecificReservationArgs']] = None):
        """
        :param pulumi.Input[str] type: The type of reservation from which this instance can consume resources.
        :param pulumi.Input['InstanceReservationAffinitySpecificReservationArgs'] specific_reservation: Specifies the label selector for the reservation to use..
               Structure is documented below.
        """
        pulumi.set(__self__, "type", type)
        if specific_reservation is not None:
            pulumi.set(__self__, "specific_reservation", specific_reservation)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        The type of reservation from which this instance can consume resources.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter(name="specificReservation")
    def specific_reservation(self) -> Optional[pulumi.Input['InstanceReservationAffinitySpecificReservationArgs']]:
        """
        Specifies the label selector for the reservation to use..
        Structure is documented below.
        """
        return pulumi.get(self, "specific_reservation")

    @specific_reservation.setter
    def specific_reservation(self, value: Optional[pulumi.Input['InstanceReservationAffinitySpecificReservationArgs']]):
        pulumi.set(self, "specific_reservation", value)


@pulumi.input_type
class InstanceReservationAffinitySpecificReservationArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 values: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        :param pulumi.Input[str] key: Corresponds to the label key of a reservation resource. To target a SPECIFIC_RESERVATION by name, specify compute.googleapis.com/reservation-name as the key and specify the name of your reservation as the only value.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: Corresponds to the label values of a reservation resource.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        Corresponds to the label key of a reservation resource. To target a SPECIFIC_RESERVATION by name, specify compute.googleapis.com/reservation-name as the key and specify the name of your reservation as the only value.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def values(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        Corresponds to the label values of a reservation resource.
        """
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class InstanceSchedulingArgs:
    def __init__(__self__, *,
                 automatic_restart: Optional[pulumi.Input[bool]] = None,
                 instance_termination_action: Optional[pulumi.Input[str]] = None,
                 min_node_cpus: Optional[pulumi.Input[int]] = None,
                 node_affinities: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceSchedulingNodeAffinityArgs']]]] = None,
                 on_host_maintenance: Optional[pulumi.Input[str]] = None,
                 preemptible: Optional[pulumi.Input[bool]] = None,
                 provisioning_model: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] automatic_restart: Specifies if the instance should be
               restarted if it was terminated by Compute Engine (not a user).
               Defaults to true.
        :param pulumi.Input[str] instance_termination_action: Describe the type of termination action for `SPOT` VM. Can be `STOP` or `DELETE`.  Read more on [here](https://cloud.google.com/compute/docs/instances/create-use-spot)
        :param pulumi.Input[int] min_node_cpus: The minimum number of virtual CPUs this instance will consume when running on a sole-tenant node.
        :param pulumi.Input[Sequence[pulumi.Input['InstanceSchedulingNodeAffinityArgs']]] node_affinities: Specifies node affinities or anti-affinities
               to determine which sole-tenant nodes your instances and managed instance
               groups will use as host systems. Read more on sole-tenant node creation
               [here](https://cloud.google.com/compute/docs/nodes/create-nodes).
               Structure documented below.
        :param pulumi.Input[str] on_host_maintenance: Describes maintenance behavior for the
               instance. Can be MIGRATE or TERMINATE, for more info, read
               [here](https://cloud.google.com/compute/docs/instances/setting-instance-scheduling-options).
        :param pulumi.Input[bool] preemptible: Specifies if the instance is preemptible.
               If this field is set to true, then `automatic_restart` must be
               set to false.  Defaults to false.
        :param pulumi.Input[str] provisioning_model: Describe the type of preemptible VM. This field accepts the value `STANDARD` or `SPOT`. If the value is `STANDARD`, there will be no discount. If this   is set to `SPOT`,
               `preemptible` should be `true` and `auto_restart` should be
               `false`. For more info about
               `SPOT`, read [here](https://cloud.google.com/compute/docs/instances/spot)
        """
        if automatic_restart is not None:
            pulumi.set(__self__, "automatic_restart", automatic_restart)
        if instance_termination_action is not None:
            pulumi.set(__self__, "instance_termination_action", instance_termination_action)
        if min_node_cpus is not None:
            pulumi.set(__self__, "min_node_cpus", min_node_cpus)
        if node_affinities is not None:
            pulumi.set(__self__, "node_affinities", node_affinities)
        if on_host_maintenance is not None:
            pulumi.set(__self__, "on_host_maintenance", on_host_maintenance)
        if preemptible is not None:
            pulumi.set(__self__, "preemptible", preemptible)
        if provisioning_model is not None:
            pulumi.set(__self__, "provisioning_model", provisioning_model)

    @property
    @pulumi.getter(name="automaticRestart")
    def automatic_restart(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies if the instance should be
        restarted if it was terminated by Compute Engine (not a user).
        Defaults to true.
        """
        return pulumi.get(self, "automatic_restart")

    @automatic_restart.setter
    def automatic_restart(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "automatic_restart", value)

    @property
    @pulumi.getter(name="instanceTerminationAction")
    def instance_termination_action(self) -> Optional[pulumi.Input[str]]:
        """
        Describe the type of termination action for `SPOT` VM. Can be `STOP` or `DELETE`.  Read more on [here](https://cloud.google.com/compute/docs/instances/create-use-spot)
        """
        return pulumi.get(self, "instance_termination_action")

    @instance_termination_action.setter
    def instance_termination_action(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "instance_termination_action", value)

    @property
    @pulumi.getter(name="minNodeCpus")
    def min_node_cpus(self) -> Optional[pulumi.Input[int]]:
        """
        The minimum number of virtual CPUs this instance will consume when running on a sole-tenant node.
        """
        return pulumi.get(self, "min_node_cpus")

    @min_node_cpus.setter
    def min_node_cpus(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_node_cpus", value)

    @property
    @pulumi.getter(name="nodeAffinities")
    def node_affinities(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceSchedulingNodeAffinityArgs']]]]:
        """
        Specifies node affinities or anti-affinities
        to determine which sole-tenant nodes your instances and managed instance
        groups will use as host systems. Read more on sole-tenant node creation
        [here](https://cloud.google.com/compute/docs/nodes/create-nodes).
        Structure documented below.
        """
        return pulumi.get(self, "node_affinities")

    @node_affinities.setter
    def node_affinities(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceSchedulingNodeAffinityArgs']]]]):
        pulumi.set(self, "node_affinities", value)

    @property
    @pulumi.getter(name="onHostMaintenance")
    def on_host_maintenance(self) -> Optional[pulumi.Input[str]]:
        """
        Describes maintenance behavior for the
        instance. Can be MIGRATE or TERMINATE, for more info, read
        [here](https://cloud.google.com/compute/docs/instances/setting-instance-scheduling-options).
        """
        return pulumi.get(self, "on_host_maintenance")

    @on_host_maintenance.setter
    def on_host_maintenance(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "on_host_maintenance", value)

    @property
    @pulumi.getter
    def preemptible(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies if the instance is preemptible.
        If this field is set to true, then `automatic_restart` must be
        set to false.  Defaults to false.
        """
        return pulumi.get(self, "preemptible")

    @preemptible.setter
    def preemptible(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "preemptible", value)

    @property
    @pulumi.getter(name="provisioningModel")
    def provisioning_model(self) -> Optional[pulumi.Input[str]]:
        """
        Describe the type of preemptible VM. This field accepts the value `STANDARD` or `SPOT`. If the value is `STANDARD`, there will be no discount. If this   is set to `SPOT`,
        `preemptible` should be `true` and `auto_restart` should be
        `false`. For more info about
        `SPOT`, read [here](https://cloud.google.com/compute/docs/instances/spot)
        """
        return pulumi.get(self, "provisioning_model")

    @provisioning_model.setter
    def provisioning_model(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "provisioning_model", value)


@pulumi.input_type
class InstanceSchedulingNodeAffinityArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 operator: pulumi.Input[str],
                 values: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        :param pulumi.Input[str] key: Corresponds to the label key of a reservation resource. To target a SPECIFIC_RESERVATION by name, specify compute.googleapis.com/reservation-name as the key and specify the name of your reservation as the only value.
        :param pulumi.Input[str] operator: The operator. Can be `IN` for node-affinities
               or `NOT_IN` for anti-affinities.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: Corresponds to the label values of a reservation resource.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        Corresponds to the label key of a reservation resource. To target a SPECIFIC_RESERVATION by name, specify compute.googleapis.com/reservation-name as the key and specify the name of your reservation as the only value.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def operator(self) -> pulumi.Input[str]:
        """
        The operator. Can be `IN` for node-affinities
        or `NOT_IN` for anti-affinities.
        """
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: pulumi.Input[str]):
        pulumi.set(self, "operator", value)

    @property
    @pulumi.getter
    def values(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        Corresponds to the label values of a reservation resource.
        """
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class InstanceScratchDiskArgs:
    def __init__(__self__, *,
                 interface: pulumi.Input[str]):
        """
        :param pulumi.Input[str] interface: The disk interface to use for attaching this disk; either SCSI or NVME.
        """
        pulumi.set(__self__, "interface", interface)

    @property
    @pulumi.getter
    def interface(self) -> pulumi.Input[str]:
        """
        The disk interface to use for attaching this disk; either SCSI or NVME.
        """
        return pulumi.get(self, "interface")

    @interface.setter
    def interface(self, value: pulumi.Input[str]):
        pulumi.set(self, "interface", value)


@pulumi.input_type
class InstanceServiceAccountArgs:
    def __init__(__self__, *,
                 scopes: pulumi.Input[Sequence[pulumi.Input[str]]],
                 email: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] scopes: A list of service scopes. Both OAuth2 URLs and gcloud
               short names are supported. To allow full access to all Cloud APIs, use the
               `cloud-platform` scope. See a complete list of scopes [here](https://cloud.google.com/sdk/gcloud/reference/alpha/compute/instances/set-scopes#--scopes).
               **Note**: `allow_stopping_for_update` must be set to true or your instance must have a `desired_status` of `TERMINATED` in order to update this field.
        :param pulumi.Input[str] email: The service account e-mail address. If not given, the
               default Google Compute Engine service account is used.
               **Note**: `allow_stopping_for_update` must be set to true or your instance must have a `desired_status` of `TERMINATED` in order to update this field.
        """
        pulumi.set(__self__, "scopes", scopes)
        if email is not None:
            pulumi.set(__self__, "email", email)

    @property
    @pulumi.getter
    def scopes(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        A list of service scopes. Both OAuth2 URLs and gcloud
        short names are supported. To allow full access to all Cloud APIs, use the
        `cloud-platform` scope. See a complete list of scopes [here](https://cloud.google.com/sdk/gcloud/reference/alpha/compute/instances/set-scopes#--scopes).
        **Note**: `allow_stopping_for_update` must be set to true or your instance must have a `desired_status` of `TERMINATED` in order to update this field.
        """
        return pulumi.get(self, "scopes")

    @scopes.setter
    def scopes(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "scopes", value)

    @property
    @pulumi.getter
    def email(self) -> Optional[pulumi.Input[str]]:
        """
        The service account e-mail address. If not given, the
        default Google Compute Engine service account is used.
        **Note**: `allow_stopping_for_update` must be set to true or your instance must have a `desired_status` of `TERMINATED` in order to update this field.
        """
        return pulumi.get(self, "email")

    @email.setter
    def email(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "email", value)


@pulumi.input_type
class InstanceShieldedInstanceConfigArgs:
    def __init__(__self__, *,
                 enable_integrity_monitoring: Optional[pulumi.Input[bool]] = None,
                 enable_secure_boot: Optional[pulumi.Input[bool]] = None,
                 enable_vtpm: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] enable_integrity_monitoring: -- Compare the most recent boot measurements to the integrity policy baseline and return a pair of pass/fail results depending on whether they match or not. Defaults to true.
               **Note**: `allow_stopping_for_update` must be set to true or your instance must have a `desired_status` of `TERMINATED` in order to update this field.
        :param pulumi.Input[bool] enable_secure_boot: -- Verify the digital signature of all boot components, and halt the boot process if signature verification fails. Defaults to false.
               **Note**: `allow_stopping_for_update` must be set to true or your instance must have a `desired_status` of `TERMINATED` in order to update this field.
        :param pulumi.Input[bool] enable_vtpm: -- Use a virtualized trusted platform module, which is a specialized computer chip you can use to encrypt objects like keys and certificates. Defaults to true.
               **Note**: `allow_stopping_for_update` must be set to true or your instance must have a `desired_status` of `TERMINATED` in order to update this field.
        """
        if enable_integrity_monitoring is not None:
            pulumi.set(__self__, "enable_integrity_monitoring", enable_integrity_monitoring)
        if enable_secure_boot is not None:
            pulumi.set(__self__, "enable_secure_boot", enable_secure_boot)
        if enable_vtpm is not None:
            pulumi.set(__self__, "enable_vtpm", enable_vtpm)

    @property
    @pulumi.getter(name="enableIntegrityMonitoring")
    def enable_integrity_monitoring(self) -> Optional[pulumi.Input[bool]]:
        """
        -- Compare the most recent boot measurements to the integrity policy baseline and return a pair of pass/fail results depending on whether they match or not. Defaults to true.
        **Note**: `allow_stopping_for_update` must be set to true or your instance must have a `desired_status` of `TERMINATED` in order to update this field.
        """
        return pulumi.get(self, "enable_integrity_monitoring")

    @enable_integrity_monitoring.setter
    def enable_integrity_monitoring(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_integrity_monitoring", value)

    @property
    @pulumi.getter(name="enableSecureBoot")
    def enable_secure_boot(self) -> Optional[pulumi.Input[bool]]:
        """
        -- Verify the digital signature of all boot components, and halt the boot process if signature verification fails. Defaults to false.
        **Note**: `allow_stopping_for_update` must be set to true or your instance must have a `desired_status` of `TERMINATED` in order to update this field.
        """
        return pulumi.get(self, "enable_secure_boot")

    @enable_secure_boot.setter
    def enable_secure_boot(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_secure_boot", value)

    @property
    @pulumi.getter(name="enableVtpm")
    def enable_vtpm(self) -> Optional[pulumi.Input[bool]]:
        """
        -- Use a virtualized trusted platform module, which is a specialized computer chip you can use to encrypt objects like keys and certificates. Defaults to true.
        **Note**: `allow_stopping_for_update` must be set to true or your instance must have a `desired_status` of `TERMINATED` in order to update this field.
        """
        return pulumi.get(self, "enable_vtpm")

    @enable_vtpm.setter
    def enable_vtpm(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_vtpm", value)


@pulumi.input_type
class InstanceTemplateAdvancedMachineFeaturesArgs:
    def __init__(__self__, *,
                 enable_nested_virtualization: Optional[pulumi.Input[bool]] = None,
                 threads_per_core: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[bool] enable_nested_virtualization: Defines whether the instance should have nested virtualization enabled. Defaults to false.
        :param pulumi.Input[int] threads_per_core: he number of threads per physical core. To disable [simultaneous multithreading (SMT)](https://cloud.google.com/compute/docs/instances/disabling-smt) set this to 1.
        """
        if enable_nested_virtualization is not None:
            pulumi.set(__self__, "enable_nested_virtualization", enable_nested_virtualization)
        if threads_per_core is not None:
            pulumi.set(__self__, "threads_per_core", threads_per_core)

    @property
    @pulumi.getter(name="enableNestedVirtualization")
    def enable_nested_virtualization(self) -> Optional[pulumi.Input[bool]]:
        """
        Defines whether the instance should have nested virtualization enabled. Defaults to false.
        """
        return pulumi.get(self, "enable_nested_virtualization")

    @enable_nested_virtualization.setter
    def enable_nested_virtualization(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_nested_virtualization", value)

    @property
    @pulumi.getter(name="threadsPerCore")
    def threads_per_core(self) -> Optional[pulumi.Input[int]]:
        """
        he number of threads per physical core. To disable [simultaneous multithreading (SMT)](https://cloud.google.com/compute/docs/instances/disabling-smt) set this to 1.
        """
        return pulumi.get(self, "threads_per_core")

    @threads_per_core.setter
    def threads_per_core(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "threads_per_core", value)


@pulumi.input_type
class InstanceTemplateConfidentialInstanceConfigArgs:
    def __init__(__self__, *,
                 enable_confidential_compute: pulumi.Input[bool]):
        """
        :param pulumi.Input[bool] enable_confidential_compute: Defines whether the instance should have confidential compute enabled. `on_host_maintenance` has to be set to TERMINATE or this will fail to create the VM.
        """
        pulumi.set(__self__, "enable_confidential_compute", enable_confidential_compute)

    @property
    @pulumi.getter(name="enableConfidentialCompute")
    def enable_confidential_compute(self) -> pulumi.Input[bool]:
        """
        Defines whether the instance should have confidential compute enabled. `on_host_maintenance` has to be set to TERMINATE or this will fail to create the VM.
        """
        return pulumi.get(self, "enable_confidential_compute")

    @enable_confidential_compute.setter
    def enable_confidential_compute(self, value: pulumi.Input[bool]):
        pulumi.set(self, "enable_confidential_compute", value)


@pulumi.input_type
class InstanceTemplateDiskArgs:
    def __init__(__self__, *,
                 auto_delete: Optional[pulumi.Input[bool]] = None,
                 boot: Optional[pulumi.Input[bool]] = None,
                 device_name: Optional[pulumi.Input[str]] = None,
                 disk_encryption_key: Optional[pulumi.Input['InstanceTemplateDiskDiskEncryptionKeyArgs']] = None,
                 disk_name: Optional[pulumi.Input[str]] = None,
                 disk_size_gb: Optional[pulumi.Input[int]] = None,
                 disk_type: Optional[pulumi.Input[str]] = None,
                 interface: Optional[pulumi.Input[str]] = None,
                 labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 mode: Optional[pulumi.Input[str]] = None,
                 resource_policies: Optional[pulumi.Input[str]] = None,
                 source: Optional[pulumi.Input[str]] = None,
                 source_image: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] auto_delete: Whether or not the disk should be auto-deleted.
               This defaults to true.
        :param pulumi.Input[bool] boot: Indicates that this is a boot disk.
        :param pulumi.Input[str] device_name: A unique device name that is reflected into the
               /dev/  tree of a Linux operating system running within the instance. If not
               specified, the server chooses a default device name to apply to this disk.
        :param pulumi.Input['InstanceTemplateDiskDiskEncryptionKeyArgs'] disk_encryption_key: Encrypts or decrypts a disk using a customer-supplied encryption key.
        :param pulumi.Input[str] disk_name: Name of the disk. When not provided, this defaults
               to the name of the instance.
        :param pulumi.Input[int] disk_size_gb: The size of the image in gigabytes. If not
               specified, it will inherit the size of its base image. For SCRATCH disks,
               the size must be exactly 375GB.
        :param pulumi.Input[str] disk_type: The GCE disk type. Such as `"pd-ssd"`, `"local-ssd"`,
               `"pd-balanced"` or `"pd-standard"`.
        :param pulumi.Input[str] interface: Specifies the disk interface to use for attaching this disk,
               which is either SCSI or NVME. The default is SCSI. Persistent disks must always use SCSI
               and the request will fail if you attempt to attach a persistent disk in any other format
               than SCSI. Local SSDs can use either NVME or SCSI.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: A set of ket/value label pairs to assign to disk created from
               this template
        :param pulumi.Input[str] mode: The mode in which to attach this disk, either READ_WRITE
               or READ_ONLY. If you are attaching or creating a boot disk, this must
               read-write mode.
        :param pulumi.Input[str] resource_policies: -- A list (short name or id) of resource policies to attach to this disk for automatic snapshot creations. Currently a max of 1 resource policy is supported.
        :param pulumi.Input[str] source: The name (**not self_link**)
               of the disk (such as those managed by `compute.Disk`) to attach.
               > **Note:** Either `source` or `source_image` is **required** in a disk block unless the disk type is `local-ssd`. Check the API [docs](https://cloud.google.com/compute/docs/reference/rest/v1/instanceTemplates/insert) for details.
        :param pulumi.Input[str] source_image: The image from which to
               initialize this disk. This can be one of: the image's `self_link`,
               `projects/{project}/global/images/{image}`,
               `projects/{project}/global/images/family/{family}`, `global/images/{image}`,
               `global/images/family/{family}`, `family/{family}`, `{project}/{family}`,
               `{project}/{image}`, `{family}`, or `{image}`.
               > **Note:** Either `source` or `source_image` is **required** in a disk block unless the disk type is `local-ssd`. Check the API [docs](https://cloud.google.com/compute/docs/reference/rest/v1/instanceTemplates/insert) for details.
        :param pulumi.Input[str] type: The type of reservation from which this instance can consume resources.
        """
        if auto_delete is not None:
            pulumi.set(__self__, "auto_delete", auto_delete)
        if boot is not None:
            pulumi.set(__self__, "boot", boot)
        if device_name is not None:
            pulumi.set(__self__, "device_name", device_name)
        if disk_encryption_key is not None:
            pulumi.set(__self__, "disk_encryption_key", disk_encryption_key)
        if disk_name is not None:
            pulumi.set(__self__, "disk_name", disk_name)
        if disk_size_gb is not None:
            pulumi.set(__self__, "disk_size_gb", disk_size_gb)
        if disk_type is not None:
            pulumi.set(__self__, "disk_type", disk_type)
        if interface is not None:
            pulumi.set(__self__, "interface", interface)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if resource_policies is not None:
            pulumi.set(__self__, "resource_policies", resource_policies)
        if source is not None:
            pulumi.set(__self__, "source", source)
        if source_image is not None:
            pulumi.set(__self__, "source_image", source_image)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="autoDelete")
    def auto_delete(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether or not the disk should be auto-deleted.
        This defaults to true.
        """
        return pulumi.get(self, "auto_delete")

    @auto_delete.setter
    def auto_delete(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "auto_delete", value)

    @property
    @pulumi.getter
    def boot(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates that this is a boot disk.
        """
        return pulumi.get(self, "boot")

    @boot.setter
    def boot(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "boot", value)

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> Optional[pulumi.Input[str]]:
        """
        A unique device name that is reflected into the
        /dev/  tree of a Linux operating system running within the instance. If not
        specified, the server chooses a default device name to apply to this disk.
        """
        return pulumi.get(self, "device_name")

    @device_name.setter
    def device_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "device_name", value)

    @property
    @pulumi.getter(name="diskEncryptionKey")
    def disk_encryption_key(self) -> Optional[pulumi.Input['InstanceTemplateDiskDiskEncryptionKeyArgs']]:
        """
        Encrypts or decrypts a disk using a customer-supplied encryption key.
        """
        return pulumi.get(self, "disk_encryption_key")

    @disk_encryption_key.setter
    def disk_encryption_key(self, value: Optional[pulumi.Input['InstanceTemplateDiskDiskEncryptionKeyArgs']]):
        pulumi.set(self, "disk_encryption_key", value)

    @property
    @pulumi.getter(name="diskName")
    def disk_name(self) -> Optional[pulumi.Input[str]]:
        """
        Name of the disk. When not provided, this defaults
        to the name of the instance.
        """
        return pulumi.get(self, "disk_name")

    @disk_name.setter
    def disk_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_name", value)

    @property
    @pulumi.getter(name="diskSizeGb")
    def disk_size_gb(self) -> Optional[pulumi.Input[int]]:
        """
        The size of the image in gigabytes. If not
        specified, it will inherit the size of its base image. For SCRATCH disks,
        the size must be exactly 375GB.
        """
        return pulumi.get(self, "disk_size_gb")

    @disk_size_gb.setter
    def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "disk_size_gb", value)

    @property
    @pulumi.getter(name="diskType")
    def disk_type(self) -> Optional[pulumi.Input[str]]:
        """
        The GCE disk type. Such as `"pd-ssd"`, `"local-ssd"`,
        `"pd-balanced"` or `"pd-standard"`.
        """
        return pulumi.get(self, "disk_type")

    @disk_type.setter
    def disk_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_type", value)

    @property
    @pulumi.getter
    def interface(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the disk interface to use for attaching this disk,
        which is either SCSI or NVME. The default is SCSI. Persistent disks must always use SCSI
        and the request will fail if you attempt to attach a persistent disk in any other format
        than SCSI. Local SSDs can use either NVME or SCSI.
        """
        return pulumi.get(self, "interface")

    @interface.setter
    def interface(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "interface", value)

    @property
    @pulumi.getter
    def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        A set of ket/value label pairs to assign to disk created from
        this template
        """
        return pulumi.get(self, "labels")

    @labels.setter
    def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "labels", value)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[str]]:
        """
        The mode in which to attach this disk, either READ_WRITE
        or READ_ONLY. If you are attaching or creating a boot disk, this must
        read-write mode.
        """
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mode", value)

    @property
    @pulumi.getter(name="resourcePolicies")
    def resource_policies(self) -> Optional[pulumi.Input[str]]:
        """
        -- A list (short name or id) of resource policies to attach to this disk for automatic snapshot creations. Currently a max of 1 resource policy is supported.
        """
        return pulumi.get(self, "resource_policies")

    @resource_policies.setter
    def resource_policies(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resource_policies", value)

    @property
    @pulumi.getter
    def source(self) -> Optional[pulumi.Input[str]]:
        """
        The name (**not self_link**)
        of the disk (such as those managed by `compute.Disk`) to attach.
        > **Note:** Either `source` or `source_image` is **required** in a disk block unless the disk type is `local-ssd`. Check the API [docs](https://cloud.google.com/compute/docs/reference/rest/v1/instanceTemplates/insert) for details.
        """
        return pulumi.get(self, "source")

    @source.setter
    def source(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "source", value)

    @property
    @pulumi.getter(name="sourceImage")
    def source_image(self) -> Optional[pulumi.Input[str]]:
        """
        The image from which to
        initialize this disk. This can be one of: the image's `self_link`,
        `projects/{project}/global/images/{image}`,
        `projects/{project}/global/images/family/{family}`, `global/images/{image}`,
        `global/images/family/{family}`, `family/{family}`, `{project}/{family}`,
        `{project}/{image}`, `{family}`, or `{image}`.
        > **Note:** Either `source` or `source_image` is **required** in a disk block unless the disk type is `local-ssd`. Check the API [docs](https://cloud.google.com/compute/docs/reference/rest/v1/instanceTemplates/insert) for details.
        """
        return pulumi.get(self, "source_image")

    @source_image.setter
    def source_image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "source_image", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        The type of reservation from which this instance can consume resources.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class InstanceTemplateDiskDiskEncryptionKeyArgs:
    def __init__(__self__, *,
                 kms_key_self_link: pulumi.Input[str]):
        """
        :param pulumi.Input[str] kms_key_self_link: The self link of the encryption key that is stored in Google Cloud KMS
        """
        pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)

    @property
    @pulumi.getter(name="kmsKeySelfLink")
    def kms_key_self_link(self) -> pulumi.Input[str]:
        """
        The self link of the encryption key that is stored in Google Cloud KMS
        """
        return pulumi.get(self, "kms_key_self_link")

    @kms_key_self_link.setter
    def kms_key_self_link(self, value: pulumi.Input[str]):
        pulumi.set(self, "kms_key_self_link", value)


@pulumi.input_type
class InstanceTemplateGuestAcceleratorArgs:
    def __init__(__self__, *,
                 count: pulumi.Input[int],
                 type: pulumi.Input[str]):
        """
        :param pulumi.Input[int] count: The number of the guest accelerator cards exposed to this instance.
        :param pulumi.Input[str] type: The type of reservation from which this instance can consume resources.
        """
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def count(self) -> pulumi.Input[int]:
        """
        The number of the guest accelerator cards exposed to this instance.
        """
        return pulumi.get(self, "count")

    @count.setter
    def count(self, value: pulumi.Input[int]):
        pulumi.set(self, "count", value)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        The type of reservation from which this instance can consume resources.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class InstanceTemplateNetworkInterfaceArgs:
    def __init__(__self__, *,
                 access_configs: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceTemplateNetworkInterfaceAccessConfigArgs']]]] = None,
                 alias_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceTemplateNetworkInterfaceAliasIpRangeArgs']]]] = None,
                 ipv6_access_configs: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceTemplateNetworkInterfaceIpv6AccessConfigArgs']]]] = None,
                 ipv6_access_type: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 network: Optional[pulumi.Input[str]] = None,
                 network_ip: Optional[pulumi.Input[str]] = None,
                 nic_type: Optional[pulumi.Input[str]] = None,
                 queue_count: Optional[pulumi.Input[int]] = None,
                 stack_type: Optional[pulumi.Input[str]] = None,
                 subnetwork: Optional[pulumi.Input[str]] = None,
                 subnetwork_project: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['InstanceTemplateNetworkInterfaceAccessConfigArgs']]] access_configs: Access configurations, i.e. IPs via which this
               instance can be accessed via the Internet. Omit to ensure that the instance
               is not accessible from the Internet (this means that ssh provisioners will
               not work unless you can send traffic to the instance's
               network (e.g. via tunnel or because it is running on another cloud instance
               on that network). This block can be repeated multiple times. Structure documented below.
        :param pulumi.Input[Sequence[pulumi.Input['InstanceTemplateNetworkInterfaceAliasIpRangeArgs']]] alias_ip_ranges: An
               array of alias IP ranges for this network interface. Can only be specified for network
               interfaces on subnet-mode networks. Structure documented below.
        :param pulumi.Input[Sequence[pulumi.Input['InstanceTemplateNetworkInterfaceIpv6AccessConfigArgs']]] ipv6_access_configs: An array of IPv6 access configurations for this interface.
               Currently, only one IPv6 access config, DIRECT_IPV6, is supported. If there is no ipv6AccessConfig
               specified, then this instance will have no external IPv6 Internet access. Structure documented below.
        :param pulumi.Input[str] name: The name of the instance template. If you leave
               this blank, the provider will auto-generate a unique name.
        :param pulumi.Input[str] network: The name or self_link of the network to attach this interface to.
               Use `network` attribute for Legacy or Auto subnetted networks and
               `subnetwork` for custom subnetted networks.
        :param pulumi.Input[str] network_ip: The private IP address to assign to the instance. If
               empty, the address will be automatically assigned.
        :param pulumi.Input[str] nic_type: The type of vNIC to be used on this interface. Possible values: GVNIC, VIRTIO_NET.
        :param pulumi.Input[int] queue_count: The networking queue count that's specified by users for the network interface. Both Rx and Tx queues will be set to this number. It will be empty if not specified.
        :param pulumi.Input[str] stack_type: The stack type for this network interface to identify whether the IPv6 feature is enabled or not. Values are IPV4_IPV6 or IPV4_ONLY. If not specified, IPV4_ONLY will be used.
        :param pulumi.Input[str] subnetwork: the name of the subnetwork to attach this interface
               to. The subnetwork must exist in the same `region` this instance will be
               created in. Either `network` or `subnetwork` must be provided.
        :param pulumi.Input[str] subnetwork_project: The ID of the project in which the subnetwork belongs.
               If it is not provided, the provider project is used.
        """
        if access_configs is not None:
            pulumi.set(__self__, "access_configs", access_configs)
        if alias_ip_ranges is not None:
            pulumi.set(__self__, "alias_ip_ranges", alias_ip_ranges)
        if ipv6_access_configs is not None:
            pulumi.set(__self__, "ipv6_access_configs", ipv6_access_configs)
        if ipv6_access_type is not None:
            pulumi.set(__self__, "ipv6_access_type", ipv6_access_type)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if network is not None:
            pulumi.set(__self__, "network", network)
        if network_ip is not None:
            pulumi.set(__self__, "network_ip", network_ip)
        if nic_type is not None:
            pulumi.set(__self__, "nic_type", nic_type)
        if queue_count is not None:
            pulumi.set(__self__, "queue_count", queue_count)
        if stack_type is not None:
            pulumi.set(__self__, "stack_type", stack_type)
        if subnetwork is not None:
            pulumi.set(__self__, "subnetwork", subnetwork)
        if subnetwork_project is not None:
            pulumi.set(__self__, "subnetwork_project", subnetwork_project)

    @property
    @pulumi.getter(name="accessConfigs")
    def access_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceTemplateNetworkInterfaceAccessConfigArgs']]]]:
        """
        Access configurations, i.e. IPs via which this
        instance can be accessed via the Internet. Omit to ensure that the instance
        is not accessible from the Internet (this means that ssh provisioners will
        not work unless you can send traffic to the instance's
        network (e.g. via tunnel or because it is running on another cloud instance
        on that network). This block can be repeated multiple times. Structure documented below.
        """
        return pulumi.get(self, "access_configs")

    @access_configs.setter
    def access_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceTemplateNetworkInterfaceAccessConfigArgs']]]]):
        pulumi.set(self, "access_configs", value)

    @property
    @pulumi.getter(name="aliasIpRanges")
    def alias_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceTemplateNetworkInterfaceAliasIpRangeArgs']]]]:
        """
        An
        array of alias IP ranges for this network interface. Can only be specified for network
        interfaces on subnet-mode networks. Structure documented below.
        """
        return pulumi.get(self, "alias_ip_ranges")

    @alias_ip_ranges.setter
    def alias_ip_ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceTemplateNetworkInterfaceAliasIpRangeArgs']]]]):
        pulumi.set(self, "alias_ip_ranges", value)

    @property
    @pulumi.getter(name="ipv6AccessConfigs")
    def ipv6_access_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceTemplateNetworkInterfaceIpv6AccessConfigArgs']]]]:
        """
        An array of IPv6 access configurations for this interface.
        Currently, only one IPv6 access config, DIRECT_IPV6, is supported. If there is no ipv6AccessConfig
        specified, then this instance will have no external IPv6 Internet access. Structure documented below.
        """
        return pulumi.get(self, "ipv6_access_configs")

    @ipv6_access_configs.setter
    def ipv6_access_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceTemplateNetworkInterfaceIpv6AccessConfigArgs']]]]):
        pulumi.set(self, "ipv6_access_configs", value)

    @property
    @pulumi.getter(name="ipv6AccessType")
    def ipv6_access_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ipv6_access_type")

    @ipv6_access_type.setter
    def ipv6_access_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ipv6_access_type", value)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the instance template. If you leave
        this blank, the provider will auto-generate a unique name.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def network(self) -> Optional[pulumi.Input[str]]:
        """
        The name or self_link of the network to attach this interface to.
        Use `network` attribute for Legacy or Auto subnetted networks and
        `subnetwork` for custom subnetted networks.
        """
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network", value)

    @property
    @pulumi.getter(name="networkIp")
    def network_ip(self) -> Optional[pulumi.Input[str]]:
        """
        The private IP address to assign to the instance. If
        empty, the address will be automatically assigned.
        """
        return pulumi.get(self, "network_ip")

    @network_ip.setter
    def network_ip(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_ip", value)

    @property
    @pulumi.getter(name="nicType")
    def nic_type(self) -> Optional[pulumi.Input[str]]:
        """
        The type of vNIC to be used on this interface. Possible values: GVNIC, VIRTIO_NET.
        """
        return pulumi.get(self, "nic_type")

    @nic_type.setter
    def nic_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "nic_type", value)

    @property
    @pulumi.getter(name="queueCount")
    def queue_count(self) -> Optional[pulumi.Input[int]]:
        """
        The networking queue count that's specified by users for the network interface. Both Rx and Tx queues will be set to this number. It will be empty if not specified.
        """
        return pulumi.get(self, "queue_count")

    @queue_count.setter
    def queue_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "queue_count", value)

    @property
    @pulumi.getter(name="stackType")
    def stack_type(self) -> Optional[pulumi.Input[str]]:
        """
        The stack type for this network interface to identify whether the IPv6 feature is enabled or not. Values are IPV4_IPV6 or IPV4_ONLY. If not specified, IPV4_ONLY will be used.
        """
        return pulumi.get(self, "stack_type")

    @stack_type.setter
    def stack_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "stack_type", value)

    @property
    @pulumi.getter
    def subnetwork(self) -> Optional[pulumi.Input[str]]:
        """
        the name of the subnetwork to attach this interface
        to. The subnetwork must exist in the same `region` this instance will be
        created in. Either `network` or `subnetwork` must be provided.
        """
        return pulumi.get(self, "subnetwork")

    @subnetwork.setter
    def subnetwork(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnetwork", value)

    @property
    @pulumi.getter(name="subnetworkProject")
    def subnetwork_project(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the project in which the subnetwork belongs.
        If it is not provided, the provider project is used.
        """
        return pulumi.get(self, "subnetwork_project")

    @subnetwork_project.setter
    def subnetwork_project(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnetwork_project", value)


@pulumi.input_type
class InstanceTemplateNetworkInterfaceAccessConfigArgs:
    def __init__(__self__, *,
                 nat_ip: Optional[pulumi.Input[str]] = None,
                 network_tier: Optional[pulumi.Input[str]] = None,
                 public_ptr_domain_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] nat_ip: The IP address that will be 1:1 mapped to the instance's
               network ip. If not given, one will be generated.
        :param pulumi.Input[str] network_tier: The service-level to be provided for IPv6 traffic when the
               subnet has an external subnet. Only PREMIUM and STANDARD tier is valid for IPv6.
        """
        if nat_ip is not None:
            pulumi.set(__self__, "nat_ip", nat_ip)
        if network_tier is not None:
            pulumi.set(__self__, "network_tier", network_tier)
        if public_ptr_domain_name is not None:
            pulumi.set(__self__, "public_ptr_domain_name", public_ptr_domain_name)

    @property
    @pulumi.getter(name="natIp")
    def nat_ip(self) -> Optional[pulumi.Input[str]]:
        """
        The IP address that will be 1:1 mapped to the instance's
        network ip. If not given, one will be generated.
        """
        return pulumi.get(self, "nat_ip")

    @nat_ip.setter
    def nat_ip(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "nat_ip", value)

    @property
    @pulumi.getter(name="networkTier")
    def network_tier(self) -> Optional[pulumi.Input[str]]:
        """
        The service-level to be provided for IPv6 traffic when the
        subnet has an external subnet. Only PREMIUM and STANDARD tier is valid for IPv6.
        """
        return pulumi.get(self, "network_tier")

    @network_tier.setter
    def network_tier(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_tier", value)

    @property
    @pulumi.getter(name="publicPtrDomainName")
    def public_ptr_domain_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "public_ptr_domain_name")

    @public_ptr_domain_name.setter
    def public_ptr_domain_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "public_ptr_domain_name", value)


@pulumi.input_type
class InstanceTemplateNetworkInterfaceAliasIpRangeArgs:
    def __init__(__self__, *,
                 ip_cidr_range: pulumi.Input[str],
                 subnetwork_range_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] ip_cidr_range: The IP CIDR range represented by this alias IP range. This IP CIDR range
               must belong to the specified subnetwork and cannot contain IP addresses reserved by
               system or used by other network interfaces. At the time of writing only a
               netmask (e.g. /24) may be supplied, with a CIDR format resulting in an API
               error.
        :param pulumi.Input[str] subnetwork_range_name: The subnetwork secondary range name specifying
               the secondary range from which to allocate the IP CIDR range for this alias IP
               range. If left unspecified, the primary range of the subnetwork will be used.
        """
        pulumi.set(__self__, "ip_cidr_range", ip_cidr_range)
        if subnetwork_range_name is not None:
            pulumi.set(__self__, "subnetwork_range_name", subnetwork_range_name)

    @property
    @pulumi.getter(name="ipCidrRange")
    def ip_cidr_range(self) -> pulumi.Input[str]:
        """
        The IP CIDR range represented by this alias IP range. This IP CIDR range
        must belong to the specified subnetwork and cannot contain IP addresses reserved by
        system or used by other network interfaces. At the time of writing only a
        netmask (e.g. /24) may be supplied, with a CIDR format resulting in an API
        error.
        """
        return pulumi.get(self, "ip_cidr_range")

    @ip_cidr_range.setter
    def ip_cidr_range(self, value: pulumi.Input[str]):
        pulumi.set(self, "ip_cidr_range", value)

    @property
    @pulumi.getter(name="subnetworkRangeName")
    def subnetwork_range_name(self) -> Optional[pulumi.Input[str]]:
        """
        The subnetwork secondary range name specifying
        the secondary range from which to allocate the IP CIDR range for this alias IP
        range. If left unspecified, the primary range of the subnetwork will be used.
        """
        return pulumi.get(self, "subnetwork_range_name")

    @subnetwork_range_name.setter
    def subnetwork_range_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnetwork_range_name", value)


@pulumi.input_type
class InstanceTemplateNetworkInterfaceIpv6AccessConfigArgs:
    def __init__(__self__, *,
                 network_tier: pulumi.Input[str],
                 external_ipv6: Optional[pulumi.Input[str]] = None,
                 external_ipv6_prefix_length: Optional[pulumi.Input[str]] = None,
                 public_ptr_domain_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] network_tier: The service-level to be provided for IPv6 traffic when the
               subnet has an external subnet. Only PREMIUM and STANDARD tier is valid for IPv6.
        """
        pulumi.set(__self__, "network_tier", network_tier)
        if external_ipv6 is not None:
            pulumi.set(__self__, "external_ipv6", external_ipv6)
        if external_ipv6_prefix_length is not None:
            pulumi.set(__self__, "external_ipv6_prefix_length", external_ipv6_prefix_length)
        if public_ptr_domain_name is not None:
            pulumi.set(__self__, "public_ptr_domain_name", public_ptr_domain_name)

    @property
    @pulumi.getter(name="networkTier")
    def network_tier(self) -> pulumi.Input[str]:
        """
        The service-level to be provided for IPv6 traffic when the
        subnet has an external subnet. Only PREMIUM and STANDARD tier is valid for IPv6.
        """
        return pulumi.get(self, "network_tier")

    @network_tier.setter
    def network_tier(self, value: pulumi.Input[str]):
        pulumi.set(self, "network_tier", value)

    @property
    @pulumi.getter(name="externalIpv6")
    def external_ipv6(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "external_ipv6")

    @external_ipv6.setter
    def external_ipv6(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "external_ipv6", value)

    @property
    @pulumi.getter(name="externalIpv6PrefixLength")
    def external_ipv6_prefix_length(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "external_ipv6_prefix_length")

    @external_ipv6_prefix_length.setter
    def external_ipv6_prefix_length(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "external_ipv6_prefix_length", value)

    @property
    @pulumi.getter(name="publicPtrDomainName")
    def public_ptr_domain_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "public_ptr_domain_name")

    @public_ptr_domain_name.setter
    def public_ptr_domain_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "public_ptr_domain_name", value)


@pulumi.input_type
class InstanceTemplateNetworkPerformanceConfigArgs:
    def __init__(__self__, *,
                 total_egress_bandwidth_tier: pulumi.Input[str]):
        """
        :param pulumi.Input[str] total_egress_bandwidth_tier: The egress bandwidth tier to enable. Possible values: TIER_1, DEFAULT
        """
        pulumi.set(__self__, "total_egress_bandwidth_tier", total_egress_bandwidth_tier)

    @property
    @pulumi.getter(name="totalEgressBandwidthTier")
    def total_egress_bandwidth_tier(self) -> pulumi.Input[str]:
        """
        The egress bandwidth tier to enable. Possible values: TIER_1, DEFAULT
        """
        return pulumi.get(self, "total_egress_bandwidth_tier")

    @total_egress_bandwidth_tier.setter
    def total_egress_bandwidth_tier(self, value: pulumi.Input[str]):
        pulumi.set(self, "total_egress_bandwidth_tier", value)


@pulumi.input_type
class InstanceTemplateReservationAffinityArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str],
                 specific_reservation: Optional[pulumi.Input['InstanceTemplateReservationAffinitySpecificReservationArgs']] = None):
        """
        :param pulumi.Input[str] type: The type of reservation from which this instance can consume resources.
        :param pulumi.Input['InstanceTemplateReservationAffinitySpecificReservationArgs'] specific_reservation: Specifies the label selector for the reservation to use..
               Structure is documented below.
        """
        pulumi.set(__self__, "type", type)
        if specific_reservation is not None:
            pulumi.set(__self__, "specific_reservation", specific_reservation)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        The type of reservation from which this instance can consume resources.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter(name="specificReservation")
    def specific_reservation(self) -> Optional[pulumi.Input['InstanceTemplateReservationAffinitySpecificReservationArgs']]:
        """
        Specifies the label selector for the reservation to use..
        Structure is documented below.
        """
        return pulumi.get(self, "specific_reservation")

    @specific_reservation.setter
    def specific_reservation(self, value: Optional[pulumi.Input['InstanceTemplateReservationAffinitySpecificReservationArgs']]):
        pulumi.set(self, "specific_reservation", value)


@pulumi.input_type
class InstanceTemplateReservationAffinitySpecificReservationArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 values: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        :param pulumi.Input[str] key: Corresponds to the label key of a reservation resource. To target a SPECIFIC_RESERVATION by name, specify compute.googleapis.com/reservation-name as the key and specify the name of your reservation as the only value.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: Corresponds to the label values of a reservation resource.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        Corresponds to the label key of a reservation resource. To target a SPECIFIC_RESERVATION by name, specify compute.googleapis.com/reservation-name as the key and specify the name of your reservation as the only value.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def values(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        Corresponds to the label values of a reservation resource.
        """
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class InstanceTemplateSchedulingArgs:
    def __init__(__self__, *,
                 automatic_restart: Optional[pulumi.Input[bool]] = None,
                 instance_termination_action: Optional[pulumi.Input[str]] = None,
                 min_node_cpus: Optional[pulumi.Input[int]] = None,
                 node_affinities: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceTemplateSchedulingNodeAffinityArgs']]]] = None,
                 on_host_maintenance: Optional[pulumi.Input[str]] = None,
                 preemptible: Optional[pulumi.Input[bool]] = None,
                 provisioning_model: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] automatic_restart: Specifies whether the instance should be
               automatically restarted if it is terminated by Compute Engine (not
               terminated by a user). This defaults to true.
        :param pulumi.Input[str] instance_termination_action: Describe the type of termination action for `SPOT` VM. Can be `STOP` or `DELETE`.  Read more on [here](https://cloud.google.com/compute/docs/instances/create-use-spot)
        :param pulumi.Input[Sequence[pulumi.Input['InstanceTemplateSchedulingNodeAffinityArgs']]] node_affinities: Specifies node affinities or anti-affinities
               to determine which sole-tenant nodes your instances and managed instance
               groups will use as host systems. Read more on sole-tenant node creation
               [here](https://cloud.google.com/compute/docs/nodes/create-nodes).
               Structure documented below.
        :param pulumi.Input[str] on_host_maintenance: Defines the maintenance behavior for this
               instance.
        :param pulumi.Input[bool] preemptible: Allows instance to be preempted. This defaults to
               false. Read more on this
               [here](https://cloud.google.com/compute/docs/instances/preemptible).
        :param pulumi.Input[str] provisioning_model: Describe the type of preemptible VM. This field accepts the value `STANDARD` or `SPOT`. If the value is `STANDARD`, there will be no discount. If this   is set to `SPOT`, 
               `preemptible` should be `true` and `auto_restart` should be
               `false`. For more info about
               `SPOT`, read [here](https://cloud.google.com/compute/docs/instances/spot)
        """
        if automatic_restart is not None:
            pulumi.set(__self__, "automatic_restart", automatic_restart)
        if instance_termination_action is not None:
            pulumi.set(__self__, "instance_termination_action", instance_termination_action)
        if min_node_cpus is not None:
            pulumi.set(__self__, "min_node_cpus", min_node_cpus)
        if node_affinities is not None:
            pulumi.set(__self__, "node_affinities", node_affinities)
        if on_host_maintenance is not None:
            pulumi.set(__self__, "on_host_maintenance", on_host_maintenance)
        if preemptible is not None:
            pulumi.set(__self__, "preemptible", preemptible)
        if provisioning_model is not None:
            pulumi.set(__self__, "provisioning_model", provisioning_model)

    @property
    @pulumi.getter(name="automaticRestart")
    def automatic_restart(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies whether the instance should be
        automatically restarted if it is terminated by Compute Engine (not
        terminated by a user). This defaults to true.
        """
        return pulumi.get(self, "automatic_restart")

    @automatic_restart.setter
    def automatic_restart(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "automatic_restart", value)

    @property
    @pulumi.getter(name="instanceTerminationAction")
    def instance_termination_action(self) -> Optional[pulumi.Input[str]]:
        """
        Describe the type of termination action for `SPOT` VM. Can be `STOP` or `DELETE`.  Read more on [here](https://cloud.google.com/compute/docs/instances/create-use-spot)
        """
        return pulumi.get(self, "instance_termination_action")

    @instance_termination_action.setter
    def instance_termination_action(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "instance_termination_action", value)

    @property
    @pulumi.getter(name="minNodeCpus")
    def min_node_cpus(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "min_node_cpus")

    @min_node_cpus.setter
    def min_node_cpus(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_node_cpus", value)

    @property
    @pulumi.getter(name="nodeAffinities")
    def node_affinities(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceTemplateSchedulingNodeAffinityArgs']]]]:
        """
        Specifies node affinities or anti-affinities
        to determine which sole-tenant nodes your instances and managed instance
        groups will use as host systems. Read more on sole-tenant node creation
        [here](https://cloud.google.com/compute/docs/nodes/create-nodes).
        Structure documented below.
        """
        return pulumi.get(self, "node_affinities")

    @node_affinities.setter
    def node_affinities(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceTemplateSchedulingNodeAffinityArgs']]]]):
        pulumi.set(self, "node_affinities", value)

    @property
    @pulumi.getter(name="onHostMaintenance")
    def on_host_maintenance(self) -> Optional[pulumi.Input[str]]:
        """
        Defines the maintenance behavior for this
        instance.
        """
        return pulumi.get(self, "on_host_maintenance")

    @on_host_maintenance.setter
    def on_host_maintenance(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "on_host_maintenance", value)

    @property
    @pulumi.getter
    def preemptible(self) -> Optional[pulumi.Input[bool]]:
        """
        Allows instance to be preempted. This defaults to
        false. Read more on this
        [here](https://cloud.google.com/compute/docs/instances/preemptible).
        """
        return pulumi.get(self, "preemptible")

    @preemptible.setter
    def preemptible(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "preemptible", value)

    @property
    @pulumi.getter(name="provisioningModel")
    def provisioning_model(self) -> Optional[pulumi.Input[str]]:
        """
        Describe the type of preemptible VM. This field accepts the value `STANDARD` or `SPOT`. If the value is `STANDARD`, there will be no discount. If this   is set to `SPOT`, 
        `preemptible` should be `true` and `auto_restart` should be
        `false`. For more info about
        `SPOT`, read [here](https://cloud.google.com/compute/docs/instances/spot)
        """
        return pulumi.get(self, "provisioning_model")

    @provisioning_model.setter
    def provisioning_model(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "provisioning_model", value)


@pulumi.input_type
class InstanceTemplateSchedulingNodeAffinityArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 operator: pulumi.Input[str],
                 values: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        :param pulumi.Input[str] key: Corresponds to the label key of a reservation resource. To target a SPECIFIC_RESERVATION by name, specify compute.googleapis.com/reservation-name as the key and specify the name of your reservation as the only value.
        :param pulumi.Input[str] operator: The operator. Can be `IN` for node-affinities
               or `NOT_IN` for anti-affinities.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: Corresponds to the label values of a reservation resource.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        Corresponds to the label key of a reservation resource. To target a SPECIFIC_RESERVATION by name, specify compute.googleapis.com/reservation-name as the key and specify the name of your reservation as the only value.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def operator(self) -> pulumi.Input[str]:
        """
        The operator. Can be `IN` for node-affinities
        or `NOT_IN` for anti-affinities.
        """
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: pulumi.Input[str]):
        pulumi.set(self, "operator", value)

    @property
    @pulumi.getter
    def values(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        Corresponds to the label values of a reservation resource.
        """
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class InstanceTemplateServiceAccountArgs:
    def __init__(__self__, *,
                 scopes: pulumi.Input[Sequence[pulumi.Input[str]]],
                 email: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] scopes: A list of service scopes. Both OAuth2 URLs and gcloud
               short names are supported. To allow full access to all Cloud APIs, use the
               `cloud-platform` scope. See a complete list of scopes [here](https://cloud.google.com/sdk/gcloud/reference/alpha/compute/instances/set-scopes#--scopes).
        :param pulumi.Input[str] email: The service account e-mail address. If not given, the
               default Google Compute Engine service account is used.
        """
        pulumi.set(__self__, "scopes", scopes)
        if email is not None:
            pulumi.set(__self__, "email", email)

    @property
    @pulumi.getter
    def scopes(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        A list of service scopes. Both OAuth2 URLs and gcloud
        short names are supported. To allow full access to all Cloud APIs, use the
        `cloud-platform` scope. See a complete list of scopes [here](https://cloud.google.com/sdk/gcloud/reference/alpha/compute/instances/set-scopes#--scopes).
        """
        return pulumi.get(self, "scopes")

    @scopes.setter
    def scopes(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "scopes", value)

    @property
    @pulumi.getter
    def email(self) -> Optional[pulumi.Input[str]]:
        """
        The service account e-mail address. If not given, the
        default Google Compute Engine service account is used.
        """
        return pulumi.get(self, "email")

    @email.setter
    def email(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "email", value)


@pulumi.input_type
class InstanceTemplateShieldedInstanceConfigArgs:
    def __init__(__self__, *,
                 enable_integrity_monitoring: Optional[pulumi.Input[bool]] = None,
                 enable_secure_boot: Optional[pulumi.Input[bool]] = None,
                 enable_vtpm: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] enable_integrity_monitoring: -- Compare the most recent boot measurements to the integrity policy baseline and return a pair of pass/fail results depending on whether they match or not. Defaults to true.
        :param pulumi.Input[bool] enable_secure_boot: -- Verify the digital signature of all boot components, and halt the boot process if signature verification fails. Defaults to false.
        :param pulumi.Input[bool] enable_vtpm: -- Use a virtualized trusted platform module, which is a specialized computer chip you can use to encrypt objects like keys and certificates. Defaults to true.
        """
        if enable_integrity_monitoring is not None:
            pulumi.set(__self__, "enable_integrity_monitoring", enable_integrity_monitoring)
        if enable_secure_boot is not None:
            pulumi.set(__self__, "enable_secure_boot", enable_secure_boot)
        if enable_vtpm is not None:
            pulumi.set(__self__, "enable_vtpm", enable_vtpm)

    @property
    @pulumi.getter(name="enableIntegrityMonitoring")
    def enable_integrity_monitoring(self) -> Optional[pulumi.Input[bool]]:
        """
        -- Compare the most recent boot measurements to the integrity policy baseline and return a pair of pass/fail results depending on whether they match or not. Defaults to true.
        """
        return pulumi.get(self, "enable_integrity_monitoring")

    @enable_integrity_monitoring.setter
    def enable_integrity_monitoring(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_integrity_monitoring", value)

    @property
    @pulumi.getter(name="enableSecureBoot")
    def enable_secure_boot(self) -> Optional[pulumi.Input[bool]]:
        """
        -- Verify the digital signature of all boot components, and halt the boot process if signature verification fails. Defaults to false.
        """
        return pulumi.get(self, "enable_secure_boot")

    @enable_secure_boot.setter
    def enable_secure_boot(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_secure_boot", value)

    @property
    @pulumi.getter(name="enableVtpm")
    def enable_vtpm(self) -> Optional[pulumi.Input[bool]]:
        """
        -- Use a virtualized trusted platform module, which is a specialized computer chip you can use to encrypt objects like keys and certificates. Defaults to true.
        """
        return pulumi.get(self, "enable_vtpm")

    @enable_vtpm.setter
    def enable_vtpm(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_vtpm", value)


@pulumi.input_type
class InterconnectAttachmentPrivateInterconnectInfoArgs:
    def __init__(__self__, *,
                 tag8021q: Optional[pulumi.Input[int]] = None):
        if tag8021q is not None:
            pulumi.set(__self__, "tag8021q", tag8021q)

    @property
    @pulumi.getter
    def tag8021q(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "tag8021q")

    @tag8021q.setter
    def tag8021q(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "tag8021q", value)


@pulumi.input_type
class MachineImageIamBindingConditionArgs:
    def __init__(__self__, *,
                 expression: pulumi.Input[str],
                 title: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] expression: Textual representation of an expression in Common Expression Language syntax.
        :param pulumi.Input[str] title: A title for the expression, i.e. a short string describing its purpose.
        :param pulumi.Input[str] description: An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "title", title)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter
    def title(self) -> pulumi.Input[str]:
        """
        A title for the expression, i.e. a short string describing its purpose.
        """
        return pulumi.get(self, "title")

    @title.setter
    def title(self, value: pulumi.Input[str]):
        pulumi.set(self, "title", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class MachineImageIamMemberConditionArgs:
    def __init__(__self__, *,
                 expression: pulumi.Input[str],
                 title: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] expression: Textual representation of an expression in Common Expression Language syntax.
        :param pulumi.Input[str] title: A title for the expression, i.e. a short string describing its purpose.
        :param pulumi.Input[str] description: An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "title", title)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter
    def title(self) -> pulumi.Input[str]:
        """
        A title for the expression, i.e. a short string describing its purpose.
        """
        return pulumi.get(self, "title")

    @title.setter
    def title(self, value: pulumi.Input[str]):
        pulumi.set(self, "title", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class MachineImageMachineImageEncryptionKeyArgs:
    def __init__(__self__, *,
                 kms_key_name: Optional[pulumi.Input[str]] = None,
                 kms_key_service_account: Optional[pulumi.Input[str]] = None,
                 raw_key: Optional[pulumi.Input[str]] = None,
                 sha256: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] kms_key_name: The name of the encryption key that is stored in Google Cloud KMS.
        :param pulumi.Input[str] kms_key_service_account: The service account used for the encryption request for the given KMS key.
               If absent, the Compute Engine Service Agent service account is used.
        :param pulumi.Input[str] raw_key: Specifies a 256-bit customer-supplied encryption key, encoded in
               RFC 4648 base64 to either encrypt or decrypt this resource.
        :param pulumi.Input[str] sha256: -
               The RFC 4648 base64 encoded SHA-256 hash of the
               customer-supplied encryption key that protects this resource.
        """
        if kms_key_name is not None:
            pulumi.set(__self__, "kms_key_name", kms_key_name)
        if kms_key_service_account is not None:
            pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
        if raw_key is not None:
            pulumi.set(__self__, "raw_key", raw_key)
        if sha256 is not None:
            pulumi.set(__self__, "sha256", sha256)

    @property
    @pulumi.getter(name="kmsKeyName")
    def kms_key_name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the encryption key that is stored in Google Cloud KMS.
        """
        return pulumi.get(self, "kms_key_name")

    @kms_key_name.setter
    def kms_key_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_name", value)

    @property
    @pulumi.getter(name="kmsKeyServiceAccount")
    def kms_key_service_account(self) -> Optional[pulumi.Input[str]]:
        """
        The service account used for the encryption request for the given KMS key.
        If absent, the Compute Engine Service Agent service account is used.
        """
        return pulumi.get(self, "kms_key_service_account")

    @kms_key_service_account.setter
    def kms_key_service_account(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_service_account", value)

    @property
    @pulumi.getter(name="rawKey")
    def raw_key(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies a 256-bit customer-supplied encryption key, encoded in
        RFC 4648 base64 to either encrypt or decrypt this resource.
        """
        return pulumi.get(self, "raw_key")

    @raw_key.setter
    def raw_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "raw_key", value)

    @property
    @pulumi.getter
    def sha256(self) -> Optional[pulumi.Input[str]]:
        """
        -
        The RFC 4648 base64 encoded SHA-256 hash of the
        customer-supplied encryption key that protects this resource.
        """
        return pulumi.get(self, "sha256")

    @sha256.setter
    def sha256(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sha256", value)


@pulumi.input_type
class ManagedSslCertificateManagedArgs:
    def __init__(__self__, *,
                 domains: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] domains: Domains for which a managed SSL certificate will be valid.  Currently,
               there can be up to 100 domains in this list.
        """
        pulumi.set(__self__, "domains", domains)

    @property
    @pulumi.getter
    def domains(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        Domains for which a managed SSL certificate will be valid.  Currently,
        there can be up to 100 domains in this list.
        """
        return pulumi.get(self, "domains")

    @domains.setter
    def domains(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "domains", value)


@pulumi.input_type
class MangedSslCertificateManagedArgs:
    def __init__(__self__, *,
                 domains: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] domains: Domains for which a managed SSL certificate will be valid.  Currently,
               there can be up to 100 domains in this list.
        """
        pulumi.set(__self__, "domains", domains)

    @property
    @pulumi.getter
    def domains(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        Domains for which a managed SSL certificate will be valid.  Currently,
        there can be up to 100 domains in this list.
        """
        return pulumi.get(self, "domains")

    @domains.setter
    def domains(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "domains", value)


@pulumi.input_type
class NodeGroupAutoscalingPolicyArgs:
    def __init__(__self__, *,
                 max_nodes: Optional[pulumi.Input[int]] = None,
                 min_nodes: Optional[pulumi.Input[int]] = None,
                 mode: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] max_nodes: Maximum size of the node group. Set to a value less than or equal
               to 100 and greater than or equal to min-nodes.
        :param pulumi.Input[int] min_nodes: Minimum size of the node group. Must be less
               than or equal to max-nodes. The default value is 0.
        :param pulumi.Input[str] mode: The autoscaling mode. Set to one of the following:
               - OFF: Disables the autoscaler.
               - ON: Enables scaling in and scaling out.
               - ONLY_SCALE_OUT: Enables only scaling out.
               You must use this mode if your node groups are configured to
               restart their hosted VMs on minimal servers.
               Possible values are `OFF`, `ON`, and `ONLY_SCALE_OUT`.
        """
        if max_nodes is not None:
            pulumi.set(__self__, "max_nodes", max_nodes)
        if min_nodes is not None:
            pulumi.set(__self__, "min_nodes", min_nodes)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter(name="maxNodes")
    def max_nodes(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum size of the node group. Set to a value less than or equal
        to 100 and greater than or equal to min-nodes.
        """
        return pulumi.get(self, "max_nodes")

    @max_nodes.setter
    def max_nodes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_nodes", value)

    @property
    @pulumi.getter(name="minNodes")
    def min_nodes(self) -> Optional[pulumi.Input[int]]:
        """
        Minimum size of the node group. Must be less
        than or equal to max-nodes. The default value is 0.
        """
        return pulumi.get(self, "min_nodes")

    @min_nodes.setter
    def min_nodes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_nodes", value)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[str]]:
        """
        The autoscaling mode. Set to one of the following:
        - OFF: Disables the autoscaler.
        - ON: Enables scaling in and scaling out.
        - ONLY_SCALE_OUT: Enables only scaling out.
        You must use this mode if your node groups are configured to
        restart their hosted VMs on minimal servers.
        Possible values are `OFF`, `ON`, and `ONLY_SCALE_OUT`.
        """
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mode", value)


@pulumi.input_type
class NodeGroupMaintenanceWindowArgs:
    def __init__(__self__, *,
                 start_time: pulumi.Input[str]):
        """
        :param pulumi.Input[str] start_time: instances.start time of the window. This must be in UTC format that resolves to one of 00:00, 04:00, 08:00, 12:00, 16:00, or 20:00. For example, both 13:00-5 and 08:00 are valid.
        """
        pulumi.set(__self__, "start_time", start_time)

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> pulumi.Input[str]:
        """
        instances.start time of the window. This must be in UTC format that resolves to one of 00:00, 04:00, 08:00, 12:00, 16:00, or 20:00. For example, both 13:00-5 and 08:00 are valid.
        """
        return pulumi.get(self, "start_time")

    @start_time.setter
    def start_time(self, value: pulumi.Input[str]):
        pulumi.set(self, "start_time", value)


@pulumi.input_type
class NodeTemplateNodeTypeFlexibilityArgs:
    def __init__(__self__, *,
                 cpus: Optional[pulumi.Input[str]] = None,
                 local_ssd: Optional[pulumi.Input[str]] = None,
                 memory: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] cpus: Number of virtual CPUs to use.
        :param pulumi.Input[str] local_ssd: -
               Use local SSD
        :param pulumi.Input[str] memory: Physical memory available to the node, defined in MB.
        """
        if cpus is not None:
            pulumi.set(__self__, "cpus", cpus)
        if local_ssd is not None:
            pulumi.set(__self__, "local_ssd", local_ssd)
        if memory is not None:
            pulumi.set(__self__, "memory", memory)

    @property
    @pulumi.getter
    def cpus(self) -> Optional[pulumi.Input[str]]:
        """
        Number of virtual CPUs to use.
        """
        return pulumi.get(self, "cpus")

    @cpus.setter
    def cpus(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cpus", value)

    @property
    @pulumi.getter(name="localSsd")
    def local_ssd(self) -> Optional[pulumi.Input[str]]:
        """
        -
        Use local SSD
        """
        return pulumi.get(self, "local_ssd")

    @local_ssd.setter
    def local_ssd(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "local_ssd", value)

    @property
    @pulumi.getter
    def memory(self) -> Optional[pulumi.Input[str]]:
        """
        Physical memory available to the node, defined in MB.
        """
        return pulumi.get(self, "memory")

    @memory.setter
    def memory(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "memory", value)


@pulumi.input_type
class NodeTemplateServerBindingArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str]):
        """
        :param pulumi.Input[str] type: Type of server binding policy. If `RESTART_NODE_ON_ANY_SERVER`,
               nodes using this template will restart on any physical server
               following a maintenance event.
               If `RESTART_NODE_ON_MINIMAL_SERVER`, nodes using this template
               will restart on the same physical server following a maintenance
               event, instead of being live migrated to or restarted on a new
               physical server. This option may be useful if you are using
               software licenses tied to the underlying server characteristics
               such as physical sockets or cores, to avoid the need for
               additional licenses when maintenance occurs. However, VMs on such
               nodes will experience outages while maintenance is applied.
               Possible values are `RESTART_NODE_ON_ANY_SERVER` and `RESTART_NODE_ON_MINIMAL_SERVERS`.
        """
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        Type of server binding policy. If `RESTART_NODE_ON_ANY_SERVER`,
        nodes using this template will restart on any physical server
        following a maintenance event.
        If `RESTART_NODE_ON_MINIMAL_SERVER`, nodes using this template
        will restart on the same physical server following a maintenance
        event, instead of being live migrated to or restarted on a new
        physical server. This option may be useful if you are using
        software licenses tied to the underlying server characteristics
        such as physical sockets or cores, to avoid the need for
        additional licenses when maintenance occurs. However, VMs on such
        nodes will experience outages while maintenance is applied.
        Possible values are `RESTART_NODE_ON_ANY_SERVER` and `RESTART_NODE_ON_MINIMAL_SERVERS`.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class OrganizationSecurityPolicyRuleMatchArgs:
    def __init__(__self__, *,
                 config: pulumi.Input['OrganizationSecurityPolicyRuleMatchConfigArgs'],
                 description: Optional[pulumi.Input[str]] = None,
                 versioned_expr: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['OrganizationSecurityPolicyRuleMatchConfigArgs'] config: The configuration options for matching the rule.
               Structure is documented below.
        :param pulumi.Input[str] description: A description of the rule.
        :param pulumi.Input[str] versioned_expr: Preconfigured versioned expression. For organization security policy rules,
               the only supported type is "FIREWALL".
               Default value is `FIREWALL`.
               Possible values are `FIREWALL`.
        """
        pulumi.set(__self__, "config", config)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if versioned_expr is not None:
            pulumi.set(__self__, "versioned_expr", versioned_expr)

    @property
    @pulumi.getter
    def config(self) -> pulumi.Input['OrganizationSecurityPolicyRuleMatchConfigArgs']:
        """
        The configuration options for matching the rule.
        Structure is documented below.
        """
        return pulumi.get(self, "config")

    @config.setter
    def config(self, value: pulumi.Input['OrganizationSecurityPolicyRuleMatchConfigArgs']):
        pulumi.set(self, "config", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        A description of the rule.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)

    @property
    @pulumi.getter(name="versionedExpr")
    def versioned_expr(self) -> Optional[pulumi.Input[str]]:
        """
        Preconfigured versioned expression. For organization security policy rules,
        the only supported type is "FIREWALL".
        Default value is `FIREWALL`.
        Possible values are `FIREWALL`.
        """
        return pulumi.get(self, "versioned_expr")

    @versioned_expr.setter
    def versioned_expr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "versioned_expr", value)


@pulumi.input_type
class OrganizationSecurityPolicyRuleMatchConfigArgs:
    def __init__(__self__, *,
                 layer4_configs: pulumi.Input[Sequence[pulumi.Input['OrganizationSecurityPolicyRuleMatchConfigLayer4ConfigArgs']]],
                 dest_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 src_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['OrganizationSecurityPolicyRuleMatchConfigLayer4ConfigArgs']]] layer4_configs: Pairs of IP protocols and ports that the rule should match.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] dest_ip_ranges: Destination IP address range in CIDR format. Required for
               EGRESS rules.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] src_ip_ranges: Source IP address range in CIDR format. Required for
               INGRESS rules.
        """
        pulumi.set(__self__, "layer4_configs", layer4_configs)
        if dest_ip_ranges is not None:
            pulumi.set(__self__, "dest_ip_ranges", dest_ip_ranges)
        if src_ip_ranges is not None:
            pulumi.set(__self__, "src_ip_ranges", src_ip_ranges)

    @property
    @pulumi.getter(name="layer4Configs")
    def layer4_configs(self) -> pulumi.Input[Sequence[pulumi.Input['OrganizationSecurityPolicyRuleMatchConfigLayer4ConfigArgs']]]:
        """
        Pairs of IP protocols and ports that the rule should match.
        Structure is documented below.
        """
        return pulumi.get(self, "layer4_configs")

    @layer4_configs.setter
    def layer4_configs(self, value: pulumi.Input[Sequence[pulumi.Input['OrganizationSecurityPolicyRuleMatchConfigLayer4ConfigArgs']]]):
        pulumi.set(self, "layer4_configs", value)

    @property
    @pulumi.getter(name="destIpRanges")
    def dest_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Destination IP address range in CIDR format. Required for
        EGRESS rules.
        """
        return pulumi.get(self, "dest_ip_ranges")

    @dest_ip_ranges.setter
    def dest_ip_ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "dest_ip_ranges", value)

    @property
    @pulumi.getter(name="srcIpRanges")
    def src_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Source IP address range in CIDR format. Required for
        INGRESS rules.
        """
        return pulumi.get(self, "src_ip_ranges")

    @src_ip_ranges.setter
    def src_ip_ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "src_ip_ranges", value)


@pulumi.input_type
class OrganizationSecurityPolicyRuleMatchConfigLayer4ConfigArgs:
    def __init__(__self__, *,
                 ip_protocol: pulumi.Input[str],
                 ports: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] ip_protocol: The IP protocol to which this rule applies. The protocol
               type is required when creating a firewall rule.
               This value can either be one of the following well
               known protocol strings (tcp, udp, icmp, esp, ah, ipip, sctp),
               or the IP protocol number.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ports: An optional list of ports to which this rule applies. This field
               is only applicable for UDP or TCP protocol. Each entry must be
               either an integer or a range. If not specified, this rule
               applies to connections through any port.
               Example inputs include: ["22"], ["80","443"], and
               ["12345-12349"].
        """
        pulumi.set(__self__, "ip_protocol", ip_protocol)
        if ports is not None:
            pulumi.set(__self__, "ports", ports)

    @property
    @pulumi.getter(name="ipProtocol")
    def ip_protocol(self) -> pulumi.Input[str]:
        """
        The IP protocol to which this rule applies. The protocol
        type is required when creating a firewall rule.
        This value can either be one of the following well
        known protocol strings (tcp, udp, icmp, esp, ah, ipip, sctp),
        or the IP protocol number.
        """
        return pulumi.get(self, "ip_protocol")

    @ip_protocol.setter
    def ip_protocol(self, value: pulumi.Input[str]):
        pulumi.set(self, "ip_protocol", value)

    @property
    @pulumi.getter
    def ports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        An optional list of ports to which this rule applies. This field
        is only applicable for UDP or TCP protocol. Each entry must be
        either an integer or a range. If not specified, this rule
        applies to connections through any port.
        Example inputs include: ["22"], ["80","443"], and
        ["12345-12349"].
        """
        return pulumi.get(self, "ports")

    @ports.setter
    def ports(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ports", value)


@pulumi.input_type
class PacketMirroringCollectorIlbArgs:
    def __init__(__self__, *,
                 url: pulumi.Input[str]):
        """
        :param pulumi.Input[str] url: The URL of the instances where this rule should be active.
        """
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def url(self) -> pulumi.Input[str]:
        """
        The URL of the instances where this rule should be active.
        """
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: pulumi.Input[str]):
        pulumi.set(self, "url", value)


@pulumi.input_type
class PacketMirroringFilterArgs:
    def __init__(__self__, *,
                 cidr_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 direction: Optional[pulumi.Input[str]] = None,
                 ip_protocols: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] cidr_ranges: IP CIDR ranges that apply as a filter on the source (ingress) or
               destination (egress) IP in the IP header. Only IPv4 is supported.
        :param pulumi.Input[str] direction: Direction of traffic to mirror.
               Default value is `BOTH`.
               Possible values are `INGRESS`, `EGRESS`, and `BOTH`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_protocols: Possible IP protocols including tcp, udp, icmp and esp
        """
        if cidr_ranges is not None:
            pulumi.set(__self__, "cidr_ranges", cidr_ranges)
        if direction is not None:
            pulumi.set(__self__, "direction", direction)
        if ip_protocols is not None:
            pulumi.set(__self__, "ip_protocols", ip_protocols)

    @property
    @pulumi.getter(name="cidrRanges")
    def cidr_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        IP CIDR ranges that apply as a filter on the source (ingress) or
        destination (egress) IP in the IP header. Only IPv4 is supported.
        """
        return pulumi.get(self, "cidr_ranges")

    @cidr_ranges.setter
    def cidr_ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "cidr_ranges", value)

    @property
    @pulumi.getter
    def direction(self) -> Optional[pulumi.Input[str]]:
        """
        Direction of traffic to mirror.
        Default value is `BOTH`.
        Possible values are `INGRESS`, `EGRESS`, and `BOTH`.
        """
        return pulumi.get(self, "direction")

    @direction.setter
    def direction(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "direction", value)

    @property
    @pulumi.getter(name="ipProtocols")
    def ip_protocols(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Possible IP protocols including tcp, udp, icmp and esp
        """
        return pulumi.get(self, "ip_protocols")

    @ip_protocols.setter
    def ip_protocols(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_protocols", value)


@pulumi.input_type
class PacketMirroringMirroredResourcesArgs:
    def __init__(__self__, *,
                 instances: Optional[pulumi.Input[Sequence[pulumi.Input['PacketMirroringMirroredResourcesInstanceArgs']]]] = None,
                 subnetworks: Optional[pulumi.Input[Sequence[pulumi.Input['PacketMirroringMirroredResourcesSubnetworkArgs']]]] = None,
                 tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['PacketMirroringMirroredResourcesInstanceArgs']]] instances: All the listed instances will be mirrored.  Specify at most 50.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['PacketMirroringMirroredResourcesSubnetworkArgs']]] subnetworks: All instances in one of these subnetworks will be mirrored.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: All instances with these tags will be mirrored.
        """
        if instances is not None:
            pulumi.set(__self__, "instances", instances)
        if subnetworks is not None:
            pulumi.set(__self__, "subnetworks", subnetworks)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter
    def instances(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PacketMirroringMirroredResourcesInstanceArgs']]]]:
        """
        All the listed instances will be mirrored.  Specify at most 50.
        Structure is documented below.
        """
        return pulumi.get(self, "instances")

    @instances.setter
    def instances(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PacketMirroringMirroredResourcesInstanceArgs']]]]):
        pulumi.set(self, "instances", value)

    @property
    @pulumi.getter
    def subnetworks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PacketMirroringMirroredResourcesSubnetworkArgs']]]]:
        """
        All instances in one of these subnetworks will be mirrored.
        Structure is documented below.
        """
        return pulumi.get(self, "subnetworks")

    @subnetworks.setter
    def subnetworks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PacketMirroringMirroredResourcesSubnetworkArgs']]]]):
        pulumi.set(self, "subnetworks", value)

    @property
    @pulumi.getter
    def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        All instances with these tags will be mirrored.
        """
        return pulumi.get(self, "tags")

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "tags", value)


@pulumi.input_type
class PacketMirroringMirroredResourcesInstanceArgs:
    def __init__(__self__, *,
                 url: pulumi.Input[str]):
        """
        :param pulumi.Input[str] url: The URL of the instances where this rule should be active.
        """
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def url(self) -> pulumi.Input[str]:
        """
        The URL of the instances where this rule should be active.
        """
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: pulumi.Input[str]):
        pulumi.set(self, "url", value)


@pulumi.input_type
class PacketMirroringMirroredResourcesSubnetworkArgs:
    def __init__(__self__, *,
                 url: pulumi.Input[str]):
        """
        :param pulumi.Input[str] url: The URL of the instances where this rule should be active.
        """
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def url(self) -> pulumi.Input[str]:
        """
        The URL of the instances where this rule should be active.
        """
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: pulumi.Input[str]):
        pulumi.set(self, "url", value)


@pulumi.input_type
class PacketMirroringNetworkArgs:
    def __init__(__self__, *,
                 url: pulumi.Input[str]):
        """
        :param pulumi.Input[str] url: The URL of the instances where this rule should be active.
        """
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def url(self) -> pulumi.Input[str]:
        """
        The URL of the instances where this rule should be active.
        """
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: pulumi.Input[str]):
        pulumi.set(self, "url", value)


@pulumi.input_type
class PerInstanceConfigPreservedStateArgs:
    def __init__(__self__, *,
                 disks: Optional[pulumi.Input[Sequence[pulumi.Input['PerInstanceConfigPreservedStateDiskArgs']]]] = None,
                 metadata: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['PerInstanceConfigPreservedStateDiskArgs']]] disks: Stateful disks for the instance.
               Structure is documented below.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] metadata: Preserved metadata defined for this instance. This is a list of key->value pairs.
        """
        if disks is not None:
            pulumi.set(__self__, "disks", disks)
        if metadata is not None:
            pulumi.set(__self__, "metadata", metadata)

    @property
    @pulumi.getter
    def disks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PerInstanceConfigPreservedStateDiskArgs']]]]:
        """
        Stateful disks for the instance.
        Structure is documented below.
        """
        return pulumi.get(self, "disks")

    @disks.setter
    def disks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PerInstanceConfigPreservedStateDiskArgs']]]]):
        pulumi.set(self, "disks", value)

    @property
    @pulumi.getter
    def metadata(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        Preserved metadata defined for this instance. This is a list of key->value pairs.
        """
        return pulumi.get(self, "metadata")

    @metadata.setter
    def metadata(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "metadata", value)


@pulumi.input_type
class PerInstanceConfigPreservedStateDiskArgs:
    def __init__(__self__, *,
                 device_name: pulumi.Input[str],
                 source: pulumi.Input[str],
                 delete_rule: Optional[pulumi.Input[str]] = None,
                 mode: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] device_name: A unique device name that is reflected into the /dev/ tree of a Linux operating system running within the instance.
        :param pulumi.Input[str] source: The URI of an existing persistent disk to attach under the specified device-name in the format
               `projects/project-id/zones/zone/disks/disk-name`.
        :param pulumi.Input[str] delete_rule: A value that prescribes what should happen to the stateful disk when the VM instance is deleted.
               The available options are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`.
               `NEVER` - detach the disk when the VM is deleted, but do not delete the disk.
               `ON_PERMANENT_INSTANCE_DELETION` will delete the stateful disk when the VM is permanently
               deleted from the instance group.
               Default value is `NEVER`.
               Possible values are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`.
        :param pulumi.Input[str] mode: The mode of the disk.
               Default value is `READ_WRITE`.
               Possible values are `READ_ONLY` and `READ_WRITE`.
        """
        pulumi.set(__self__, "device_name", device_name)
        pulumi.set(__self__, "source", source)
        if delete_rule is not None:
            pulumi.set(__self__, "delete_rule", delete_rule)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> pulumi.Input[str]:
        """
        A unique device name that is reflected into the /dev/ tree of a Linux operating system running within the instance.
        """
        return pulumi.get(self, "device_name")

    @device_name.setter
    def device_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "device_name", value)

    @property
    @pulumi.getter
    def source(self) -> pulumi.Input[str]:
        """
        The URI of an existing persistent disk to attach under the specified device-name in the format
        `projects/project-id/zones/zone/disks/disk-name`.
        """
        return pulumi.get(self, "source")

    @source.setter
    def source(self, value: pulumi.Input[str]):
        pulumi.set(self, "source", value)

    @property
    @pulumi.getter(name="deleteRule")
    def delete_rule(self) -> Optional[pulumi.Input[str]]:
        """
        A value that prescribes what should happen to the stateful disk when the VM instance is deleted.
        The available options are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`.
        `NEVER` - detach the disk when the VM is deleted, but do not delete the disk.
        `ON_PERMANENT_INSTANCE_DELETION` will delete the stateful disk when the VM is permanently
        deleted from the instance group.
        Default value is `NEVER`.
        Possible values are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`.
        """
        return pulumi.get(self, "delete_rule")

    @delete_rule.setter
    def delete_rule(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "delete_rule", value)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[str]]:
        """
        The mode of the disk.
        Default value is `READ_WRITE`.
        Possible values are `READ_ONLY` and `READ_WRITE`.
        """
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mode", value)


@pulumi.input_type
class RegionAutoscalerAutoscalingPolicyArgs:
    def __init__(__self__, *,
                 max_replicas: pulumi.Input[int],
                 min_replicas: pulumi.Input[int],
                 cooldown_period: Optional[pulumi.Input[int]] = None,
                 cpu_utilization: Optional[pulumi.Input['RegionAutoscalerAutoscalingPolicyCpuUtilizationArgs']] = None,
                 load_balancing_utilization: Optional[pulumi.Input['RegionAutoscalerAutoscalingPolicyLoadBalancingUtilizationArgs']] = None,
                 metrics: Optional[pulumi.Input[Sequence[pulumi.Input['RegionAutoscalerAutoscalingPolicyMetricArgs']]]] = None,
                 mode: Optional[pulumi.Input[str]] = None,
                 scale_down_control: Optional[pulumi.Input['RegionAutoscalerAutoscalingPolicyScaleDownControlArgs']] = None,
                 scale_in_control: Optional[pulumi.Input['RegionAutoscalerAutoscalingPolicyScaleInControlArgs']] = None,
                 scaling_schedules: Optional[pulumi.Input[Sequence[pulumi.Input['RegionAutoscalerAutoscalingPolicyScalingScheduleArgs']]]] = None):
        """
        :param pulumi.Input[int] max_replicas: The maximum number of instances that the autoscaler can scale up
               to. This is required when creating or updating an autoscaler. The
               maximum number of replicas should not be lower than minimal number
               of replicas.
        :param pulumi.Input[int] min_replicas: The minimum number of replicas that the autoscaler can scale down
               to. This cannot be less than 0. If not provided, autoscaler will
               choose a default value depending on maximum number of instances
               allowed.
        :param pulumi.Input[int] cooldown_period: The number of seconds that the autoscaler should wait before it
               starts collecting information from a new instance. This prevents
               the autoscaler from collecting information when the instance is
               initializing, during which the collected usage would not be
               reliable. The default time autoscaler waits is 60 seconds.
               Virtual machine initialization times might vary because of
               numerous factors. We recommend that you test how long an
               instance may take to initialize. To do this, create an instance
               and time the startup process.
        :param pulumi.Input['RegionAutoscalerAutoscalingPolicyCpuUtilizationArgs'] cpu_utilization: Defines the CPU utilization policy that allows the autoscaler to
               scale based on the average CPU utilization of a managed instance
               group.
               Structure is documented below.
        :param pulumi.Input['RegionAutoscalerAutoscalingPolicyLoadBalancingUtilizationArgs'] load_balancing_utilization: Configuration parameters of autoscaling based on a load balancer.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['RegionAutoscalerAutoscalingPolicyMetricArgs']]] metrics: Configuration parameters of autoscaling based on a custom metric.
               Structure is documented below.
        :param pulumi.Input[str] mode: Defines operating mode for this policy.
               Default value is `ON`.
               Possible values are `OFF`, `ONLY_UP`, and `ON`.
        :param pulumi.Input['RegionAutoscalerAutoscalingPolicyScaleDownControlArgs'] scale_down_control: Defines scale down controls to reduce the risk of response latency
               and outages due to abrupt scale-in events
               Structure is documented below.
        :param pulumi.Input['RegionAutoscalerAutoscalingPolicyScaleInControlArgs'] scale_in_control: Defines scale in controls to reduce the risk of response latency
               and outages due to abrupt scale-in events
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['RegionAutoscalerAutoscalingPolicyScalingScheduleArgs']]] scaling_schedules: Scaling schedules defined for an autoscaler. Multiple schedules can be set on an autoscaler and they can overlap.
               Structure is documented below.
        """
        pulumi.set(__self__, "max_replicas", max_replicas)
        pulumi.set(__self__, "min_replicas", min_replicas)
        if cooldown_period is not None:
            pulumi.set(__self__, "cooldown_period", cooldown_period)
        if cpu_utilization is not None:
            pulumi.set(__self__, "cpu_utilization", cpu_utilization)
        if load_balancing_utilization is not None:
            pulumi.set(__self__, "load_balancing_utilization", load_balancing_utilization)
        if metrics is not None:
            pulumi.set(__self__, "metrics", metrics)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if scale_down_control is not None:
            pulumi.set(__self__, "scale_down_control", scale_down_control)
        if scale_in_control is not None:
            pulumi.set(__self__, "scale_in_control", scale_in_control)
        if scaling_schedules is not None:
            pulumi.set(__self__, "scaling_schedules", scaling_schedules)

    @property
    @pulumi.getter(name="maxReplicas")
    def max_replicas(self) -> pulumi.Input[int]:
        """
        The maximum number of instances that the autoscaler can scale up
        to. This is required when creating or updating an autoscaler. The
        maximum number of replicas should not be lower than minimal number
        of replicas.
        """
        return pulumi.get(self, "max_replicas")

    @max_replicas.setter
    def max_replicas(self, value: pulumi.Input[int]):
        pulumi.set(self, "max_replicas", value)

    @property
    @pulumi.getter(name="minReplicas")
    def min_replicas(self) -> pulumi.Input[int]:
        """
        The minimum number of replicas that the autoscaler can scale down
        to. This cannot be less than 0. If not provided, autoscaler will
        choose a default value depending on maximum number of instances
        allowed.
        """
        return pulumi.get(self, "min_replicas")

    @min_replicas.setter
    def min_replicas(self, value: pulumi.Input[int]):
        pulumi.set(self, "min_replicas", value)

    @property
    @pulumi.getter(name="cooldownPeriod")
    def cooldown_period(self) -> Optional[pulumi.Input[int]]:
        """
        The number of seconds that the autoscaler should wait before it
        starts collecting information from a new instance. This prevents
        the autoscaler from collecting information when the instance is
        initializing, during which the collected usage would not be
        reliable. The default time autoscaler waits is 60 seconds.
        Virtual machine initialization times might vary because of
        numerous factors. We recommend that you test how long an
        instance may take to initialize. To do this, create an instance
        and time the startup process.
        """
        return pulumi.get(self, "cooldown_period")

    @cooldown_period.setter
    def cooldown_period(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "cooldown_period", value)

    @property
    @pulumi.getter(name="cpuUtilization")
    def cpu_utilization(self) -> Optional[pulumi.Input['RegionAutoscalerAutoscalingPolicyCpuUtilizationArgs']]:
        """
        Defines the CPU utilization policy that allows the autoscaler to
        scale based on the average CPU utilization of a managed instance
        group.
        Structure is documented below.
        """
        return pulumi.get(self, "cpu_utilization")

    @cpu_utilization.setter
    def cpu_utilization(self, value: Optional[pulumi.Input['RegionAutoscalerAutoscalingPolicyCpuUtilizationArgs']]):
        pulumi.set(self, "cpu_utilization", value)

    @property
    @pulumi.getter(name="loadBalancingUtilization")
    def load_balancing_utilization(self) -> Optional[pulumi.Input['RegionAutoscalerAutoscalingPolicyLoadBalancingUtilizationArgs']]:
        """
        Configuration parameters of autoscaling based on a load balancer.
        Structure is documented below.
        """
        return pulumi.get(self, "load_balancing_utilization")

    @load_balancing_utilization.setter
    def load_balancing_utilization(self, value: Optional[pulumi.Input['RegionAutoscalerAutoscalingPolicyLoadBalancingUtilizationArgs']]):
        pulumi.set(self, "load_balancing_utilization", value)

    @property
    @pulumi.getter
    def metrics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionAutoscalerAutoscalingPolicyMetricArgs']]]]:
        """
        Configuration parameters of autoscaling based on a custom metric.
        Structure is documented below.
        """
        return pulumi.get(self, "metrics")

    @metrics.setter
    def metrics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionAutoscalerAutoscalingPolicyMetricArgs']]]]):
        pulumi.set(self, "metrics", value)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[str]]:
        """
        Defines operating mode for this policy.
        Default value is `ON`.
        Possible values are `OFF`, `ONLY_UP`, and `ON`.
        """
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mode", value)

    @property
    @pulumi.getter(name="scaleDownControl")
    def scale_down_control(self) -> Optional[pulumi.Input['RegionAutoscalerAutoscalingPolicyScaleDownControlArgs']]:
        """
        Defines scale down controls to reduce the risk of response latency
        and outages due to abrupt scale-in events
        Structure is documented below.
        """
        return pulumi.get(self, "scale_down_control")

    @scale_down_control.setter
    def scale_down_control(self, value: Optional[pulumi.Input['RegionAutoscalerAutoscalingPolicyScaleDownControlArgs']]):
        pulumi.set(self, "scale_down_control", value)

    @property
    @pulumi.getter(name="scaleInControl")
    def scale_in_control(self) -> Optional[pulumi.Input['RegionAutoscalerAutoscalingPolicyScaleInControlArgs']]:
        """
        Defines scale in controls to reduce the risk of response latency
        and outages due to abrupt scale-in events
        Structure is documented below.
        """
        return pulumi.get(self, "scale_in_control")

    @scale_in_control.setter
    def scale_in_control(self, value: Optional[pulumi.Input['RegionAutoscalerAutoscalingPolicyScaleInControlArgs']]):
        pulumi.set(self, "scale_in_control", value)

    @property
    @pulumi.getter(name="scalingSchedules")
    def scaling_schedules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionAutoscalerAutoscalingPolicyScalingScheduleArgs']]]]:
        """
        Scaling schedules defined for an autoscaler. Multiple schedules can be set on an autoscaler and they can overlap.
        Structure is documented below.
        """
        return pulumi.get(self, "scaling_schedules")

    @scaling_schedules.setter
    def scaling_schedules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionAutoscalerAutoscalingPolicyScalingScheduleArgs']]]]):
        pulumi.set(self, "scaling_schedules", value)


@pulumi.input_type
class RegionAutoscalerAutoscalingPolicyCpuUtilizationArgs:
    def __init__(__self__, *,
                 target: pulumi.Input[float],
                 predictive_method: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[float] target: Fraction of backend capacity utilization (set in HTTP(s) load
               balancing configuration) that autoscaler should maintain. Must
               be a positive float value. If not defined, the default is 0.8.
        :param pulumi.Input[str] predictive_method: Indicates whether predictive autoscaling based on CPU metric is enabled. Valid values are:
               - NONE (default). No predictive method is used. The autoscaler scales the group to meet current demand based on real-time metrics.
               - OPTIMIZE_AVAILABILITY. Predictive autoscaling improves availability by monitoring daily and weekly load patterns and scaling out ahead of anticipated demand.
        """
        pulumi.set(__self__, "target", target)
        if predictive_method is not None:
            pulumi.set(__self__, "predictive_method", predictive_method)

    @property
    @pulumi.getter
    def target(self) -> pulumi.Input[float]:
        """
        Fraction of backend capacity utilization (set in HTTP(s) load
        balancing configuration) that autoscaler should maintain. Must
        be a positive float value. If not defined, the default is 0.8.
        """
        return pulumi.get(self, "target")

    @target.setter
    def target(self, value: pulumi.Input[float]):
        pulumi.set(self, "target", value)

    @property
    @pulumi.getter(name="predictiveMethod")
    def predictive_method(self) -> Optional[pulumi.Input[str]]:
        """
        Indicates whether predictive autoscaling based on CPU metric is enabled. Valid values are:
        - NONE (default). No predictive method is used. The autoscaler scales the group to meet current demand based on real-time metrics.
        - OPTIMIZE_AVAILABILITY. Predictive autoscaling improves availability by monitoring daily and weekly load patterns and scaling out ahead of anticipated demand.
        """
        return pulumi.get(self, "predictive_method")

    @predictive_method.setter
    def predictive_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "predictive_method", value)


@pulumi.input_type
class RegionAutoscalerAutoscalingPolicyLoadBalancingUtilizationArgs:
    def __init__(__self__, *,
                 target: pulumi.Input[float]):
        """
        :param pulumi.Input[float] target: Fraction of backend capacity utilization (set in HTTP(s) load
               balancing configuration) that autoscaler should maintain. Must
               be a positive float value. If not defined, the default is 0.8.
        """
        pulumi.set(__self__, "target", target)

    @property
    @pulumi.getter
    def target(self) -> pulumi.Input[float]:
        """
        Fraction of backend capacity utilization (set in HTTP(s) load
        balancing configuration) that autoscaler should maintain. Must
        be a positive float value. If not defined, the default is 0.8.
        """
        return pulumi.get(self, "target")

    @target.setter
    def target(self, value: pulumi.Input[float]):
        pulumi.set(self, "target", value)


@pulumi.input_type
class RegionAutoscalerAutoscalingPolicyMetricArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 filter: Optional[pulumi.Input[str]] = None,
                 single_instance_assignment: Optional[pulumi.Input[float]] = None,
                 target: Optional[pulumi.Input[float]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for this object. Format specified above.
        :param pulumi.Input[str] filter: A filter string to be used as the filter string for
               a Stackdriver Monitoring TimeSeries.list API call.
               This filter is used to select a specific TimeSeries for
               the purpose of autoscaling and to determine whether the metric
               is exporting per-instance or per-group data.
               You can only use the AND operator for joining selectors.
               You can only use direct equality comparison operator (=) without
               any functions for each selector.
               You can specify the metric in both the filter string and in the
               metric field. However, if specified in both places, the metric must
               be identical.
               The monitored resource type determines what kind of values are
               expected for the metric. If it is a gce_instance, the autoscaler
               expects the metric to include a separate TimeSeries for each
               instance in a group. In such a case, you cannot filter on resource
               labels.
               If the resource type is any other value, the autoscaler expects
               this metric to contain values that apply to the entire autoscaled
               instance group and resource label filtering can be performed to
               point autoscaler at the correct TimeSeries to scale upon.
               This is called a per-group metric for the purpose of autoscaling.
               If not specified, the type defaults to gce_instance.
               You should provide a filter that is selective enough to pick just
               one TimeSeries for the autoscaled group or for each of the instances
               (if you are using gce_instance resource type). If multiple
               TimeSeries are returned upon the query execution, the autoscaler
               will sum their respective values to obtain its scaling value.
        :param pulumi.Input[float] single_instance_assignment: If scaling is based on a per-group metric value that represents the
               total amount of work to be done or resource usage, set this value to
               an amount assigned for a single instance of the scaled group.
               The autoscaler will keep the number of instances proportional to the
               value of this metric, the metric itself should not change value due
               to group resizing.
               For example, a good metric to use with the target is
               `pubsub.googleapis.com/subscription/num_undelivered_messages`
               or a custom metric exporting the total number of requests coming to
               your instances.
               A bad example would be a metric exporting an average or median
               latency, since this value can't include a chunk assignable to a
               single instance, it could be better used with utilization_target
               instead.
        :param pulumi.Input[float] target: Fraction of backend capacity utilization (set in HTTP(s) load
               balancing configuration) that autoscaler should maintain. Must
               be a positive float value. If not defined, the default is 0.8.
        :param pulumi.Input[str] type: Defines how target utilization value is expressed for a
               Stackdriver Monitoring metric.
               Possible values are `GAUGE`, `DELTA_PER_SECOND`, and `DELTA_PER_MINUTE`.
        """
        pulumi.set(__self__, "name", name)
        if filter is not None:
            pulumi.set(__self__, "filter", filter)
        if single_instance_assignment is not None:
            pulumi.set(__self__, "single_instance_assignment", single_instance_assignment)
        if target is not None:
            pulumi.set(__self__, "target", target)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The identifier for this object. Format specified above.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def filter(self) -> Optional[pulumi.Input[str]]:
        """
        A filter string to be used as the filter string for
        a Stackdriver Monitoring TimeSeries.list API call.
        This filter is used to select a specific TimeSeries for
        the purpose of autoscaling and to determine whether the metric
        is exporting per-instance or per-group data.
        You can only use the AND operator for joining selectors.
        You can only use direct equality comparison operator (=) without
        any functions for each selector.
        You can specify the metric in both the filter string and in the
        metric field. However, if specified in both places, the metric must
        be identical.
        The monitored resource type determines what kind of values are
        expected for the metric. If it is a gce_instance, the autoscaler
        expects the metric to include a separate TimeSeries for each
        instance in a group. In such a case, you cannot filter on resource
        labels.
        If the resource type is any other value, the autoscaler expects
        this metric to contain values that apply to the entire autoscaled
        instance group and resource label filtering can be performed to
        point autoscaler at the correct TimeSeries to scale upon.
        This is called a per-group metric for the purpose of autoscaling.
        If not specified, the type defaults to gce_instance.
        You should provide a filter that is selective enough to pick just
        one TimeSeries for the autoscaled group or for each of the instances
        (if you are using gce_instance resource type). If multiple
        TimeSeries are returned upon the query execution, the autoscaler
        will sum their respective values to obtain its scaling value.
        """
        return pulumi.get(self, "filter")

    @filter.setter
    def filter(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "filter", value)

    @property
    @pulumi.getter(name="singleInstanceAssignment")
    def single_instance_assignment(self) -> Optional[pulumi.Input[float]]:
        """
        If scaling is based on a per-group metric value that represents the
        total amount of work to be done or resource usage, set this value to
        an amount assigned for a single instance of the scaled group.
        The autoscaler will keep the number of instances proportional to the
        value of this metric, the metric itself should not change value due
        to group resizing.
        For example, a good metric to use with the target is
        `pubsub.googleapis.com/subscription/num_undelivered_messages`
        or a custom metric exporting the total number of requests coming to
        your instances.
        A bad example would be a metric exporting an average or median
        latency, since this value can't include a chunk assignable to a
        single instance, it could be better used with utilization_target
        instead.
        """
        return pulumi.get(self, "single_instance_assignment")

    @single_instance_assignment.setter
    def single_instance_assignment(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "single_instance_assignment", value)

    @property
    @pulumi.getter
    def target(self) -> Optional[pulumi.Input[float]]:
        """
        Fraction of backend capacity utilization (set in HTTP(s) load
        balancing configuration) that autoscaler should maintain. Must
        be a positive float value. If not defined, the default is 0.8.
        """
        return pulumi.get(self, "target")

    @target.setter
    def target(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "target", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Defines how target utilization value is expressed for a
        Stackdriver Monitoring metric.
        Possible values are `GAUGE`, `DELTA_PER_SECOND`, and `DELTA_PER_MINUTE`.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class RegionAutoscalerAutoscalingPolicyScaleDownControlArgs:
    def __init__(__self__, *,
                 max_scaled_down_replicas: Optional[pulumi.Input['RegionAutoscalerAutoscalingPolicyScaleDownControlMaxScaledDownReplicasArgs']] = None,
                 time_window_sec: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input['RegionAutoscalerAutoscalingPolicyScaleDownControlMaxScaledDownReplicasArgs'] max_scaled_down_replicas: A nested object resource
               Structure is documented below.
        :param pulumi.Input[int] time_window_sec: How long back autoscaling should look when computing recommendations
               to include directives regarding slower scale down, as described above.
        """
        if max_scaled_down_replicas is not None:
            pulumi.set(__self__, "max_scaled_down_replicas", max_scaled_down_replicas)
        if time_window_sec is not None:
            pulumi.set(__self__, "time_window_sec", time_window_sec)

    @property
    @pulumi.getter(name="maxScaledDownReplicas")
    def max_scaled_down_replicas(self) -> Optional[pulumi.Input['RegionAutoscalerAutoscalingPolicyScaleDownControlMaxScaledDownReplicasArgs']]:
        """
        A nested object resource
        Structure is documented below.
        """
        return pulumi.get(self, "max_scaled_down_replicas")

    @max_scaled_down_replicas.setter
    def max_scaled_down_replicas(self, value: Optional[pulumi.Input['RegionAutoscalerAutoscalingPolicyScaleDownControlMaxScaledDownReplicasArgs']]):
        pulumi.set(self, "max_scaled_down_replicas", value)

    @property
    @pulumi.getter(name="timeWindowSec")
    def time_window_sec(self) -> Optional[pulumi.Input[int]]:
        """
        How long back autoscaling should look when computing recommendations
        to include directives regarding slower scale down, as described above.
        """
        return pulumi.get(self, "time_window_sec")

    @time_window_sec.setter
    def time_window_sec(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "time_window_sec", value)


@pulumi.input_type
class RegionAutoscalerAutoscalingPolicyScaleDownControlMaxScaledDownReplicasArgs:
    def __init__(__self__, *,
                 fixed: Optional[pulumi.Input[int]] = None,
                 percent: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] fixed: Specifies a fixed number of VM instances. This must be a positive
               integer.
        :param pulumi.Input[int] percent: Specifies a percentage of instances between 0 to 100%, inclusive.
               For example, specify 80 for 80%.
        """
        if fixed is not None:
            pulumi.set(__self__, "fixed", fixed)
        if percent is not None:
            pulumi.set(__self__, "percent", percent)

    @property
    @pulumi.getter
    def fixed(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies a fixed number of VM instances. This must be a positive
        integer.
        """
        return pulumi.get(self, "fixed")

    @fixed.setter
    def fixed(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "fixed", value)

    @property
    @pulumi.getter
    def percent(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies a percentage of instances between 0 to 100%, inclusive.
        For example, specify 80 for 80%.
        """
        return pulumi.get(self, "percent")

    @percent.setter
    def percent(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "percent", value)


@pulumi.input_type
class RegionAutoscalerAutoscalingPolicyScaleInControlArgs:
    def __init__(__self__, *,
                 max_scaled_in_replicas: Optional[pulumi.Input['RegionAutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicasArgs']] = None,
                 time_window_sec: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input['RegionAutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicasArgs'] max_scaled_in_replicas: A nested object resource
               Structure is documented below.
        :param pulumi.Input[int] time_window_sec: How long back autoscaling should look when computing recommendations
               to include directives regarding slower scale down, as described above.
        """
        if max_scaled_in_replicas is not None:
            pulumi.set(__self__, "max_scaled_in_replicas", max_scaled_in_replicas)
        if time_window_sec is not None:
            pulumi.set(__self__, "time_window_sec", time_window_sec)

    @property
    @pulumi.getter(name="maxScaledInReplicas")
    def max_scaled_in_replicas(self) -> Optional[pulumi.Input['RegionAutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicasArgs']]:
        """
        A nested object resource
        Structure is documented below.
        """
        return pulumi.get(self, "max_scaled_in_replicas")

    @max_scaled_in_replicas.setter
    def max_scaled_in_replicas(self, value: Optional[pulumi.Input['RegionAutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicasArgs']]):
        pulumi.set(self, "max_scaled_in_replicas", value)

    @property
    @pulumi.getter(name="timeWindowSec")
    def time_window_sec(self) -> Optional[pulumi.Input[int]]:
        """
        How long back autoscaling should look when computing recommendations
        to include directives regarding slower scale down, as described above.
        """
        return pulumi.get(self, "time_window_sec")

    @time_window_sec.setter
    def time_window_sec(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "time_window_sec", value)


@pulumi.input_type
class RegionAutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicasArgs:
    def __init__(__self__, *,
                 fixed: Optional[pulumi.Input[int]] = None,
                 percent: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] fixed: Specifies a fixed number of VM instances. This must be a positive
               integer.
        :param pulumi.Input[int] percent: Specifies a percentage of instances between 0 to 100%, inclusive.
               For example, specify 80 for 80%.
        """
        if fixed is not None:
            pulumi.set(__self__, "fixed", fixed)
        if percent is not None:
            pulumi.set(__self__, "percent", percent)

    @property
    @pulumi.getter
    def fixed(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies a fixed number of VM instances. This must be a positive
        integer.
        """
        return pulumi.get(self, "fixed")

    @fixed.setter
    def fixed(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "fixed", value)

    @property
    @pulumi.getter
    def percent(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies a percentage of instances between 0 to 100%, inclusive.
        For example, specify 80 for 80%.
        """
        return pulumi.get(self, "percent")

    @percent.setter
    def percent(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "percent", value)


@pulumi.input_type
class RegionAutoscalerAutoscalingPolicyScalingScheduleArgs:
    def __init__(__self__, *,
                 duration_sec: pulumi.Input[int],
                 min_required_replicas: pulumi.Input[int],
                 name: pulumi.Input[str],
                 schedule: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None,
                 disabled: Optional[pulumi.Input[bool]] = None,
                 time_zone: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] duration_sec: The duration of time intervals (in seconds) for which this scaling schedule will be running. The minimum allowed value is 300.
        :param pulumi.Input[int] min_required_replicas: Minimum number of VM instances that autoscaler will recommend in time intervals starting according to schedule.
        :param pulumi.Input[str] name: The identifier for this object. Format specified above.
        :param pulumi.Input[str] schedule: The start timestamps of time intervals when this scaling schedule should provide a scaling signal. This field uses the extended cron format (with an optional year field).
        :param pulumi.Input[str] description: An optional description of this resource.
        :param pulumi.Input[bool] disabled: A boolean value that specifies if a scaling schedule can influence autoscaler recommendations. If set to true, then a scaling schedule has no effect.
        :param pulumi.Input[str] time_zone: The time zone to be used when interpreting the schedule. The value of this field must be a time zone name from the tz database: http://en.wikipedia.org/wiki/Tz_database.
        """
        pulumi.set(__self__, "duration_sec", duration_sec)
        pulumi.set(__self__, "min_required_replicas", min_required_replicas)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "schedule", schedule)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)
        if time_zone is not None:
            pulumi.set(__self__, "time_zone", time_zone)

    @property
    @pulumi.getter(name="durationSec")
    def duration_sec(self) -> pulumi.Input[int]:
        """
        The duration of time intervals (in seconds) for which this scaling schedule will be running. The minimum allowed value is 300.
        """
        return pulumi.get(self, "duration_sec")

    @duration_sec.setter
    def duration_sec(self, value: pulumi.Input[int]):
        pulumi.set(self, "duration_sec", value)

    @property
    @pulumi.getter(name="minRequiredReplicas")
    def min_required_replicas(self) -> pulumi.Input[int]:
        """
        Minimum number of VM instances that autoscaler will recommend in time intervals starting according to schedule.
        """
        return pulumi.get(self, "min_required_replicas")

    @min_required_replicas.setter
    def min_required_replicas(self, value: pulumi.Input[int]):
        pulumi.set(self, "min_required_replicas", value)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The identifier for this object. Format specified above.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def schedule(self) -> pulumi.Input[str]:
        """
        The start timestamps of time intervals when this scaling schedule should provide a scaling signal. This field uses the extended cron format (with an optional year field).
        """
        return pulumi.get(self, "schedule")

    @schedule.setter
    def schedule(self, value: pulumi.Input[str]):
        pulumi.set(self, "schedule", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        An optional description of this resource.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        A boolean value that specifies if a scaling schedule can influence autoscaler recommendations. If set to true, then a scaling schedule has no effect.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)

    @property
    @pulumi.getter(name="timeZone")
    def time_zone(self) -> Optional[pulumi.Input[str]]:
        """
        The time zone to be used when interpreting the schedule. The value of this field must be a time zone name from the tz database: http://en.wikipedia.org/wiki/Tz_database.
        """
        return pulumi.get(self, "time_zone")

    @time_zone.setter
    def time_zone(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "time_zone", value)


@pulumi.input_type
class RegionBackendServiceBackendArgs:
    def __init__(__self__, *,
                 group: pulumi.Input[str],
                 balancing_mode: Optional[pulumi.Input[str]] = None,
                 capacity_scaler: Optional[pulumi.Input[float]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 failover: Optional[pulumi.Input[bool]] = None,
                 max_connections: Optional[pulumi.Input[int]] = None,
                 max_connections_per_endpoint: Optional[pulumi.Input[int]] = None,
                 max_connections_per_instance: Optional[pulumi.Input[int]] = None,
                 max_rate: Optional[pulumi.Input[int]] = None,
                 max_rate_per_endpoint: Optional[pulumi.Input[float]] = None,
                 max_rate_per_instance: Optional[pulumi.Input[float]] = None,
                 max_utilization: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[str] group: The fully-qualified URL of an Instance Group or Network Endpoint
               Group resource. In case of instance group this defines the list
               of instances that serve traffic. Member virtual machine
               instances from each instance group must live in the same zone as
               the instance group itself. No two backends in a backend service
               are allowed to use same Instance Group resource.
               For Network Endpoint Groups this defines list of endpoints. All
               endpoints of Network Endpoint Group must be hosted on instances
               located in the same zone as the Network Endpoint Group.
               Backend services cannot mix Instance Group and
               Network Endpoint Group backends.
               When the `load_balancing_scheme` is INTERNAL, only instance groups
               are supported.
               Note that you must specify an Instance Group or Network Endpoint
               Group resource using the fully-qualified URL, rather than a
               partial URL.
        :param pulumi.Input[str] balancing_mode: Specifies the balancing mode for this backend.
               See the [Backend Services Overview](https://cloud.google.com/load-balancing/docs/backend-service#balancing-mode)
               for an explanation of load balancing modes.
               Default value is `CONNECTION`.
               Possible values are `UTILIZATION`, `RATE`, and `CONNECTION`.
        :param pulumi.Input[float] capacity_scaler: A multiplier applied to the group's maximum servicing capacity
               (based on UTILIZATION, RATE or CONNECTION).
               ~>**NOTE**: This field cannot be set for
               INTERNAL region backend services (default loadBalancingScheme),
               but is required for non-INTERNAL backend service. The total
               capacity_scaler for all backends must be non-zero.
               A setting of 0 means the group is completely drained, offering
               0% of its available Capacity. Valid range is [0.0,1.0].
        :param pulumi.Input[str] description: An optional description of this resource.
               Provide this property when you create the resource.
        :param pulumi.Input[bool] failover: This field designates whether this is a failover backend. More
               than one failover backend can be configured for a given RegionBackendService.
        :param pulumi.Input[int] max_connections: The maximum number of connections to the backend cluster.
               Defaults to 1024.
        :param pulumi.Input[int] max_connections_per_endpoint: The max number of simultaneous connections that a single backend
               network endpoint can handle. Cannot be set
               for INTERNAL backend services.
               This is used to calculate the capacity of the group. Can be
               used in either CONNECTION or UTILIZATION balancing modes. For
               CONNECTION mode, either maxConnections or
               maxConnectionsPerEndpoint must be set.
        :param pulumi.Input[int] max_connections_per_instance: The max number of simultaneous connections that a single
               backend instance can handle. Cannot be set for INTERNAL backend
               services.
               This is used to calculate the capacity of the group.
               Can be used in either CONNECTION or UTILIZATION balancing modes.
               For CONNECTION mode, either maxConnections or
               maxConnectionsPerInstance must be set.
        :param pulumi.Input[int] max_rate: The max requests per second (RPS) of the group. Cannot be set
               for INTERNAL backend services.
               Can be used with either RATE or UTILIZATION balancing modes,
               but required if RATE mode. Either maxRate or one
               of maxRatePerInstance or maxRatePerEndpoint, as appropriate for
               group type, must be set.
        :param pulumi.Input[float] max_rate_per_endpoint: The max requests per second (RPS) that a single backend network
               endpoint can handle. This is used to calculate the capacity of
               the group. Can be used in either balancing mode. For RATE mode,
               either maxRate or maxRatePerEndpoint must be set. Cannot be set
               for INTERNAL backend services.
        :param pulumi.Input[float] max_rate_per_instance: The max requests per second (RPS) that a single backend
               instance can handle. This is used to calculate the capacity of
               the group. Can be used in either balancing mode. For RATE mode,
               either maxRate or maxRatePerInstance must be set. Cannot be set
               for INTERNAL backend services.
        :param pulumi.Input[float] max_utilization: Used when balancingMode is UTILIZATION. This ratio defines the
               CPU utilization target for the group. Valid range is [0.0, 1.0].
               Cannot be set for INTERNAL backend services.
        """
        pulumi.set(__self__, "group", group)
        if balancing_mode is not None:
            pulumi.set(__self__, "balancing_mode", balancing_mode)
        if capacity_scaler is not None:
            pulumi.set(__self__, "capacity_scaler", capacity_scaler)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if failover is not None:
            pulumi.set(__self__, "failover", failover)
        if max_connections is not None:
            pulumi.set(__self__, "max_connections", max_connections)
        if max_connections_per_endpoint is not None:
            pulumi.set(__self__, "max_connections_per_endpoint", max_connections_per_endpoint)
        if max_connections_per_instance is not None:
            pulumi.set(__self__, "max_connections_per_instance", max_connections_per_instance)
        if max_rate is not None:
            pulumi.set(__self__, "max_rate", max_rate)
        if max_rate_per_endpoint is not None:
            pulumi.set(__self__, "max_rate_per_endpoint", max_rate_per_endpoint)
        if max_rate_per_instance is not None:
            pulumi.set(__self__, "max_rate_per_instance", max_rate_per_instance)
        if max_utilization is not None:
            pulumi.set(__self__, "max_utilization", max_utilization)

    @property
    @pulumi.getter
    def group(self) -> pulumi.Input[str]:
        """
        The fully-qualified URL of an Instance Group or Network Endpoint
        Group resource. In case of instance group this defines the list
        of instances that serve traffic. Member virtual machine
        instances from each instance group must live in the same zone as
        the instance group itself. No two backends in a backend service
        are allowed to use same Instance Group resource.
        For Network Endpoint Groups this defines list of endpoints. All
        endpoints of Network Endpoint Group must be hosted on instances
        located in the same zone as the Network Endpoint Group.
        Backend services cannot mix Instance Group and
        Network Endpoint Group backends.
        When the `load_balancing_scheme` is INTERNAL, only instance groups
        are supported.
        Note that you must specify an Instance Group or Network Endpoint
        Group resource using the fully-qualified URL, rather than a
        partial URL.
        """
        return pulumi.get(self, "group")

    @group.setter
    def group(self, value: pulumi.Input[str]):
        pulumi.set(self, "group", value)

    @property
    @pulumi.getter(name="balancingMode")
    def balancing_mode(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the balancing mode for this backend.
        See the [Backend Services Overview](https://cloud.google.com/load-balancing/docs/backend-service#balancing-mode)
        for an explanation of load balancing modes.
        Default value is `CONNECTION`.
        Possible values are `UTILIZATION`, `RATE`, and `CONNECTION`.
        """
        return pulumi.get(self, "balancing_mode")

    @balancing_mode.setter
    def balancing_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "balancing_mode", value)

    @property
    @pulumi.getter(name="capacityScaler")
    def capacity_scaler(self) -> Optional[pulumi.Input[float]]:
        """
        A multiplier applied to the group's maximum servicing capacity
        (based on UTILIZATION, RATE or CONNECTION).
        ~>**NOTE**: This field cannot be set for
        INTERNAL region backend services (default loadBalancingScheme),
        but is required for non-INTERNAL backend service. The total
        capacity_scaler for all backends must be non-zero.
        A setting of 0 means the group is completely drained, offering
        0% of its available Capacity. Valid range is [0.0,1.0].
        """
        return pulumi.get(self, "capacity_scaler")

    @capacity_scaler.setter
    def capacity_scaler(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "capacity_scaler", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        An optional description of this resource.
        Provide this property when you create the resource.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)

    @property
    @pulumi.getter
    def failover(self) -> Optional[pulumi.Input[bool]]:
        """
        This field designates whether this is a failover backend. More
        than one failover backend can be configured for a given RegionBackendService.
        """
        return pulumi.get(self, "failover")

    @failover.setter
    def failover(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "failover", value)

    @property
    @pulumi.getter(name="maxConnections")
    def max_connections(self) -> Optional[pulumi.Input[int]]:
        """
        The maximum number of connections to the backend cluster.
        Defaults to 1024.
        """
        return pulumi.get(self, "max_connections")

    @max_connections.setter
    def max_connections(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_connections", value)

    @property
    @pulumi.getter(name="maxConnectionsPerEndpoint")
    def max_connections_per_endpoint(self) -> Optional[pulumi.Input[int]]:
        """
        The max number of simultaneous connections that a single backend
        network endpoint can handle. Cannot be set
        for INTERNAL backend services.
        This is used to calculate the capacity of the group. Can be
        used in either CONNECTION or UTILIZATION balancing modes. For
        CONNECTION mode, either maxConnections or
        maxConnectionsPerEndpoint must be set.
        """
        return pulumi.get(self, "max_connections_per_endpoint")

    @max_connections_per_endpoint.setter
    def max_connections_per_endpoint(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_connections_per_endpoint", value)

    @property
    @pulumi.getter(name="maxConnectionsPerInstance")
    def max_connections_per_instance(self) -> Optional[pulumi.Input[int]]:
        """
        The max number of simultaneous connections that a single
        backend instance can handle. Cannot be set for INTERNAL backend
        services.
        This is used to calculate the capacity of the group.
        Can be used in either CONNECTION or UTILIZATION balancing modes.
        For CONNECTION mode, either maxConnections or
        maxConnectionsPerInstance must be set.
        """
        return pulumi.get(self, "max_connections_per_instance")

    @max_connections_per_instance.setter
    def max_connections_per_instance(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_connections_per_instance", value)

    @property
    @pulumi.getter(name="maxRate")
    def max_rate(self) -> Optional[pulumi.Input[int]]:
        """
        The max requests per second (RPS) of the group. Cannot be set
        for INTERNAL backend services.
        Can be used with either RATE or UTILIZATION balancing modes,
        but required if RATE mode. Either maxRate or one
        of maxRatePerInstance or maxRatePerEndpoint, as appropriate for
        group type, must be set.
        """
        return pulumi.get(self, "max_rate")

    @max_rate.setter
    def max_rate(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_rate", value)

    @property
    @pulumi.getter(name="maxRatePerEndpoint")
    def max_rate_per_endpoint(self) -> Optional[pulumi.Input[float]]:
        """
        The max requests per second (RPS) that a single backend network
        endpoint can handle. This is used to calculate the capacity of
        the group. Can be used in either balancing mode. For RATE mode,
        either maxRate or maxRatePerEndpoint must be set. Cannot be set
        for INTERNAL backend services.
        """
        return pulumi.get(self, "max_rate_per_endpoint")

    @max_rate_per_endpoint.setter
    def max_rate_per_endpoint(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "max_rate_per_endpoint", value)

    @property
    @pulumi.getter(name="maxRatePerInstance")
    def max_rate_per_instance(self) -> Optional[pulumi.Input[float]]:
        """
        The max requests per second (RPS) that a single backend
        instance can handle. This is used to calculate the capacity of
        the group. Can be used in either balancing mode. For RATE mode,
        either maxRate or maxRatePerInstance must be set. Cannot be set
        for INTERNAL backend services.
        """
        return pulumi.get(self, "max_rate_per_instance")

    @max_rate_per_instance.setter
    def max_rate_per_instance(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "max_rate_per_instance", value)

    @property
    @pulumi.getter(name="maxUtilization")
    def max_utilization(self) -> Optional[pulumi.Input[float]]:
        """
        Used when balancingMode is UTILIZATION. This ratio defines the
        CPU utilization target for the group. Valid range is [0.0, 1.0].
        Cannot be set for INTERNAL backend services.
        """
        return pulumi.get(self, "max_utilization")

    @max_utilization.setter
    def max_utilization(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "max_utilization", value)


@pulumi.input_type
class RegionBackendServiceCdnPolicyArgs:
    def __init__(__self__, *,
                 cache_key_policy: Optional[pulumi.Input['RegionBackendServiceCdnPolicyCacheKeyPolicyArgs']] = None,
                 cache_mode: Optional[pulumi.Input[str]] = None,
                 client_ttl: Optional[pulumi.Input[int]] = None,
                 default_ttl: Optional[pulumi.Input[int]] = None,
                 max_ttl: Optional[pulumi.Input[int]] = None,
                 negative_caching: Optional[pulumi.Input[bool]] = None,
                 negative_caching_policies: Optional[pulumi.Input[Sequence[pulumi.Input['RegionBackendServiceCdnPolicyNegativeCachingPolicyArgs']]]] = None,
                 serve_while_stale: Optional[pulumi.Input[int]] = None,
                 signed_url_cache_max_age_sec: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input['RegionBackendServiceCdnPolicyCacheKeyPolicyArgs'] cache_key_policy: The CacheKeyPolicy for this CdnPolicy.
               Structure is documented below.
        :param pulumi.Input[str] cache_mode: Specifies the cache setting for all responses from this backend.
               The possible values are: USE_ORIGIN_HEADERS, FORCE_CACHE_ALL and CACHE_ALL_STATIC
               Possible values are `USE_ORIGIN_HEADERS`, `FORCE_CACHE_ALL`, and `CACHE_ALL_STATIC`.
        :param pulumi.Input[int] client_ttl: Specifies the maximum allowed TTL for cached content served by this origin.
        :param pulumi.Input[int] default_ttl: Specifies the default TTL for cached content served by this origin for responses
               that do not have an existing valid TTL (max-age or s-max-age).
        :param pulumi.Input[int] max_ttl: Specifies the maximum allowed TTL for cached content served by this origin.
        :param pulumi.Input[bool] negative_caching: Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects.
        :param pulumi.Input[Sequence[pulumi.Input['RegionBackendServiceCdnPolicyNegativeCachingPolicyArgs']]] negative_caching_policies: Sets a cache TTL for the specified HTTP status code. negativeCaching must be enabled to configure negativeCachingPolicy.
               Omitting the policy and leaving negativeCaching enabled will use Cloud CDN's default cache TTLs.
               Structure is documented below.
        :param pulumi.Input[int] serve_while_stale: Serve existing content from the cache (if available) when revalidating content with the origin, or when an error is encountered when refreshing the cache.
        :param pulumi.Input[int] signed_url_cache_max_age_sec: Maximum number of seconds the response to a signed URL request
               will be considered fresh, defaults to 1hr (3600s). After this
               time period, the response will be revalidated before
               being served.
               When serving responses to signed URL requests, Cloud CDN will
               internally behave as though all responses from this backend had a
               "Cache-Control: public, max-age=[TTL]" header, regardless of any
               existing Cache-Control header. The actual headers served in
               responses will not be altered.
        """
        if cache_key_policy is not None:
            pulumi.set(__self__, "cache_key_policy", cache_key_policy)
        if cache_mode is not None:
            pulumi.set(__self__, "cache_mode", cache_mode)
        if client_ttl is not None:
            pulumi.set(__self__, "client_ttl", client_ttl)
        if default_ttl is not None:
            pulumi.set(__self__, "default_ttl", default_ttl)
        if max_ttl is not None:
            pulumi.set(__self__, "max_ttl", max_ttl)
        if negative_caching is not None:
            pulumi.set(__self__, "negative_caching", negative_caching)
        if negative_caching_policies is not None:
            pulumi.set(__self__, "negative_caching_policies", negative_caching_policies)
        if serve_while_stale is not None:
            pulumi.set(__self__, "serve_while_stale", serve_while_stale)
        if signed_url_cache_max_age_sec is not None:
            pulumi.set(__self__, "signed_url_cache_max_age_sec", signed_url_cache_max_age_sec)

    @property
    @pulumi.getter(name="cacheKeyPolicy")
    def cache_key_policy(self) -> Optional[pulumi.Input['RegionBackendServiceCdnPolicyCacheKeyPolicyArgs']]:
        """
        The CacheKeyPolicy for this CdnPolicy.
        Structure is documented below.
        """
        return pulumi.get(self, "cache_key_policy")

    @cache_key_policy.setter
    def cache_key_policy(self, value: Optional[pulumi.Input['RegionBackendServiceCdnPolicyCacheKeyPolicyArgs']]):
        pulumi.set(self, "cache_key_policy", value)

    @property
    @pulumi.getter(name="cacheMode")
    def cache_mode(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the cache setting for all responses from this backend.
        The possible values are: USE_ORIGIN_HEADERS, FORCE_CACHE_ALL and CACHE_ALL_STATIC
        Possible values are `USE_ORIGIN_HEADERS`, `FORCE_CACHE_ALL`, and `CACHE_ALL_STATIC`.
        """
        return pulumi.get(self, "cache_mode")

    @cache_mode.setter
    def cache_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cache_mode", value)

    @property
    @pulumi.getter(name="clientTtl")
    def client_ttl(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the maximum allowed TTL for cached content served by this origin.
        """
        return pulumi.get(self, "client_ttl")

    @client_ttl.setter
    def client_ttl(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "client_ttl", value)

    @property
    @pulumi.getter(name="defaultTtl")
    def default_ttl(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the default TTL for cached content served by this origin for responses
        that do not have an existing valid TTL (max-age or s-max-age).
        """
        return pulumi.get(self, "default_ttl")

    @default_ttl.setter
    def default_ttl(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "default_ttl", value)

    @property
    @pulumi.getter(name="maxTtl")
    def max_ttl(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the maximum allowed TTL for cached content served by this origin.
        """
        return pulumi.get(self, "max_ttl")

    @max_ttl.setter
    def max_ttl(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_ttl", value)

    @property
    @pulumi.getter(name="negativeCaching")
    def negative_caching(self) -> Optional[pulumi.Input[bool]]:
        """
        Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects.
        """
        return pulumi.get(self, "negative_caching")

    @negative_caching.setter
    def negative_caching(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "negative_caching", value)

    @property
    @pulumi.getter(name="negativeCachingPolicies")
    def negative_caching_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionBackendServiceCdnPolicyNegativeCachingPolicyArgs']]]]:
        """
        Sets a cache TTL for the specified HTTP status code. negativeCaching must be enabled to configure negativeCachingPolicy.
        Omitting the policy and leaving negativeCaching enabled will use Cloud CDN's default cache TTLs.
        Structure is documented below.
        """
        return pulumi.get(self, "negative_caching_policies")

    @negative_caching_policies.setter
    def negative_caching_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionBackendServiceCdnPolicyNegativeCachingPolicyArgs']]]]):
        pulumi.set(self, "negative_caching_policies", value)

    @property
    @pulumi.getter(name="serveWhileStale")
    def serve_while_stale(self) -> Optional[pulumi.Input[int]]:
        """
        Serve existing content from the cache (if available) when revalidating content with the origin, or when an error is encountered when refreshing the cache.
        """
        return pulumi.get(self, "serve_while_stale")

    @serve_while_stale.setter
    def serve_while_stale(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "serve_while_stale", value)

    @property
    @pulumi.getter(name="signedUrlCacheMaxAgeSec")
    def signed_url_cache_max_age_sec(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum number of seconds the response to a signed URL request
        will be considered fresh, defaults to 1hr (3600s). After this
        time period, the response will be revalidated before
        being served.
        When serving responses to signed URL requests, Cloud CDN will
        internally behave as though all responses from this backend had a
        "Cache-Control: public, max-age=[TTL]" header, regardless of any
        existing Cache-Control header. The actual headers served in
        responses will not be altered.
        """
        return pulumi.get(self, "signed_url_cache_max_age_sec")

    @signed_url_cache_max_age_sec.setter
    def signed_url_cache_max_age_sec(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "signed_url_cache_max_age_sec", value)


@pulumi.input_type
class RegionBackendServiceCdnPolicyCacheKeyPolicyArgs:
    def __init__(__self__, *,
                 include_host: Optional[pulumi.Input[bool]] = None,
                 include_named_cookies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 include_protocol: Optional[pulumi.Input[bool]] = None,
                 include_query_string: Optional[pulumi.Input[bool]] = None,
                 query_string_blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 query_string_whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[bool] include_host: If true requests to different hosts will be cached separately.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] include_named_cookies: Names of cookies to include in cache keys.
        :param pulumi.Input[bool] include_protocol: If true, http and https requests will be cached separately.
        :param pulumi.Input[bool] include_query_string: If true, include query string parameters in the cache key
               according to query_string_whitelist and
               query_string_blacklist. If neither is set, the entire query
               string will be included.
               If false, the query string will be excluded from the cache
               key entirely.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] query_string_blacklists: Names of query string parameters to exclude in cache keys.
               All other parameters will be included. Either specify
               query_string_whitelist or query_string_blacklist, not both.
               '&' and '=' will be percent encoded and not treated as
               delimiters.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] query_string_whitelists: Names of query string parameters to include in cache keys.
               All other parameters will be excluded. Either specify
               query_string_whitelist or query_string_blacklist, not both.
               '&' and '=' will be percent encoded and not treated as
               delimiters.
        """
        if include_host is not None:
            pulumi.set(__self__, "include_host", include_host)
        if include_named_cookies is not None:
            pulumi.set(__self__, "include_named_cookies", include_named_cookies)
        if include_protocol is not None:
            pulumi.set(__self__, "include_protocol", include_protocol)
        if include_query_string is not None:
            pulumi.set(__self__, "include_query_string", include_query_string)
        if query_string_blacklists is not None:
            pulumi.set(__self__, "query_string_blacklists", query_string_blacklists)
        if query_string_whitelists is not None:
            pulumi.set(__self__, "query_string_whitelists", query_string_whitelists)

    @property
    @pulumi.getter(name="includeHost")
    def include_host(self) -> Optional[pulumi.Input[bool]]:
        """
        If true requests to different hosts will be cached separately.
        """
        return pulumi.get(self, "include_host")

    @include_host.setter
    def include_host(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "include_host", value)

    @property
    @pulumi.getter(name="includeNamedCookies")
    def include_named_cookies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Names of cookies to include in cache keys.
        """
        return pulumi.get(self, "include_named_cookies")

    @include_named_cookies.setter
    def include_named_cookies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "include_named_cookies", value)

    @property
    @pulumi.getter(name="includeProtocol")
    def include_protocol(self) -> Optional[pulumi.Input[bool]]:
        """
        If true, http and https requests will be cached separately.
        """
        return pulumi.get(self, "include_protocol")

    @include_protocol.setter
    def include_protocol(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "include_protocol", value)

    @property
    @pulumi.getter(name="includeQueryString")
    def include_query_string(self) -> Optional[pulumi.Input[bool]]:
        """
        If true, include query string parameters in the cache key
        according to query_string_whitelist and
        query_string_blacklist. If neither is set, the entire query
        string will be included.
        If false, the query string will be excluded from the cache
        key entirely.
        """
        return pulumi.get(self, "include_query_string")

    @include_query_string.setter
    def include_query_string(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "include_query_string", value)

    @property
    @pulumi.getter(name="queryStringBlacklists")
    def query_string_blacklists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Names of query string parameters to exclude in cache keys.
        All other parameters will be included. Either specify
        query_string_whitelist or query_string_blacklist, not both.
        '&' and '=' will be percent encoded and not treated as
        delimiters.
        """
        return pulumi.get(self, "query_string_blacklists")

    @query_string_blacklists.setter
    def query_string_blacklists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "query_string_blacklists", value)

    @property
    @pulumi.getter(name="queryStringWhitelists")
    def query_string_whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Names of query string parameters to include in cache keys.
        All other parameters will be excluded. Either specify
        query_string_whitelist or query_string_blacklist, not both.
        '&' and '=' will be percent encoded and not treated as
        delimiters.
        """
        return pulumi.get(self, "query_string_whitelists")

    @query_string_whitelists.setter
    def query_string_whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "query_string_whitelists", value)


@pulumi.input_type
class RegionBackendServiceCdnPolicyNegativeCachingPolicyArgs:
    def __init__(__self__, *,
                 code: Optional[pulumi.Input[int]] = None,
                 ttl: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] code: The HTTP status code to define a TTL against. Only HTTP status codes 300, 301, 308, 404, 405, 410, 421, 451 and 501
               can be specified as values, and you cannot specify a status code more than once.
        :param pulumi.Input[int] ttl: The TTL (in seconds) for which to cache responses with the corresponding status code. The maximum allowed value is 1800s
               (30 minutes), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
        """
        if code is not None:
            pulumi.set(__self__, "code", code)
        if ttl is not None:
            pulumi.set(__self__, "ttl", ttl)

    @property
    @pulumi.getter
    def code(self) -> Optional[pulumi.Input[int]]:
        """
        The HTTP status code to define a TTL against. Only HTTP status codes 300, 301, 308, 404, 405, 410, 421, 451 and 501
        can be specified as values, and you cannot specify a status code more than once.
        """
        return pulumi.get(self, "code")

    @code.setter
    def code(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "code", value)

    @property
    @pulumi.getter
    def ttl(self) -> Optional[pulumi.Input[int]]:
        """
        The TTL (in seconds) for which to cache responses with the corresponding status code. The maximum allowed value is 1800s
        (30 minutes), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
        """
        return pulumi.get(self, "ttl")

    @ttl.setter
    def ttl(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "ttl", value)


@pulumi.input_type
class RegionBackendServiceCircuitBreakersArgs:
    def __init__(__self__, *,
                 connect_timeout: Optional[pulumi.Input['RegionBackendServiceCircuitBreakersConnectTimeoutArgs']] = None,
                 max_connections: Optional[pulumi.Input[int]] = None,
                 max_pending_requests: Optional[pulumi.Input[int]] = None,
                 max_requests: Optional[pulumi.Input[int]] = None,
                 max_requests_per_connection: Optional[pulumi.Input[int]] = None,
                 max_retries: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input['RegionBackendServiceCircuitBreakersConnectTimeoutArgs'] connect_timeout: The timeout for new network connections to hosts.
               Structure is documented below.
        :param pulumi.Input[int] max_connections: The maximum number of connections to the backend cluster.
               Defaults to 1024.
        :param pulumi.Input[int] max_pending_requests: The maximum number of pending requests to the backend cluster.
               Defaults to 1024.
        :param pulumi.Input[int] max_requests: The maximum number of parallel requests to the backend cluster.
               Defaults to 1024.
        :param pulumi.Input[int] max_requests_per_connection: Maximum requests for a single backend connection. This parameter
               is respected by both the HTTP/1.1 and HTTP/2 implementations. If
               not specified, there is no limit. Setting this parameter to 1
               will effectively disable keep alive.
        :param pulumi.Input[int] max_retries: The maximum number of parallel retries to the backend cluster.
               Defaults to 3.
        """
        if connect_timeout is not None:
            pulumi.set(__self__, "connect_timeout", connect_timeout)
        if max_connections is not None:
            pulumi.set(__self__, "max_connections", max_connections)
        if max_pending_requests is not None:
            pulumi.set(__self__, "max_pending_requests", max_pending_requests)
        if max_requests is not None:
            pulumi.set(__self__, "max_requests", max_requests)
        if max_requests_per_connection is not None:
            pulumi.set(__self__, "max_requests_per_connection", max_requests_per_connection)
        if max_retries is not None:
            pulumi.set(__self__, "max_retries", max_retries)

    @property
    @pulumi.getter(name="connectTimeout")
    def connect_timeout(self) -> Optional[pulumi.Input['RegionBackendServiceCircuitBreakersConnectTimeoutArgs']]:
        """
        The timeout for new network connections to hosts.
        Structure is documented below.
        """
        return pulumi.get(self, "connect_timeout")

    @connect_timeout.setter
    def connect_timeout(self, value: Optional[pulumi.Input['RegionBackendServiceCircuitBreakersConnectTimeoutArgs']]):
        pulumi.set(self, "connect_timeout", value)

    @property
    @pulumi.getter(name="maxConnections")
    def max_connections(self) -> Optional[pulumi.Input[int]]:
        """
        The maximum number of connections to the backend cluster.
        Defaults to 1024.
        """
        return pulumi.get(self, "max_connections")

    @max_connections.setter
    def max_connections(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_connections", value)

    @property
    @pulumi.getter(name="maxPendingRequests")
    def max_pending_requests(self) -> Optional[pulumi.Input[int]]:
        """
        The maximum number of pending requests to the backend cluster.
        Defaults to 1024.
        """
        return pulumi.get(self, "max_pending_requests")

    @max_pending_requests.setter
    def max_pending_requests(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_pending_requests", value)

    @property
    @pulumi.getter(name="maxRequests")
    def max_requests(self) -> Optional[pulumi.Input[int]]:
        """
        The maximum number of parallel requests to the backend cluster.
        Defaults to 1024.
        """
        return pulumi.get(self, "max_requests")

    @max_requests.setter
    def max_requests(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_requests", value)

    @property
    @pulumi.getter(name="maxRequestsPerConnection")
    def max_requests_per_connection(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum requests for a single backend connection. This parameter
        is respected by both the HTTP/1.1 and HTTP/2 implementations. If
        not specified, there is no limit. Setting this parameter to 1
        will effectively disable keep alive.
        """
        return pulumi.get(self, "max_requests_per_connection")

    @max_requests_per_connection.setter
    def max_requests_per_connection(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_requests_per_connection", value)

    @property
    @pulumi.getter(name="maxRetries")
    def max_retries(self) -> Optional[pulumi.Input[int]]:
        """
        The maximum number of parallel retries to the backend cluster.
        Defaults to 3.
        """
        return pulumi.get(self, "max_retries")

    @max_retries.setter
    def max_retries(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_retries", value)


@pulumi.input_type
class RegionBackendServiceCircuitBreakersConnectTimeoutArgs:
    def __init__(__self__, *,
                 seconds: pulumi.Input[int],
                 nanos: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
               inclusive.
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations
               less than one second are represented with a 0 `seconds` field and a positive
               `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        pulumi.set(__self__, "seconds", seconds)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)

    @property
    @pulumi.getter
    def seconds(self) -> pulumi.Input[int]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
        inclusive.
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: pulumi.Input[int]):
        pulumi.set(self, "seconds", value)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations
        less than one second are represented with a 0 `seconds` field and a positive
        `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)


@pulumi.input_type
class RegionBackendServiceConnectionTrackingPolicyArgs:
    def __init__(__self__, *,
                 connection_persistence_on_unhealthy_backends: Optional[pulumi.Input[str]] = None,
                 idle_timeout_sec: Optional[pulumi.Input[int]] = None,
                 tracking_mode: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] connection_persistence_on_unhealthy_backends: Specifies connection persistence when backends are unhealthy.
               If set to `DEFAULT_FOR_PROTOCOL`, the existing connections persist on
               unhealthy backends only for connection-oriented protocols (TCP and SCTP)
               and only if the Tracking Mode is PER_CONNECTION (default tracking mode)
               or the Session Affinity is configured for 5-tuple. They do not persist
               for UDP.
               If set to `NEVER_PERSIST`, after a backend becomes unhealthy, the existing
               connections on the unhealthy backend are never persisted on the unhealthy
               backend. They are always diverted to newly selected healthy backends
               (unless all backends are unhealthy).
               If set to `ALWAYS_PERSIST`, existing connections always persist on
               unhealthy backends regardless of protocol and session affinity. It is
               generally not recommended to use this mode overriding the default.
               Default value is `DEFAULT_FOR_PROTOCOL`.
               Possible values are `DEFAULT_FOR_PROTOCOL`, `NEVER_PERSIST`, and `ALWAYS_PERSIST`.
        :param pulumi.Input[int] idle_timeout_sec: Specifies how long to keep a Connection Tracking entry while there is
               no matching traffic (in seconds).
               For L4 ILB the minimum(default) is 10 minutes and maximum is 16 hours.
               For NLB the minimum(default) is 60 seconds and the maximum is 16 hours.
        :param pulumi.Input[str] tracking_mode: Specifies the key used for connection tracking. There are two options:
               `PER_CONNECTION`: The Connection Tracking is performed as per the
               Connection Key (default Hash Method) for the specific protocol.
               `PER_SESSION`: The Connection Tracking is performed as per the
               configured Session Affinity. It matches the configured Session Affinity.
               Default value is `PER_CONNECTION`.
               Possible values are `PER_CONNECTION` and `PER_SESSION`.
        """
        if connection_persistence_on_unhealthy_backends is not None:
            pulumi.set(__self__, "connection_persistence_on_unhealthy_backends", connection_persistence_on_unhealthy_backends)
        if idle_timeout_sec is not None:
            pulumi.set(__self__, "idle_timeout_sec", idle_timeout_sec)
        if tracking_mode is not None:
            pulumi.set(__self__, "tracking_mode", tracking_mode)

    @property
    @pulumi.getter(name="connectionPersistenceOnUnhealthyBackends")
    def connection_persistence_on_unhealthy_backends(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies connection persistence when backends are unhealthy.
        If set to `DEFAULT_FOR_PROTOCOL`, the existing connections persist on
        unhealthy backends only for connection-oriented protocols (TCP and SCTP)
        and only if the Tracking Mode is PER_CONNECTION (default tracking mode)
        or the Session Affinity is configured for 5-tuple. They do not persist
        for UDP.
        If set to `NEVER_PERSIST`, after a backend becomes unhealthy, the existing
        connections on the unhealthy backend are never persisted on the unhealthy
        backend. They are always diverted to newly selected healthy backends
        (unless all backends are unhealthy).
        If set to `ALWAYS_PERSIST`, existing connections always persist on
        unhealthy backends regardless of protocol and session affinity. It is
        generally not recommended to use this mode overriding the default.
        Default value is `DEFAULT_FOR_PROTOCOL`.
        Possible values are `DEFAULT_FOR_PROTOCOL`, `NEVER_PERSIST`, and `ALWAYS_PERSIST`.
        """
        return pulumi.get(self, "connection_persistence_on_unhealthy_backends")

    @connection_persistence_on_unhealthy_backends.setter
    def connection_persistence_on_unhealthy_backends(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "connection_persistence_on_unhealthy_backends", value)

    @property
    @pulumi.getter(name="idleTimeoutSec")
    def idle_timeout_sec(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies how long to keep a Connection Tracking entry while there is
        no matching traffic (in seconds).
        For L4 ILB the minimum(default) is 10 minutes and maximum is 16 hours.
        For NLB the minimum(default) is 60 seconds and the maximum is 16 hours.
        """
        return pulumi.get(self, "idle_timeout_sec")

    @idle_timeout_sec.setter
    def idle_timeout_sec(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "idle_timeout_sec", value)

    @property
    @pulumi.getter(name="trackingMode")
    def tracking_mode(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the key used for connection tracking. There are two options:
        `PER_CONNECTION`: The Connection Tracking is performed as per the
        Connection Key (default Hash Method) for the specific protocol.
        `PER_SESSION`: The Connection Tracking is performed as per the
        configured Session Affinity. It matches the configured Session Affinity.
        Default value is `PER_CONNECTION`.
        Possible values are `PER_CONNECTION` and `PER_SESSION`.
        """
        return pulumi.get(self, "tracking_mode")

    @tracking_mode.setter
    def tracking_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tracking_mode", value)


@pulumi.input_type
class RegionBackendServiceConsistentHashArgs:
    def __init__(__self__, *,
                 http_cookie: Optional[pulumi.Input['RegionBackendServiceConsistentHashHttpCookieArgs']] = None,
                 http_header_name: Optional[pulumi.Input[str]] = None,
                 minimum_ring_size: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input['RegionBackendServiceConsistentHashHttpCookieArgs'] http_cookie: Hash is based on HTTP Cookie. This field describes a HTTP cookie
               that will be used as the hash key for the consistent hash load
               balancer. If the cookie is not present, it will be generated.
               This field is applicable if the sessionAffinity is set to HTTP_COOKIE.
               Structure is documented below.
        :param pulumi.Input[str] http_header_name: The hash based on the value of the specified header field.
               This field is applicable if the sessionAffinity is set to HEADER_FIELD.
        :param pulumi.Input[int] minimum_ring_size: The minimum number of virtual nodes to use for the hash ring.
               Larger ring sizes result in more granular load
               distributions. If the number of hosts in the load balancing pool
               is larger than the ring size, each host will be assigned a single
               virtual node.
               Defaults to 1024.
        """
        if http_cookie is not None:
            pulumi.set(__self__, "http_cookie", http_cookie)
        if http_header_name is not None:
            pulumi.set(__self__, "http_header_name", http_header_name)
        if minimum_ring_size is not None:
            pulumi.set(__self__, "minimum_ring_size", minimum_ring_size)

    @property
    @pulumi.getter(name="httpCookie")
    def http_cookie(self) -> Optional[pulumi.Input['RegionBackendServiceConsistentHashHttpCookieArgs']]:
        """
        Hash is based on HTTP Cookie. This field describes a HTTP cookie
        that will be used as the hash key for the consistent hash load
        balancer. If the cookie is not present, it will be generated.
        This field is applicable if the sessionAffinity is set to HTTP_COOKIE.
        Structure is documented below.
        """
        return pulumi.get(self, "http_cookie")

    @http_cookie.setter
    def http_cookie(self, value: Optional[pulumi.Input['RegionBackendServiceConsistentHashHttpCookieArgs']]):
        pulumi.set(self, "http_cookie", value)

    @property
    @pulumi.getter(name="httpHeaderName")
    def http_header_name(self) -> Optional[pulumi.Input[str]]:
        """
        The hash based on the value of the specified header field.
        This field is applicable if the sessionAffinity is set to HEADER_FIELD.
        """
        return pulumi.get(self, "http_header_name")

    @http_header_name.setter
    def http_header_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "http_header_name", value)

    @property
    @pulumi.getter(name="minimumRingSize")
    def minimum_ring_size(self) -> Optional[pulumi.Input[int]]:
        """
        The minimum number of virtual nodes to use for the hash ring.
        Larger ring sizes result in more granular load
        distributions. If the number of hosts in the load balancing pool
        is larger than the ring size, each host will be assigned a single
        virtual node.
        Defaults to 1024.
        """
        return pulumi.get(self, "minimum_ring_size")

    @minimum_ring_size.setter
    def minimum_ring_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "minimum_ring_size", value)


@pulumi.input_type
class RegionBackendServiceConsistentHashHttpCookieArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None,
                 path: Optional[pulumi.Input[str]] = None,
                 ttl: Optional[pulumi.Input['RegionBackendServiceConsistentHashHttpCookieTtlArgs']] = None):
        """
        :param pulumi.Input[str] name: Name of the cookie.
        :param pulumi.Input[str] path: Path to set for the cookie.
        :param pulumi.Input['RegionBackendServiceConsistentHashHttpCookieTtlArgs'] ttl: The TTL (in seconds) for which to cache responses with the corresponding status code. The maximum allowed value is 1800s
               (30 minutes), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if ttl is not None:
            pulumi.set(__self__, "ttl", ttl)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        Name of the cookie.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def path(self) -> Optional[pulumi.Input[str]]:
        """
        Path to set for the cookie.
        """
        return pulumi.get(self, "path")

    @path.setter
    def path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path", value)

    @property
    @pulumi.getter
    def ttl(self) -> Optional[pulumi.Input['RegionBackendServiceConsistentHashHttpCookieTtlArgs']]:
        """
        The TTL (in seconds) for which to cache responses with the corresponding status code. The maximum allowed value is 1800s
        (30 minutes), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
        """
        return pulumi.get(self, "ttl")

    @ttl.setter
    def ttl(self, value: Optional[pulumi.Input['RegionBackendServiceConsistentHashHttpCookieTtlArgs']]):
        pulumi.set(self, "ttl", value)


@pulumi.input_type
class RegionBackendServiceConsistentHashHttpCookieTtlArgs:
    def __init__(__self__, *,
                 seconds: pulumi.Input[int],
                 nanos: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
               inclusive.
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations
               less than one second are represented with a 0 `seconds` field and a positive
               `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        pulumi.set(__self__, "seconds", seconds)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)

    @property
    @pulumi.getter
    def seconds(self) -> pulumi.Input[int]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
        inclusive.
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: pulumi.Input[int]):
        pulumi.set(self, "seconds", value)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations
        less than one second are represented with a 0 `seconds` field and a positive
        `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)


@pulumi.input_type
class RegionBackendServiceFailoverPolicyArgs:
    def __init__(__self__, *,
                 disable_connection_drain_on_failover: Optional[pulumi.Input[bool]] = None,
                 drop_traffic_if_unhealthy: Optional[pulumi.Input[bool]] = None,
                 failover_ratio: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[bool] disable_connection_drain_on_failover: On failover or failback, this field indicates whether connection drain
               will be honored. Setting this to true has the following effect: connections
               to the old active pool are not drained. Connections to the new active pool
               use the timeout of 10 min (currently fixed). Setting to false has the
               following effect: both old and new connections will have a drain timeout
               of 10 min.
               This can be set to true only if the protocol is TCP.
               The default is false.
        :param pulumi.Input[bool] drop_traffic_if_unhealthy: This option is used only when no healthy VMs are detected in the primary
               and backup instance groups. When set to true, traffic is dropped. When
               set to false, new connections are sent across all VMs in the primary group.
               The default is false.
        :param pulumi.Input[float] failover_ratio: The value of the field must be in [0, 1]. If the ratio of the healthy
               VMs in the primary backend is at or below this number, traffic arriving
               at the load-balanced IP will be directed to the failover backend.
               In case where 'failoverRatio' is not set or all the VMs in the backup
               backend are unhealthy, the traffic will be directed back to the primary
               backend in the "force" mode, where traffic will be spread to the healthy
               VMs with the best effort, or to all VMs when no VM is healthy.
               This field is only used with l4 load balancing.
        """
        if disable_connection_drain_on_failover is not None:
            pulumi.set(__self__, "disable_connection_drain_on_failover", disable_connection_drain_on_failover)
        if drop_traffic_if_unhealthy is not None:
            pulumi.set(__self__, "drop_traffic_if_unhealthy", drop_traffic_if_unhealthy)
        if failover_ratio is not None:
            pulumi.set(__self__, "failover_ratio", failover_ratio)

    @property
    @pulumi.getter(name="disableConnectionDrainOnFailover")
    def disable_connection_drain_on_failover(self) -> Optional[pulumi.Input[bool]]:
        """
        On failover or failback, this field indicates whether connection drain
        will be honored. Setting this to true has the following effect: connections
        to the old active pool are not drained. Connections to the new active pool
        use the timeout of 10 min (currently fixed). Setting to false has the
        following effect: both old and new connections will have a drain timeout
        of 10 min.
        This can be set to true only if the protocol is TCP.
        The default is false.
        """
        return pulumi.get(self, "disable_connection_drain_on_failover")

    @disable_connection_drain_on_failover.setter
    def disable_connection_drain_on_failover(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disable_connection_drain_on_failover", value)

    @property
    @pulumi.getter(name="dropTrafficIfUnhealthy")
    def drop_traffic_if_unhealthy(self) -> Optional[pulumi.Input[bool]]:
        """
        This option is used only when no healthy VMs are detected in the primary
        and backup instance groups. When set to true, traffic is dropped. When
        set to false, new connections are sent across all VMs in the primary group.
        The default is false.
        """
        return pulumi.get(self, "drop_traffic_if_unhealthy")

    @drop_traffic_if_unhealthy.setter
    def drop_traffic_if_unhealthy(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "drop_traffic_if_unhealthy", value)

    @property
    @pulumi.getter(name="failoverRatio")
    def failover_ratio(self) -> Optional[pulumi.Input[float]]:
        """
        The value of the field must be in [0, 1]. If the ratio of the healthy
        VMs in the primary backend is at or below this number, traffic arriving
        at the load-balanced IP will be directed to the failover backend.
        In case where 'failoverRatio' is not set or all the VMs in the backup
        backend are unhealthy, the traffic will be directed back to the primary
        backend in the "force" mode, where traffic will be spread to the healthy
        VMs with the best effort, or to all VMs when no VM is healthy.
        This field is only used with l4 load balancing.
        """
        return pulumi.get(self, "failover_ratio")

    @failover_ratio.setter
    def failover_ratio(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "failover_ratio", value)


@pulumi.input_type
class RegionBackendServiceIamBindingConditionArgs:
    def __init__(__self__, *,
                 expression: pulumi.Input[str],
                 title: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] expression: Textual representation of an expression in Common Expression Language syntax.
        :param pulumi.Input[str] title: A title for the expression, i.e. a short string describing its purpose.
        :param pulumi.Input[str] description: An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "title", title)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter
    def title(self) -> pulumi.Input[str]:
        """
        A title for the expression, i.e. a short string describing its purpose.
        """
        return pulumi.get(self, "title")

    @title.setter
    def title(self, value: pulumi.Input[str]):
        pulumi.set(self, "title", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class RegionBackendServiceIamMemberConditionArgs:
    def __init__(__self__, *,
                 expression: pulumi.Input[str],
                 title: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] expression: Textual representation of an expression in Common Expression Language syntax.
        :param pulumi.Input[str] title: A title for the expression, i.e. a short string describing its purpose.
        :param pulumi.Input[str] description: An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "title", title)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter
    def title(self) -> pulumi.Input[str]:
        """
        A title for the expression, i.e. a short string describing its purpose.
        """
        return pulumi.get(self, "title")

    @title.setter
    def title(self, value: pulumi.Input[str]):
        pulumi.set(self, "title", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class RegionBackendServiceIapArgs:
    def __init__(__self__, *,
                 oauth2_client_id: pulumi.Input[str],
                 oauth2_client_secret: pulumi.Input[str],
                 oauth2_client_secret_sha256: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] oauth2_client_id: OAuth2 Client ID for IAP
        :param pulumi.Input[str] oauth2_client_secret: OAuth2 Client Secret for IAP
               **Note**: This property is sensitive and will not be displayed in the plan.
        :param pulumi.Input[str] oauth2_client_secret_sha256: -
               OAuth2 Client Secret SHA-256 for IAP
               **Note**: This property is sensitive and will not be displayed in the plan.
        """
        pulumi.set(__self__, "oauth2_client_id", oauth2_client_id)
        pulumi.set(__self__, "oauth2_client_secret", oauth2_client_secret)
        if oauth2_client_secret_sha256 is not None:
            pulumi.set(__self__, "oauth2_client_secret_sha256", oauth2_client_secret_sha256)

    @property
    @pulumi.getter(name="oauth2ClientId")
    def oauth2_client_id(self) -> pulumi.Input[str]:
        """
        OAuth2 Client ID for IAP
        """
        return pulumi.get(self, "oauth2_client_id")

    @oauth2_client_id.setter
    def oauth2_client_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "oauth2_client_id", value)

    @property
    @pulumi.getter(name="oauth2ClientSecret")
    def oauth2_client_secret(self) -> pulumi.Input[str]:
        """
        OAuth2 Client Secret for IAP
        **Note**: This property is sensitive and will not be displayed in the plan.
        """
        return pulumi.get(self, "oauth2_client_secret")

    @oauth2_client_secret.setter
    def oauth2_client_secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "oauth2_client_secret", value)

    @property
    @pulumi.getter(name="oauth2ClientSecretSha256")
    def oauth2_client_secret_sha256(self) -> Optional[pulumi.Input[str]]:
        """
        -
        OAuth2 Client Secret SHA-256 for IAP
        **Note**: This property is sensitive and will not be displayed in the plan.
        """
        return pulumi.get(self, "oauth2_client_secret_sha256")

    @oauth2_client_secret_sha256.setter
    def oauth2_client_secret_sha256(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "oauth2_client_secret_sha256", value)


@pulumi.input_type
class RegionBackendServiceLogConfigArgs:
    def __init__(__self__, *,
                 enable: Optional[pulumi.Input[bool]] = None,
                 sample_rate: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[bool] enable: Whether to enable logging for the load balancer traffic served by this backend service.
        :param pulumi.Input[float] sample_rate: This field can only be specified if logging is enabled for this backend service. The value of
               the field must be in [0, 1]. This configures the sampling rate of requests to the load balancer
               where 1.0 means all logged requests are reported and 0.0 means no logged requests are reported.
               The default value is 1.0.
        """
        if enable is not None:
            pulumi.set(__self__, "enable", enable)
        if sample_rate is not None:
            pulumi.set(__self__, "sample_rate", sample_rate)

    @property
    @pulumi.getter
    def enable(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to enable logging for the load balancer traffic served by this backend service.
        """
        return pulumi.get(self, "enable")

    @enable.setter
    def enable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable", value)

    @property
    @pulumi.getter(name="sampleRate")
    def sample_rate(self) -> Optional[pulumi.Input[float]]:
        """
        This field can only be specified if logging is enabled for this backend service. The value of
        the field must be in [0, 1]. This configures the sampling rate of requests to the load balancer
        where 1.0 means all logged requests are reported and 0.0 means no logged requests are reported.
        The default value is 1.0.
        """
        return pulumi.get(self, "sample_rate")

    @sample_rate.setter
    def sample_rate(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "sample_rate", value)


@pulumi.input_type
class RegionBackendServiceOutlierDetectionArgs:
    def __init__(__self__, *,
                 base_ejection_time: Optional[pulumi.Input['RegionBackendServiceOutlierDetectionBaseEjectionTimeArgs']] = None,
                 consecutive_errors: Optional[pulumi.Input[int]] = None,
                 consecutive_gateway_failure: Optional[pulumi.Input[int]] = None,
                 enforcing_consecutive_errors: Optional[pulumi.Input[int]] = None,
                 enforcing_consecutive_gateway_failure: Optional[pulumi.Input[int]] = None,
                 enforcing_success_rate: Optional[pulumi.Input[int]] = None,
                 interval: Optional[pulumi.Input['RegionBackendServiceOutlierDetectionIntervalArgs']] = None,
                 max_ejection_percent: Optional[pulumi.Input[int]] = None,
                 success_rate_minimum_hosts: Optional[pulumi.Input[int]] = None,
                 success_rate_request_volume: Optional[pulumi.Input[int]] = None,
                 success_rate_stdev_factor: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input['RegionBackendServiceOutlierDetectionBaseEjectionTimeArgs'] base_ejection_time: The base time that a host is ejected for. The real time is equal to the base
               time multiplied by the number of times the host has been ejected. Defaults to
               30000ms or 30s.
               Structure is documented below.
        :param pulumi.Input[int] consecutive_errors: Number of errors before a host is ejected from the connection pool. When the
               backend host is accessed over HTTP, a 5xx return code qualifies as an error.
               Defaults to 5.
        :param pulumi.Input[int] consecutive_gateway_failure: The number of consecutive gateway failures (502, 503, 504 status or connection
               errors that are mapped to one of those status codes) before a consecutive
               gateway failure ejection occurs. Defaults to 5.
        :param pulumi.Input[int] enforcing_consecutive_errors: The percentage chance that a host will be actually ejected when an outlier
               status is detected through consecutive 5xx. This setting can be used to disable
               ejection or to ramp it up slowly. Defaults to 100.
        :param pulumi.Input[int] enforcing_consecutive_gateway_failure: The percentage chance that a host will be actually ejected when an outlier
               status is detected through consecutive gateway failures. This setting can be
               used to disable ejection or to ramp it up slowly. Defaults to 0.
        :param pulumi.Input[int] enforcing_success_rate: The percentage chance that a host will be actually ejected when an outlier
               status is detected through success rate statistics. This setting can be used to
               disable ejection or to ramp it up slowly. Defaults to 100.
        :param pulumi.Input['RegionBackendServiceOutlierDetectionIntervalArgs'] interval: Time interval between ejection sweep analysis. This can result in both new
               ejections as well as hosts being returned to service. Defaults to 10 seconds.
               Structure is documented below.
        :param pulumi.Input[int] max_ejection_percent: Maximum percentage of hosts in the load balancing pool for the backend service
               that can be ejected. Defaults to 10%.
        :param pulumi.Input[int] success_rate_minimum_hosts: The number of hosts in a cluster that must have enough request volume to detect
               success rate outliers. If the number of hosts is less than this setting, outlier
               detection via success rate statistics is not performed for any host in the
               cluster. Defaults to 5.
        :param pulumi.Input[int] success_rate_request_volume: The minimum number of total requests that must be collected in one interval (as
               defined by the interval duration above) to include this host in success rate
               based outlier detection. If the volume is lower than this setting, outlier
               detection via success rate statistics is not performed for that host. Defaults
               to 100.
        :param pulumi.Input[int] success_rate_stdev_factor: This factor is used to determine the ejection threshold for success rate outlier
               ejection. The ejection threshold is the difference between the mean success
               rate, and the product of this factor and the standard deviation of the mean
               success rate: mean - (stdev * success_rate_stdev_factor). This factor is divided
               by a thousand to get a double. That is, if the desired factor is 1.9, the
               runtime value should be 1900. Defaults to 1900.
        """
        if base_ejection_time is not None:
            pulumi.set(__self__, "base_ejection_time", base_ejection_time)
        if consecutive_errors is not None:
            pulumi.set(__self__, "consecutive_errors", consecutive_errors)
        if consecutive_gateway_failure is not None:
            pulumi.set(__self__, "consecutive_gateway_failure", consecutive_gateway_failure)
        if enforcing_consecutive_errors is not None:
            pulumi.set(__self__, "enforcing_consecutive_errors", enforcing_consecutive_errors)
        if enforcing_consecutive_gateway_failure is not None:
            pulumi.set(__self__, "enforcing_consecutive_gateway_failure", enforcing_consecutive_gateway_failure)
        if enforcing_success_rate is not None:
            pulumi.set(__self__, "enforcing_success_rate", enforcing_success_rate)
        if interval is not None:
            pulumi.set(__self__, "interval", interval)
        if max_ejection_percent is not None:
            pulumi.set(__self__, "max_ejection_percent", max_ejection_percent)
        if success_rate_minimum_hosts is not None:
            pulumi.set(__self__, "success_rate_minimum_hosts", success_rate_minimum_hosts)
        if success_rate_request_volume is not None:
            pulumi.set(__self__, "success_rate_request_volume", success_rate_request_volume)
        if success_rate_stdev_factor is not None:
            pulumi.set(__self__, "success_rate_stdev_factor", success_rate_stdev_factor)

    @property
    @pulumi.getter(name="baseEjectionTime")
    def base_ejection_time(self) -> Optional[pulumi.Input['RegionBackendServiceOutlierDetectionBaseEjectionTimeArgs']]:
        """
        The base time that a host is ejected for. The real time is equal to the base
        time multiplied by the number of times the host has been ejected. Defaults to
        30000ms or 30s.
        Structure is documented below.
        """
        return pulumi.get(self, "base_ejection_time")

    @base_ejection_time.setter
    def base_ejection_time(self, value: Optional[pulumi.Input['RegionBackendServiceOutlierDetectionBaseEjectionTimeArgs']]):
        pulumi.set(self, "base_ejection_time", value)

    @property
    @pulumi.getter(name="consecutiveErrors")
    def consecutive_errors(self) -> Optional[pulumi.Input[int]]:
        """
        Number of errors before a host is ejected from the connection pool. When the
        backend host is accessed over HTTP, a 5xx return code qualifies as an error.
        Defaults to 5.
        """
        return pulumi.get(self, "consecutive_errors")

    @consecutive_errors.setter
    def consecutive_errors(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "consecutive_errors", value)

    @property
    @pulumi.getter(name="consecutiveGatewayFailure")
    def consecutive_gateway_failure(self) -> Optional[pulumi.Input[int]]:
        """
        The number of consecutive gateway failures (502, 503, 504 status or connection
        errors that are mapped to one of those status codes) before a consecutive
        gateway failure ejection occurs. Defaults to 5.
        """
        return pulumi.get(self, "consecutive_gateway_failure")

    @consecutive_gateway_failure.setter
    def consecutive_gateway_failure(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "consecutive_gateway_failure", value)

    @property
    @pulumi.getter(name="enforcingConsecutiveErrors")
    def enforcing_consecutive_errors(self) -> Optional[pulumi.Input[int]]:
        """
        The percentage chance that a host will be actually ejected when an outlier
        status is detected through consecutive 5xx. This setting can be used to disable
        ejection or to ramp it up slowly. Defaults to 100.
        """
        return pulumi.get(self, "enforcing_consecutive_errors")

    @enforcing_consecutive_errors.setter
    def enforcing_consecutive_errors(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "enforcing_consecutive_errors", value)

    @property
    @pulumi.getter(name="enforcingConsecutiveGatewayFailure")
    def enforcing_consecutive_gateway_failure(self) -> Optional[pulumi.Input[int]]:
        """
        The percentage chance that a host will be actually ejected when an outlier
        status is detected through consecutive gateway failures. This setting can be
        used to disable ejection or to ramp it up slowly. Defaults to 0.
        """
        return pulumi.get(self, "enforcing_consecutive_gateway_failure")

    @enforcing_consecutive_gateway_failure.setter
    def enforcing_consecutive_gateway_failure(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "enforcing_consecutive_gateway_failure", value)

    @property
    @pulumi.getter(name="enforcingSuccessRate")
    def enforcing_success_rate(self) -> Optional[pulumi.Input[int]]:
        """
        The percentage chance that a host will be actually ejected when an outlier
        status is detected through success rate statistics. This setting can be used to
        disable ejection or to ramp it up slowly. Defaults to 100.
        """
        return pulumi.get(self, "enforcing_success_rate")

    @enforcing_success_rate.setter
    def enforcing_success_rate(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "enforcing_success_rate", value)

    @property
    @pulumi.getter
    def interval(self) -> Optional[pulumi.Input['RegionBackendServiceOutlierDetectionIntervalArgs']]:
        """
        Time interval between ejection sweep analysis. This can result in both new
        ejections as well as hosts being returned to service. Defaults to 10 seconds.
        Structure is documented below.
        """
        return pulumi.get(self, "interval")

    @interval.setter
    def interval(self, value: Optional[pulumi.Input['RegionBackendServiceOutlierDetectionIntervalArgs']]):
        pulumi.set(self, "interval", value)

    @property
    @pulumi.getter(name="maxEjectionPercent")
    def max_ejection_percent(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum percentage of hosts in the load balancing pool for the backend service
        that can be ejected. Defaults to 10%.
        """
        return pulumi.get(self, "max_ejection_percent")

    @max_ejection_percent.setter
    def max_ejection_percent(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_ejection_percent", value)

    @property
    @pulumi.getter(name="successRateMinimumHosts")
    def success_rate_minimum_hosts(self) -> Optional[pulumi.Input[int]]:
        """
        The number of hosts in a cluster that must have enough request volume to detect
        success rate outliers. If the number of hosts is less than this setting, outlier
        detection via success rate statistics is not performed for any host in the
        cluster. Defaults to 5.
        """
        return pulumi.get(self, "success_rate_minimum_hosts")

    @success_rate_minimum_hosts.setter
    def success_rate_minimum_hosts(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "success_rate_minimum_hosts", value)

    @property
    @pulumi.getter(name="successRateRequestVolume")
    def success_rate_request_volume(self) -> Optional[pulumi.Input[int]]:
        """
        The minimum number of total requests that must be collected in one interval (as
        defined by the interval duration above) to include this host in success rate
        based outlier detection. If the volume is lower than this setting, outlier
        detection via success rate statistics is not performed for that host. Defaults
        to 100.
        """
        return pulumi.get(self, "success_rate_request_volume")

    @success_rate_request_volume.setter
    def success_rate_request_volume(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "success_rate_request_volume", value)

    @property
    @pulumi.getter(name="successRateStdevFactor")
    def success_rate_stdev_factor(self) -> Optional[pulumi.Input[int]]:
        """
        This factor is used to determine the ejection threshold for success rate outlier
        ejection. The ejection threshold is the difference between the mean success
        rate, and the product of this factor and the standard deviation of the mean
        success rate: mean - (stdev * success_rate_stdev_factor). This factor is divided
        by a thousand to get a double. That is, if the desired factor is 1.9, the
        runtime value should be 1900. Defaults to 1900.
        """
        return pulumi.get(self, "success_rate_stdev_factor")

    @success_rate_stdev_factor.setter
    def success_rate_stdev_factor(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "success_rate_stdev_factor", value)


@pulumi.input_type
class RegionBackendServiceOutlierDetectionBaseEjectionTimeArgs:
    def __init__(__self__, *,
                 seconds: pulumi.Input[int],
                 nanos: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
               inclusive.
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations
               less than one second are represented with a 0 `seconds` field and a positive
               `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        pulumi.set(__self__, "seconds", seconds)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)

    @property
    @pulumi.getter
    def seconds(self) -> pulumi.Input[int]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
        inclusive.
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: pulumi.Input[int]):
        pulumi.set(self, "seconds", value)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations
        less than one second are represented with a 0 `seconds` field and a positive
        `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)


@pulumi.input_type
class RegionBackendServiceOutlierDetectionIntervalArgs:
    def __init__(__self__, *,
                 seconds: pulumi.Input[int],
                 nanos: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
               inclusive.
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations
               less than one second are represented with a 0 `seconds` field and a positive
               `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        pulumi.set(__self__, "seconds", seconds)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)

    @property
    @pulumi.getter
    def seconds(self) -> pulumi.Input[int]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
        inclusive.
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: pulumi.Input[int]):
        pulumi.set(self, "seconds", value)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations
        less than one second are represented with a 0 `seconds` field and a positive
        `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)


@pulumi.input_type
class RegionBackendServiceSubsettingArgs:
    def __init__(__self__, *,
                 policy: pulumi.Input[str]):
        """
        :param pulumi.Input[str] policy: The algorithm used for subsetting.
               Possible values are `CONSISTENT_HASH_SUBSETTING`.
        """
        pulumi.set(__self__, "policy", policy)

    @property
    @pulumi.getter
    def policy(self) -> pulumi.Input[str]:
        """
        The algorithm used for subsetting.
        Possible values are `CONSISTENT_HASH_SUBSETTING`.
        """
        return pulumi.get(self, "policy")

    @policy.setter
    def policy(self, value: pulumi.Input[str]):
        pulumi.set(self, "policy", value)


@pulumi.input_type
class RegionDiskDiskEncryptionKeyArgs:
    def __init__(__self__, *,
                 kms_key_name: Optional[pulumi.Input[str]] = None,
                 raw_key: Optional[pulumi.Input[str]] = None,
                 sha256: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] kms_key_name: The name of the encryption key that is stored in Google Cloud KMS.
        :param pulumi.Input[str] raw_key: Specifies a 256-bit customer-supplied encryption key, encoded in
               RFC 4648 base64 to either encrypt or decrypt this resource.
        :param pulumi.Input[str] sha256: -
               The RFC 4648 base64 encoded SHA-256 hash of the customer-supplied
               encryption key that protects this resource.
        """
        if kms_key_name is not None:
            pulumi.set(__self__, "kms_key_name", kms_key_name)
        if raw_key is not None:
            pulumi.set(__self__, "raw_key", raw_key)
        if sha256 is not None:
            pulumi.set(__self__, "sha256", sha256)

    @property
    @pulumi.getter(name="kmsKeyName")
    def kms_key_name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the encryption key that is stored in Google Cloud KMS.
        """
        return pulumi.get(self, "kms_key_name")

    @kms_key_name.setter
    def kms_key_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_name", value)

    @property
    @pulumi.getter(name="rawKey")
    def raw_key(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies a 256-bit customer-supplied encryption key, encoded in
        RFC 4648 base64 to either encrypt or decrypt this resource.
        """
        return pulumi.get(self, "raw_key")

    @raw_key.setter
    def raw_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "raw_key", value)

    @property
    @pulumi.getter
    def sha256(self) -> Optional[pulumi.Input[str]]:
        """
        -
        The RFC 4648 base64 encoded SHA-256 hash of the customer-supplied
        encryption key that protects this resource.
        """
        return pulumi.get(self, "sha256")

    @sha256.setter
    def sha256(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sha256", value)


@pulumi.input_type
class RegionDiskIamBindingConditionArgs:
    def __init__(__self__, *,
                 expression: pulumi.Input[str],
                 title: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "title", title)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter
    def title(self) -> pulumi.Input[str]:
        return pulumi.get(self, "title")

    @title.setter
    def title(self, value: pulumi.Input[str]):
        pulumi.set(self, "title", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class RegionDiskIamMemberConditionArgs:
    def __init__(__self__, *,
                 expression: pulumi.Input[str],
                 title: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "title", title)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter
    def title(self) -> pulumi.Input[str]:
        return pulumi.get(self, "title")

    @title.setter
    def title(self, value: pulumi.Input[str]):
        pulumi.set(self, "title", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class RegionDiskSourceSnapshotEncryptionKeyArgs:
    def __init__(__self__, *,
                 kms_key_name: Optional[pulumi.Input[str]] = None,
                 raw_key: Optional[pulumi.Input[str]] = None,
                 sha256: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] kms_key_name: The name of the encryption key that is stored in Google Cloud KMS.
        :param pulumi.Input[str] raw_key: Specifies a 256-bit customer-supplied encryption key, encoded in
               RFC 4648 base64 to either encrypt or decrypt this resource.
        :param pulumi.Input[str] sha256: -
               The RFC 4648 base64 encoded SHA-256 hash of the customer-supplied
               encryption key that protects this resource.
        """
        if kms_key_name is not None:
            pulumi.set(__self__, "kms_key_name", kms_key_name)
        if raw_key is not None:
            pulumi.set(__self__, "raw_key", raw_key)
        if sha256 is not None:
            pulumi.set(__self__, "sha256", sha256)

    @property
    @pulumi.getter(name="kmsKeyName")
    def kms_key_name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the encryption key that is stored in Google Cloud KMS.
        """
        return pulumi.get(self, "kms_key_name")

    @kms_key_name.setter
    def kms_key_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_name", value)

    @property
    @pulumi.getter(name="rawKey")
    def raw_key(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies a 256-bit customer-supplied encryption key, encoded in
        RFC 4648 base64 to either encrypt or decrypt this resource.
        """
        return pulumi.get(self, "raw_key")

    @raw_key.setter
    def raw_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "raw_key", value)

    @property
    @pulumi.getter
    def sha256(self) -> Optional[pulumi.Input[str]]:
        """
        -
        The RFC 4648 base64 encoded SHA-256 hash of the customer-supplied
        encryption key that protects this resource.
        """
        return pulumi.get(self, "sha256")

    @sha256.setter
    def sha256(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sha256", value)


@pulumi.input_type
class RegionHealthCheckGrpcHealthCheckArgs:
    def __init__(__self__, *,
                 grpc_service_name: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 port_name: Optional[pulumi.Input[str]] = None,
                 port_specification: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] grpc_service_name: The gRPC service name for the health check.
               The value of grpcServiceName has the following meanings by convention:
               * Empty serviceName means the overall status of all services at the backend.
               * Non-empty serviceName means the health of that gRPC service, as defined by the owner of the service.
               The grpcServiceName can only be ASCII.
        :param pulumi.Input[int] port: The port number for the health check request.
               Must be specified if portName and portSpecification are not set
               or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        :param pulumi.Input[str] port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param pulumi.Input[str] port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
               * `USE_NAMED_PORT`: The `portName` is used for health checking.
               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
               network endpoint is used for health checking. For other backends, the
               port or named port specified in the Backend Service is used for health
               checking.
               If not specified, gRPC health check follows behavior specified in `port` and
               `portName` fields.
               Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        """
        if grpc_service_name is not None:
            pulumi.set(__self__, "grpc_service_name", grpc_service_name)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if port_name is not None:
            pulumi.set(__self__, "port_name", port_name)
        if port_specification is not None:
            pulumi.set(__self__, "port_specification", port_specification)

    @property
    @pulumi.getter(name="grpcServiceName")
    def grpc_service_name(self) -> Optional[pulumi.Input[str]]:
        """
        The gRPC service name for the health check.
        The value of grpcServiceName has the following meanings by convention:
        * Empty serviceName means the overall status of all services at the backend.
        * Non-empty serviceName means the health of that gRPC service, as defined by the owner of the service.
        The grpcServiceName can only be ASCII.
        """
        return pulumi.get(self, "grpc_service_name")

    @grpc_service_name.setter
    def grpc_service_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "grpc_service_name", value)

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[int]]:
        """
        The port number for the health check request.
        Must be specified if portName and portSpecification are not set
        or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> Optional[pulumi.Input[str]]:
        """
        Port name as defined in InstanceGroup#NamedPort#name. If both port and
        port_name are defined, port takes precedence.
        """
        return pulumi.get(self, "port_name")

    @port_name.setter
    def port_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_name", value)

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
        * `USE_NAMED_PORT`: The `portName` is used for health checking.
        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
        network endpoint is used for health checking. For other backends, the
        port or named port specified in the Backend Service is used for health
        checking.
        If not specified, gRPC health check follows behavior specified in `port` and
        `portName` fields.
        Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        """
        return pulumi.get(self, "port_specification")

    @port_specification.setter
    def port_specification(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_specification", value)


@pulumi.input_type
class RegionHealthCheckHttp2HealthCheckArgs:
    def __init__(__self__, *,
                 host: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 port_name: Optional[pulumi.Input[str]] = None,
                 port_specification: Optional[pulumi.Input[str]] = None,
                 proxy_header: Optional[pulumi.Input[str]] = None,
                 request_path: Optional[pulumi.Input[str]] = None,
                 response: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host: The value of the host header in the HTTP2 health check request.
               If left empty (default value), the public IP on behalf of which this health
               check is performed will be used.
        :param pulumi.Input[int] port: The port number for the health check request.
               Must be specified if portName and portSpecification are not set
               or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        :param pulumi.Input[str] port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param pulumi.Input[str] port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
               * `USE_NAMED_PORT`: The `portName` is used for health checking.
               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
               network endpoint is used for health checking. For other backends, the
               port or named port specified in the Backend Service is used for health
               checking.
               If not specified, gRPC health check follows behavior specified in `port` and
               `portName` fields.
               Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        :param pulumi.Input[str] proxy_header: Specifies the type of proxy header to append before sending data to the
               backend.
               Default value is `NONE`.
               Possible values are `NONE` and `PROXY_V1`.
        :param pulumi.Input[str] request_path: The request path of the HTTP2 health check request.
               The default value is /.
        :param pulumi.Input[str] response: The bytes to match against the beginning of the response data. If left empty
               (the default value), any response will indicate health. The response data
               can only be ASCII.
        """
        if host is not None:
            pulumi.set(__self__, "host", host)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if port_name is not None:
            pulumi.set(__self__, "port_name", port_name)
        if port_specification is not None:
            pulumi.set(__self__, "port_specification", port_specification)
        if proxy_header is not None:
            pulumi.set(__self__, "proxy_header", proxy_header)
        if request_path is not None:
            pulumi.set(__self__, "request_path", request_path)
        if response is not None:
            pulumi.set(__self__, "response", response)

    @property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the host header in the HTTP2 health check request.
        If left empty (default value), the public IP on behalf of which this health
        check is performed will be used.
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host", value)

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[int]]:
        """
        The port number for the health check request.
        Must be specified if portName and portSpecification are not set
        or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> Optional[pulumi.Input[str]]:
        """
        Port name as defined in InstanceGroup#NamedPort#name. If both port and
        port_name are defined, port takes precedence.
        """
        return pulumi.get(self, "port_name")

    @port_name.setter
    def port_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_name", value)

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
        * `USE_NAMED_PORT`: The `portName` is used for health checking.
        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
        network endpoint is used for health checking. For other backends, the
        port or named port specified in the Backend Service is used for health
        checking.
        If not specified, gRPC health check follows behavior specified in `port` and
        `portName` fields.
        Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        """
        return pulumi.get(self, "port_specification")

    @port_specification.setter
    def port_specification(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_specification", value)

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the type of proxy header to append before sending data to the
        backend.
        Default value is `NONE`.
        Possible values are `NONE` and `PROXY_V1`.
        """
        return pulumi.get(self, "proxy_header")

    @proxy_header.setter
    def proxy_header(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "proxy_header", value)

    @property
    @pulumi.getter(name="requestPath")
    def request_path(self) -> Optional[pulumi.Input[str]]:
        """
        The request path of the HTTP2 health check request.
        The default value is /.
        """
        return pulumi.get(self, "request_path")

    @request_path.setter
    def request_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "request_path", value)

    @property
    @pulumi.getter
    def response(self) -> Optional[pulumi.Input[str]]:
        """
        The bytes to match against the beginning of the response data. If left empty
        (the default value), any response will indicate health. The response data
        can only be ASCII.
        """
        return pulumi.get(self, "response")

    @response.setter
    def response(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "response", value)


@pulumi.input_type
class RegionHealthCheckHttpHealthCheckArgs:
    def __init__(__self__, *,
                 host: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 port_name: Optional[pulumi.Input[str]] = None,
                 port_specification: Optional[pulumi.Input[str]] = None,
                 proxy_header: Optional[pulumi.Input[str]] = None,
                 request_path: Optional[pulumi.Input[str]] = None,
                 response: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host: The value of the host header in the HTTP2 health check request.
               If left empty (default value), the public IP on behalf of which this health
               check is performed will be used.
        :param pulumi.Input[int] port: The port number for the health check request.
               Must be specified if portName and portSpecification are not set
               or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        :param pulumi.Input[str] port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param pulumi.Input[str] port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
               * `USE_NAMED_PORT`: The `portName` is used for health checking.
               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
               network endpoint is used for health checking. For other backends, the
               port or named port specified in the Backend Service is used for health
               checking.
               If not specified, gRPC health check follows behavior specified in `port` and
               `portName` fields.
               Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        :param pulumi.Input[str] proxy_header: Specifies the type of proxy header to append before sending data to the
               backend.
               Default value is `NONE`.
               Possible values are `NONE` and `PROXY_V1`.
        :param pulumi.Input[str] request_path: The request path of the HTTP2 health check request.
               The default value is /.
        :param pulumi.Input[str] response: The bytes to match against the beginning of the response data. If left empty
               (the default value), any response will indicate health. The response data
               can only be ASCII.
        """
        if host is not None:
            pulumi.set(__self__, "host", host)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if port_name is not None:
            pulumi.set(__self__, "port_name", port_name)
        if port_specification is not None:
            pulumi.set(__self__, "port_specification", port_specification)
        if proxy_header is not None:
            pulumi.set(__self__, "proxy_header", proxy_header)
        if request_path is not None:
            pulumi.set(__self__, "request_path", request_path)
        if response is not None:
            pulumi.set(__self__, "response", response)

    @property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the host header in the HTTP2 health check request.
        If left empty (default value), the public IP on behalf of which this health
        check is performed will be used.
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host", value)

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[int]]:
        """
        The port number for the health check request.
        Must be specified if portName and portSpecification are not set
        or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> Optional[pulumi.Input[str]]:
        """
        Port name as defined in InstanceGroup#NamedPort#name. If both port and
        port_name are defined, port takes precedence.
        """
        return pulumi.get(self, "port_name")

    @port_name.setter
    def port_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_name", value)

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
        * `USE_NAMED_PORT`: The `portName` is used for health checking.
        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
        network endpoint is used for health checking. For other backends, the
        port or named port specified in the Backend Service is used for health
        checking.
        If not specified, gRPC health check follows behavior specified in `port` and
        `portName` fields.
        Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        """
        return pulumi.get(self, "port_specification")

    @port_specification.setter
    def port_specification(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_specification", value)

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the type of proxy header to append before sending data to the
        backend.
        Default value is `NONE`.
        Possible values are `NONE` and `PROXY_V1`.
        """
        return pulumi.get(self, "proxy_header")

    @proxy_header.setter
    def proxy_header(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "proxy_header", value)

    @property
    @pulumi.getter(name="requestPath")
    def request_path(self) -> Optional[pulumi.Input[str]]:
        """
        The request path of the HTTP2 health check request.
        The default value is /.
        """
        return pulumi.get(self, "request_path")

    @request_path.setter
    def request_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "request_path", value)

    @property
    @pulumi.getter
    def response(self) -> Optional[pulumi.Input[str]]:
        """
        The bytes to match against the beginning of the response data. If left empty
        (the default value), any response will indicate health. The response data
        can only be ASCII.
        """
        return pulumi.get(self, "response")

    @response.setter
    def response(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "response", value)


@pulumi.input_type
class RegionHealthCheckHttpsHealthCheckArgs:
    def __init__(__self__, *,
                 host: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 port_name: Optional[pulumi.Input[str]] = None,
                 port_specification: Optional[pulumi.Input[str]] = None,
                 proxy_header: Optional[pulumi.Input[str]] = None,
                 request_path: Optional[pulumi.Input[str]] = None,
                 response: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host: The value of the host header in the HTTP2 health check request.
               If left empty (default value), the public IP on behalf of which this health
               check is performed will be used.
        :param pulumi.Input[int] port: The port number for the health check request.
               Must be specified if portName and portSpecification are not set
               or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        :param pulumi.Input[str] port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param pulumi.Input[str] port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
               * `USE_NAMED_PORT`: The `portName` is used for health checking.
               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
               network endpoint is used for health checking. For other backends, the
               port or named port specified in the Backend Service is used for health
               checking.
               If not specified, gRPC health check follows behavior specified in `port` and
               `portName` fields.
               Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        :param pulumi.Input[str] proxy_header: Specifies the type of proxy header to append before sending data to the
               backend.
               Default value is `NONE`.
               Possible values are `NONE` and `PROXY_V1`.
        :param pulumi.Input[str] request_path: The request path of the HTTP2 health check request.
               The default value is /.
        :param pulumi.Input[str] response: The bytes to match against the beginning of the response data. If left empty
               (the default value), any response will indicate health. The response data
               can only be ASCII.
        """
        if host is not None:
            pulumi.set(__self__, "host", host)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if port_name is not None:
            pulumi.set(__self__, "port_name", port_name)
        if port_specification is not None:
            pulumi.set(__self__, "port_specification", port_specification)
        if proxy_header is not None:
            pulumi.set(__self__, "proxy_header", proxy_header)
        if request_path is not None:
            pulumi.set(__self__, "request_path", request_path)
        if response is not None:
            pulumi.set(__self__, "response", response)

    @property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the host header in the HTTP2 health check request.
        If left empty (default value), the public IP on behalf of which this health
        check is performed will be used.
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host", value)

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[int]]:
        """
        The port number for the health check request.
        Must be specified if portName and portSpecification are not set
        or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> Optional[pulumi.Input[str]]:
        """
        Port name as defined in InstanceGroup#NamedPort#name. If both port and
        port_name are defined, port takes precedence.
        """
        return pulumi.get(self, "port_name")

    @port_name.setter
    def port_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_name", value)

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
        * `USE_NAMED_PORT`: The `portName` is used for health checking.
        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
        network endpoint is used for health checking. For other backends, the
        port or named port specified in the Backend Service is used for health
        checking.
        If not specified, gRPC health check follows behavior specified in `port` and
        `portName` fields.
        Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        """
        return pulumi.get(self, "port_specification")

    @port_specification.setter
    def port_specification(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_specification", value)

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the type of proxy header to append before sending data to the
        backend.
        Default value is `NONE`.
        Possible values are `NONE` and `PROXY_V1`.
        """
        return pulumi.get(self, "proxy_header")

    @proxy_header.setter
    def proxy_header(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "proxy_header", value)

    @property
    @pulumi.getter(name="requestPath")
    def request_path(self) -> Optional[pulumi.Input[str]]:
        """
        The request path of the HTTP2 health check request.
        The default value is /.
        """
        return pulumi.get(self, "request_path")

    @request_path.setter
    def request_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "request_path", value)

    @property
    @pulumi.getter
    def response(self) -> Optional[pulumi.Input[str]]:
        """
        The bytes to match against the beginning of the response data. If left empty
        (the default value), any response will indicate health. The response data
        can only be ASCII.
        """
        return pulumi.get(self, "response")

    @response.setter
    def response(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "response", value)


@pulumi.input_type
class RegionHealthCheckLogConfigArgs:
    def __init__(__self__, *,
                 enable: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] enable: Indicates whether or not to export logs. This is false by default,
               which means no health check logging will be done.
        """
        if enable is not None:
            pulumi.set(__self__, "enable", enable)

    @property
    @pulumi.getter
    def enable(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether or not to export logs. This is false by default,
        which means no health check logging will be done.
        """
        return pulumi.get(self, "enable")

    @enable.setter
    def enable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable", value)


@pulumi.input_type
class RegionHealthCheckSslHealthCheckArgs:
    def __init__(__self__, *,
                 port: Optional[pulumi.Input[int]] = None,
                 port_name: Optional[pulumi.Input[str]] = None,
                 port_specification: Optional[pulumi.Input[str]] = None,
                 proxy_header: Optional[pulumi.Input[str]] = None,
                 request: Optional[pulumi.Input[str]] = None,
                 response: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] port: The port number for the health check request.
               Must be specified if portName and portSpecification are not set
               or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        :param pulumi.Input[str] port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param pulumi.Input[str] port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
               * `USE_NAMED_PORT`: The `portName` is used for health checking.
               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
               network endpoint is used for health checking. For other backends, the
               port or named port specified in the Backend Service is used for health
               checking.
               If not specified, gRPC health check follows behavior specified in `port` and
               `portName` fields.
               Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        :param pulumi.Input[str] proxy_header: Specifies the type of proxy header to append before sending data to the
               backend.
               Default value is `NONE`.
               Possible values are `NONE` and `PROXY_V1`.
        :param pulumi.Input[str] request: The application data to send once the SSL connection has been
               established (default value is empty). If both request and response are
               empty, the connection establishment alone will indicate health. The request
               data can only be ASCII.
        :param pulumi.Input[str] response: The bytes to match against the beginning of the response data. If left empty
               (the default value), any response will indicate health. The response data
               can only be ASCII.
        """
        if port is not None:
            pulumi.set(__self__, "port", port)
        if port_name is not None:
            pulumi.set(__self__, "port_name", port_name)
        if port_specification is not None:
            pulumi.set(__self__, "port_specification", port_specification)
        if proxy_header is not None:
            pulumi.set(__self__, "proxy_header", proxy_header)
        if request is not None:
            pulumi.set(__self__, "request", request)
        if response is not None:
            pulumi.set(__self__, "response", response)

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[int]]:
        """
        The port number for the health check request.
        Must be specified if portName and portSpecification are not set
        or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> Optional[pulumi.Input[str]]:
        """
        Port name as defined in InstanceGroup#NamedPort#name. If both port and
        port_name are defined, port takes precedence.
        """
        return pulumi.get(self, "port_name")

    @port_name.setter
    def port_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_name", value)

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
        * `USE_NAMED_PORT`: The `portName` is used for health checking.
        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
        network endpoint is used for health checking. For other backends, the
        port or named port specified in the Backend Service is used for health
        checking.
        If not specified, gRPC health check follows behavior specified in `port` and
        `portName` fields.
        Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        """
        return pulumi.get(self, "port_specification")

    @port_specification.setter
    def port_specification(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_specification", value)

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the type of proxy header to append before sending data to the
        backend.
        Default value is `NONE`.
        Possible values are `NONE` and `PROXY_V1`.
        """
        return pulumi.get(self, "proxy_header")

    @proxy_header.setter
    def proxy_header(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "proxy_header", value)

    @property
    @pulumi.getter
    def request(self) -> Optional[pulumi.Input[str]]:
        """
        The application data to send once the SSL connection has been
        established (default value is empty). If both request and response are
        empty, the connection establishment alone will indicate health. The request
        data can only be ASCII.
        """
        return pulumi.get(self, "request")

    @request.setter
    def request(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "request", value)

    @property
    @pulumi.getter
    def response(self) -> Optional[pulumi.Input[str]]:
        """
        The bytes to match against the beginning of the response data. If left empty
        (the default value), any response will indicate health. The response data
        can only be ASCII.
        """
        return pulumi.get(self, "response")

    @response.setter
    def response(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "response", value)


@pulumi.input_type
class RegionHealthCheckTcpHealthCheckArgs:
    def __init__(__self__, *,
                 port: Optional[pulumi.Input[int]] = None,
                 port_name: Optional[pulumi.Input[str]] = None,
                 port_specification: Optional[pulumi.Input[str]] = None,
                 proxy_header: Optional[pulumi.Input[str]] = None,
                 request: Optional[pulumi.Input[str]] = None,
                 response: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] port: The port number for the health check request.
               Must be specified if portName and portSpecification are not set
               or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        :param pulumi.Input[str] port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param pulumi.Input[str] port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
               * `USE_NAMED_PORT`: The `portName` is used for health checking.
               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
               network endpoint is used for health checking. For other backends, the
               port or named port specified in the Backend Service is used for health
               checking.
               If not specified, gRPC health check follows behavior specified in `port` and
               `portName` fields.
               Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        :param pulumi.Input[str] proxy_header: Specifies the type of proxy header to append before sending data to the
               backend.
               Default value is `NONE`.
               Possible values are `NONE` and `PROXY_V1`.
        :param pulumi.Input[str] request: The application data to send once the SSL connection has been
               established (default value is empty). If both request and response are
               empty, the connection establishment alone will indicate health. The request
               data can only be ASCII.
        :param pulumi.Input[str] response: The bytes to match against the beginning of the response data. If left empty
               (the default value), any response will indicate health. The response data
               can only be ASCII.
        """
        if port is not None:
            pulumi.set(__self__, "port", port)
        if port_name is not None:
            pulumi.set(__self__, "port_name", port_name)
        if port_specification is not None:
            pulumi.set(__self__, "port_specification", port_specification)
        if proxy_header is not None:
            pulumi.set(__self__, "proxy_header", proxy_header)
        if request is not None:
            pulumi.set(__self__, "request", request)
        if response is not None:
            pulumi.set(__self__, "response", response)

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[int]]:
        """
        The port number for the health check request.
        Must be specified if portName and portSpecification are not set
        or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> Optional[pulumi.Input[str]]:
        """
        Port name as defined in InstanceGroup#NamedPort#name. If both port and
        port_name are defined, port takes precedence.
        """
        return pulumi.get(self, "port_name")

    @port_name.setter
    def port_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_name", value)

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
        * `USE_NAMED_PORT`: The `portName` is used for health checking.
        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
        network endpoint is used for health checking. For other backends, the
        port or named port specified in the Backend Service is used for health
        checking.
        If not specified, gRPC health check follows behavior specified in `port` and
        `portName` fields.
        Possible values are `USE_FIXED_PORT`, `USE_NAMED_PORT`, and `USE_SERVING_PORT`.
        """
        return pulumi.get(self, "port_specification")

    @port_specification.setter
    def port_specification(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port_specification", value)

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the type of proxy header to append before sending data to the
        backend.
        Default value is `NONE`.
        Possible values are `NONE` and `PROXY_V1`.
        """
        return pulumi.get(self, "proxy_header")

    @proxy_header.setter
    def proxy_header(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "proxy_header", value)

    @property
    @pulumi.getter
    def request(self) -> Optional[pulumi.Input[str]]:
        """
        The application data to send once the SSL connection has been
        established (default value is empty). If both request and response are
        empty, the connection establishment alone will indicate health. The request
        data can only be ASCII.
        """
        return pulumi.get(self, "request")

    @request.setter
    def request(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "request", value)

    @property
    @pulumi.getter
    def response(self) -> Optional[pulumi.Input[str]]:
        """
        The bytes to match against the beginning of the response data. If left empty
        (the default value), any response will indicate health. The response data
        can only be ASCII.
        """
        return pulumi.get(self, "response")

    @response.setter
    def response(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "response", value)


@pulumi.input_type
class RegionInstanceGroupManagerAllInstancesConfigArgs:
    def __init__(__self__, *,
                 labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 metadata: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: ), The label key-value pairs that you want to patch onto the instance.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] metadata: ), The metadata key-value pairs that you want to patch onto the instance. For more information, see [Project and instance metadata](https://cloud.google.com/compute/docs/metadata#project_and_instance_metadata).
        """
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if metadata is not None:
            pulumi.set(__self__, "metadata", metadata)

    @property
    @pulumi.getter
    def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        ), The label key-value pairs that you want to patch onto the instance.
        """
        return pulumi.get(self, "labels")

    @labels.setter
    def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "labels", value)

    @property
    @pulumi.getter
    def metadata(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        ), The metadata key-value pairs that you want to patch onto the instance. For more information, see [Project and instance metadata](https://cloud.google.com/compute/docs/metadata#project_and_instance_metadata).
        """
        return pulumi.get(self, "metadata")

    @metadata.setter
    def metadata(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "metadata", value)


@pulumi.input_type
class RegionInstanceGroupManagerAutoHealingPoliciesArgs:
    def __init__(__self__, *,
                 health_check: pulumi.Input[str],
                 initial_delay_sec: pulumi.Input[int]):
        """
        :param pulumi.Input[str] health_check: The health check resource that signals autohealing.
        :param pulumi.Input[int] initial_delay_sec: The number of seconds that the managed instance group waits before
               it applies autohealing policies to new instances or recently recreated instances. Between 0 and 3600.
        """
        pulumi.set(__self__, "health_check", health_check)
        pulumi.set(__self__, "initial_delay_sec", initial_delay_sec)

    @property
    @pulumi.getter(name="healthCheck")
    def health_check(self) -> pulumi.Input[str]:
        """
        The health check resource that signals autohealing.
        """
        return pulumi.get(self, "health_check")

    @health_check.setter
    def health_check(self, value: pulumi.Input[str]):
        pulumi.set(self, "health_check", value)

    @property
    @pulumi.getter(name="initialDelaySec")
    def initial_delay_sec(self) -> pulumi.Input[int]:
        """
        The number of seconds that the managed instance group waits before
        it applies autohealing policies to new instances or recently recreated instances. Between 0 and 3600.
        """
        return pulumi.get(self, "initial_delay_sec")

    @initial_delay_sec.setter
    def initial_delay_sec(self, value: pulumi.Input[int]):
        pulumi.set(self, "initial_delay_sec", value)


@pulumi.input_type
class RegionInstanceGroupManagerNamedPortArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 port: pulumi.Input[int]):
        """
        :param pulumi.Input[str] name: - Version name.
        :param pulumi.Input[int] port: The port number.
               - - -
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        - Version name.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[int]:
        """
        The port number.
        - - -
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: pulumi.Input[int]):
        pulumi.set(self, "port", value)


@pulumi.input_type
class RegionInstanceGroupManagerStatefulDiskArgs:
    def __init__(__self__, *,
                 device_name: pulumi.Input[str],
                 delete_rule: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] device_name: , The device name of the disk to be attached.
        :param pulumi.Input[str] delete_rule: , A value that prescribes what should happen to the stateful disk when the VM instance is deleted. The available options are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`. `NEVER` - detach the disk when the VM is deleted, but do not delete the disk. `ON_PERMANENT_INSTANCE_DELETION` will delete the stateful disk when the VM is permanently deleted from the instance group. The default is `NEVER`.
        """
        pulumi.set(__self__, "device_name", device_name)
        if delete_rule is not None:
            pulumi.set(__self__, "delete_rule", delete_rule)

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> pulumi.Input[str]:
        """
        , The device name of the disk to be attached.
        """
        return pulumi.get(self, "device_name")

    @device_name.setter
    def device_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "device_name", value)

    @property
    @pulumi.getter(name="deleteRule")
    def delete_rule(self) -> Optional[pulumi.Input[str]]:
        """
        , A value that prescribes what should happen to the stateful disk when the VM instance is deleted. The available options are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`. `NEVER` - detach the disk when the VM is deleted, but do not delete the disk. `ON_PERMANENT_INSTANCE_DELETION` will delete the stateful disk when the VM is permanently deleted from the instance group. The default is `NEVER`.
        """
        return pulumi.get(self, "delete_rule")

    @delete_rule.setter
    def delete_rule(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "delete_rule", value)


@pulumi.input_type
class RegionInstanceGroupManagerStatusArgs:
    def __init__(__self__, *,
                 all_instances_configs: Optional[pulumi.Input[Sequence[pulumi.Input['RegionInstanceGroupManagerStatusAllInstancesConfigArgs']]]] = None,
                 is_stable: Optional[pulumi.Input[bool]] = None,
                 statefuls: Optional[pulumi.Input[Sequence[pulumi.Input['RegionInstanceGroupManagerStatusStatefulArgs']]]] = None,
                 version_targets: Optional[pulumi.Input[Sequence[pulumi.Input['RegionInstanceGroupManagerStatusVersionTargetArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['RegionInstanceGroupManagerStatusAllInstancesConfigArgs']]] all_instances_configs: )
               Properties to set on all instances in the group. After setting
               allInstancesConfig on the group, you must update the group's instances to
               apply the configuration.
        :param pulumi.Input[bool] is_stable: A bit indicating whether the managed instance group is in a stable state. A stable state means that: none of the instances in the managed instance group is currently undergoing any type of change (for example, creation, restart, or deletion); no future changes are scheduled for instances in the managed instance group; and the managed instance group itself is not being modified.
        :param pulumi.Input[Sequence[pulumi.Input['RegionInstanceGroupManagerStatusStatefulArgs']]] statefuls: Stateful status of the given Instance Group Manager.
        :param pulumi.Input[Sequence[pulumi.Input['RegionInstanceGroupManagerStatusVersionTargetArgs']]] version_targets: A bit indicating whether version target has been reached in this managed instance group, i.e. all instances are in their target version. Instances' target version are specified by version field on Instance Group Manager.
        """
        if all_instances_configs is not None:
            pulumi.set(__self__, "all_instances_configs", all_instances_configs)
        if is_stable is not None:
            pulumi.set(__self__, "is_stable", is_stable)
        if statefuls is not None:
            pulumi.set(__self__, "statefuls", statefuls)
        if version_targets is not None:
            pulumi.set(__self__, "version_targets", version_targets)

    @property
    @pulumi.getter(name="allInstancesConfigs")
    def all_instances_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionInstanceGroupManagerStatusAllInstancesConfigArgs']]]]:
        """
        )
        Properties to set on all instances in the group. After setting
        allInstancesConfig on the group, you must update the group's instances to
        apply the configuration.
        """
        return pulumi.get(self, "all_instances_configs")

    @all_instances_configs.setter
    def all_instances_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionInstanceGroupManagerStatusAllInstancesConfigArgs']]]]):
        pulumi.set(self, "all_instances_configs", value)

    @property
    @pulumi.getter(name="isStable")
    def is_stable(self) -> Optional[pulumi.Input[bool]]:
        """
        A bit indicating whether the managed instance group is in a stable state. A stable state means that: none of the instances in the managed instance group is currently undergoing any type of change (for example, creation, restart, or deletion); no future changes are scheduled for instances in the managed instance group; and the managed instance group itself is not being modified.
        """
        return pulumi.get(self, "is_stable")

    @is_stable.setter
    def is_stable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "is_stable", value)

    @property
    @pulumi.getter
    def statefuls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionInstanceGroupManagerStatusStatefulArgs']]]]:
        """
        Stateful status of the given Instance Group Manager.
        """
        return pulumi.get(self, "statefuls")

    @statefuls.setter
    def statefuls(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionInstanceGroupManagerStatusStatefulArgs']]]]):
        pulumi.set(self, "statefuls", value)

    @property
    @pulumi.getter(name="versionTargets")
    def version_targets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionInstanceGroupManagerStatusVersionTargetArgs']]]]:
        """
        A bit indicating whether version target has been reached in this managed instance group, i.e. all instances are in their target version. Instances' target version are specified by version field on Instance Group Manager.
        """
        return pulumi.get(self, "version_targets")

    @version_targets.setter
    def version_targets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionInstanceGroupManagerStatusVersionTargetArgs']]]]):
        pulumi.set(self, "version_targets", value)


@pulumi.input_type
class RegionInstanceGroupManagerStatusAllInstancesConfigArgs:
    def __init__(__self__, *,
                 effective: Optional[pulumi.Input[bool]] = None):
        if effective is not None:
            pulumi.set(__self__, "effective", effective)

    @property
    @pulumi.getter
    def effective(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "effective")

    @effective.setter
    def effective(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "effective", value)


@pulumi.input_type
class RegionInstanceGroupManagerStatusStatefulArgs:
    def __init__(__self__, *,
                 has_stateful_config: Optional[pulumi.Input[bool]] = None,
                 per_instance_configs: Optional[pulumi.Input[Sequence[pulumi.Input['RegionInstanceGroupManagerStatusStatefulPerInstanceConfigArgs']]]] = None):
        """
        :param pulumi.Input[bool] has_stateful_config: A bit indicating whether the managed instance group has stateful configuration, that is, if you have configured any items in a stateful policy or in per-instance configs. The group might report that it has no stateful config even when there is still some preserved state on a managed instance, for example, if you have deleted all PICs but not yet applied those deletions.
        :param pulumi.Input[Sequence[pulumi.Input['RegionInstanceGroupManagerStatusStatefulPerInstanceConfigArgs']]] per_instance_configs: Status of per-instance configs on the instance.
        """
        if has_stateful_config is not None:
            pulumi.set(__self__, "has_stateful_config", has_stateful_config)
        if per_instance_configs is not None:
            pulumi.set(__self__, "per_instance_configs", per_instance_configs)

    @property
    @pulumi.getter(name="hasStatefulConfig")
    def has_stateful_config(self) -> Optional[pulumi.Input[bool]]:
        """
        A bit indicating whether the managed instance group has stateful configuration, that is, if you have configured any items in a stateful policy or in per-instance configs. The group might report that it has no stateful config even when there is still some preserved state on a managed instance, for example, if you have deleted all PICs but not yet applied those deletions.
        """
        return pulumi.get(self, "has_stateful_config")

    @has_stateful_config.setter
    def has_stateful_config(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "has_stateful_config", value)

    @property
    @pulumi.getter(name="perInstanceConfigs")
    def per_instance_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionInstanceGroupManagerStatusStatefulPerInstanceConfigArgs']]]]:
        """
        Status of per-instance configs on the instance.
        """
        return pulumi.get(self, "per_instance_configs")

    @per_instance_configs.setter
    def per_instance_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionInstanceGroupManagerStatusStatefulPerInstanceConfigArgs']]]]):
        pulumi.set(self, "per_instance_configs", value)


@pulumi.input_type
class RegionInstanceGroupManagerStatusStatefulPerInstanceConfigArgs:
    def __init__(__self__, *,
                 all_effective: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] all_effective: A bit indicating if all of the group's per-instance configs (listed in the output of a listPerInstanceConfigs API call) have status `EFFECTIVE` or there are no per-instance-configs.
        """
        if all_effective is not None:
            pulumi.set(__self__, "all_effective", all_effective)

    @property
    @pulumi.getter(name="allEffective")
    def all_effective(self) -> Optional[pulumi.Input[bool]]:
        """
        A bit indicating if all of the group's per-instance configs (listed in the output of a listPerInstanceConfigs API call) have status `EFFECTIVE` or there are no per-instance-configs.
        """
        return pulumi.get(self, "all_effective")

    @all_effective.setter
    def all_effective(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "all_effective", value)


@pulumi.input_type
class RegionInstanceGroupManagerStatusVersionTargetArgs:
    def __init__(__self__, *,
                 is_reached: Optional[pulumi.Input[bool]] = None):
        if is_reached is not None:
            pulumi.set(__self__, "is_reached", is_reached)

    @property
    @pulumi.getter(name="isReached")
    def is_reached(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "is_reached")

    @is_reached.setter
    def is_reached(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "is_reached", value)


@pulumi.input_type
class RegionInstanceGroupManagerUpdatePolicyArgs:
    def __init__(__self__, *,
                 minimal_action: pulumi.Input[str],
                 type: pulumi.Input[str],
                 instance_redistribution_type: Optional[pulumi.Input[str]] = None,
                 max_surge_fixed: Optional[pulumi.Input[int]] = None,
                 max_surge_percent: Optional[pulumi.Input[int]] = None,
                 max_unavailable_fixed: Optional[pulumi.Input[int]] = None,
                 max_unavailable_percent: Optional[pulumi.Input[int]] = None,
                 min_ready_sec: Optional[pulumi.Input[int]] = None,
                 most_disruptive_allowed_action: Optional[pulumi.Input[str]] = None,
                 replacement_method: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] minimal_action: - Minimal action to be taken on an instance. You can specify either `REFRESH` to update without stopping instances, `RESTART` to restart existing instances or `REPLACE` to delete and create new instances from the target template. If you specify a `REFRESH`, the Updater will attempt to perform that action only. However, if the Updater determines that the minimal action you specify is not enough to perform the update, it might perform a more disruptive action.
        :param pulumi.Input[str] type: - The type of update process. You can specify either `PROACTIVE` so that the instance group manager proactively executes actions in order to bring instances to their target versions or `OPPORTUNISTIC` so that no action is proactively executed but the update will be performed as part of other actions (for example, resizes or recreateInstances calls).
        :param pulumi.Input[str] instance_redistribution_type: - The instance redistribution policy for regional managed instance groups. Valid values are: `"PROACTIVE"`, `"NONE"`. If `PROACTIVE` (default), the group attempts to maintain an even distribution of VM instances across zones in the region. If `NONE`, proactive redistribution is disabled.
        :param pulumi.Input[int] max_surge_fixed: , The maximum number of instances that can be created above the specified targetSize during the update process. Conflicts with `max_surge_percent`. It has to be either 0 or at least equal to the number of zones.  If fixed values are used, at least one of `max_unavailable_fixed` or `max_surge_fixed` must be greater than 0.
        :param pulumi.Input[int] max_surge_percent: , The maximum number of instances(calculated as percentage) that can be created above the specified targetSize during the update process. Conflicts with `max_surge_fixed`. Percent value is only allowed for regional managed instance groups with size at least 10.
        :param pulumi.Input[int] max_unavailable_fixed: , The maximum number of instances that can be unavailable during the update process. Conflicts with `max_unavailable_percent`. It has to be either 0 or at least equal to the number of zones. If fixed values are used, at least one of `max_unavailable_fixed` or `max_surge_fixed` must be greater than 0.
        :param pulumi.Input[int] max_unavailable_percent: , The maximum number of instances(calculated as percentage) that can be unavailable during the update process. Conflicts with `max_unavailable_fixed`. Percent value is only allowed for regional managed instance groups with size at least 10.
        :param pulumi.Input[int] min_ready_sec: ), Minimum number of seconds to wait for after a newly created instance becomes available. This value must be from range [0, 3600]
        :param pulumi.Input[str] most_disruptive_allowed_action: - Most disruptive action that is allowed to be taken on an instance. You can specify either NONE to forbid any actions, REFRESH to allow actions that do not need instance restart, RESTART to allow actions that can be applied without instance replacing or REPLACE to allow all possible actions. If the Updater determines that the minimal update action needed is more disruptive than most disruptive allowed action you specify it will not perform the update at all.
        :param pulumi.Input[str] replacement_method: , The instance replacement method for managed instance groups. Valid values are: "RECREATE", "SUBSTITUTE". If SUBSTITUTE (default), the group replaces VM instances with new instances that have randomly generated names. If RECREATE, instance names are preserved.  You must also set max_unavailable_fixed or max_unavailable_percent to be greater than 0.
               - - -
        """
        pulumi.set(__self__, "minimal_action", minimal_action)
        pulumi.set(__self__, "type", type)
        if instance_redistribution_type is not None:
            pulumi.set(__self__, "instance_redistribution_type", instance_redistribution_type)
        if max_surge_fixed is not None:
            pulumi.set(__self__, "max_surge_fixed", max_surge_fixed)
        if max_surge_percent is not None:
            pulumi.set(__self__, "max_surge_percent", max_surge_percent)
        if max_unavailable_fixed is not None:
            pulumi.set(__self__, "max_unavailable_fixed", max_unavailable_fixed)
        if max_unavailable_percent is not None:
            pulumi.set(__self__, "max_unavailable_percent", max_unavailable_percent)
        if min_ready_sec is not None:
            pulumi.set(__self__, "min_ready_sec", min_ready_sec)
        if most_disruptive_allowed_action is not None:
            pulumi.set(__self__, "most_disruptive_allowed_action", most_disruptive_allowed_action)
        if replacement_method is not None:
            pulumi.set(__self__, "replacement_method", replacement_method)

    @property
    @pulumi.getter(name="minimalAction")
    def minimal_action(self) -> pulumi.Input[str]:
        """
        - Minimal action to be taken on an instance. You can specify either `REFRESH` to update without stopping instances, `RESTART` to restart existing instances or `REPLACE` to delete and create new instances from the target template. If you specify a `REFRESH`, the Updater will attempt to perform that action only. However, if the Updater determines that the minimal action you specify is not enough to perform the update, it might perform a more disruptive action.
        """
        return pulumi.get(self, "minimal_action")

    @minimal_action.setter
    def minimal_action(self, value: pulumi.Input[str]):
        pulumi.set(self, "minimal_action", value)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        - The type of update process. You can specify either `PROACTIVE` so that the instance group manager proactively executes actions in order to bring instances to their target versions or `OPPORTUNISTIC` so that no action is proactively executed but the update will be performed as part of other actions (for example, resizes or recreateInstances calls).
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter(name="instanceRedistributionType")
    def instance_redistribution_type(self) -> Optional[pulumi.Input[str]]:
        """
        - The instance redistribution policy for regional managed instance groups. Valid values are: `"PROACTIVE"`, `"NONE"`. If `PROACTIVE` (default), the group attempts to maintain an even distribution of VM instances across zones in the region. If `NONE`, proactive redistribution is disabled.
        """
        return pulumi.get(self, "instance_redistribution_type")

    @instance_redistribution_type.setter
    def instance_redistribution_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "instance_redistribution_type", value)

    @property
    @pulumi.getter(name="maxSurgeFixed")
    def max_surge_fixed(self) -> Optional[pulumi.Input[int]]:
        """
        , The maximum number of instances that can be created above the specified targetSize during the update process. Conflicts with `max_surge_percent`. It has to be either 0 or at least equal to the number of zones.  If fixed values are used, at least one of `max_unavailable_fixed` or `max_surge_fixed` must be greater than 0.
        """
        return pulumi.get(self, "max_surge_fixed")

    @max_surge_fixed.setter
    def max_surge_fixed(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_surge_fixed", value)

    @property
    @pulumi.getter(name="maxSurgePercent")
    def max_surge_percent(self) -> Optional[pulumi.Input[int]]:
        """
        , The maximum number of instances(calculated as percentage) that can be created above the specified targetSize during the update process. Conflicts with `max_surge_fixed`. Percent value is only allowed for regional managed instance groups with size at least 10.
        """
        return pulumi.get(self, "max_surge_percent")

    @max_surge_percent.setter
    def max_surge_percent(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_surge_percent", value)

    @property
    @pulumi.getter(name="maxUnavailableFixed")
    def max_unavailable_fixed(self) -> Optional[pulumi.Input[int]]:
        """
        , The maximum number of instances that can be unavailable during the update process. Conflicts with `max_unavailable_percent`. It has to be either 0 or at least equal to the number of zones. If fixed values are used, at least one of `max_unavailable_fixed` or `max_surge_fixed` must be greater than 0.
        """
        return pulumi.get(self, "max_unavailable_fixed")

    @max_unavailable_fixed.setter
    def max_unavailable_fixed(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_unavailable_fixed", value)

    @property
    @pulumi.getter(name="maxUnavailablePercent")
    def max_unavailable_percent(self) -> Optional[pulumi.Input[int]]:
        """
        , The maximum number of instances(calculated as percentage) that can be unavailable during the update process. Conflicts with `max_unavailable_fixed`. Percent value is only allowed for regional managed instance groups with size at least 10.
        """
        return pulumi.get(self, "max_unavailable_percent")

    @max_unavailable_percent.setter
    def max_unavailable_percent(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_unavailable_percent", value)

    @property
    @pulumi.getter(name="minReadySec")
    def min_ready_sec(self) -> Optional[pulumi.Input[int]]:
        """
        ), Minimum number of seconds to wait for after a newly created instance becomes available. This value must be from range [0, 3600]
        """
        return pulumi.get(self, "min_ready_sec")

    @min_ready_sec.setter
    def min_ready_sec(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_ready_sec", value)

    @property
    @pulumi.getter(name="mostDisruptiveAllowedAction")
    def most_disruptive_allowed_action(self) -> Optional[pulumi.Input[str]]:
        """
        - Most disruptive action that is allowed to be taken on an instance. You can specify either NONE to forbid any actions, REFRESH to allow actions that do not need instance restart, RESTART to allow actions that can be applied without instance replacing or REPLACE to allow all possible actions. If the Updater determines that the minimal update action needed is more disruptive than most disruptive allowed action you specify it will not perform the update at all.
        """
        return pulumi.get(self, "most_disruptive_allowed_action")

    @most_disruptive_allowed_action.setter
    def most_disruptive_allowed_action(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "most_disruptive_allowed_action", value)

    @property
    @pulumi.getter(name="replacementMethod")
    def replacement_method(self) -> Optional[pulumi.Input[str]]:
        """
        , The instance replacement method for managed instance groups. Valid values are: "RECREATE", "SUBSTITUTE". If SUBSTITUTE (default), the group replaces VM instances with new instances that have randomly generated names. If RECREATE, instance names are preserved.  You must also set max_unavailable_fixed or max_unavailable_percent to be greater than 0.
        - - -
        """
        return pulumi.get(self, "replacement_method")

    @replacement_method.setter
    def replacement_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "replacement_method", value)


@pulumi.input_type
class RegionInstanceGroupManagerVersionArgs:
    def __init__(__self__, *,
                 instance_template: pulumi.Input[str],
                 name: Optional[pulumi.Input[str]] = None,
                 target_size: Optional[pulumi.Input['RegionInstanceGroupManagerVersionTargetSizeArgs']] = None):
        """
        :param pulumi.Input[str] instance_template: - The full URL to an instance template from which all new instances of this version will be created.
        :param pulumi.Input[str] name: - Version name.
        :param pulumi.Input['RegionInstanceGroupManagerVersionTargetSizeArgs'] target_size: - The number of instances calculated as a fixed number or a percentage depending on the settings. Structure is documented below.
        """
        pulumi.set(__self__, "instance_template", instance_template)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if target_size is not None:
            pulumi.set(__self__, "target_size", target_size)

    @property
    @pulumi.getter(name="instanceTemplate")
    def instance_template(self) -> pulumi.Input[str]:
        """
        - The full URL to an instance template from which all new instances of this version will be created.
        """
        return pulumi.get(self, "instance_template")

    @instance_template.setter
    def instance_template(self, value: pulumi.Input[str]):
        pulumi.set(self, "instance_template", value)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        - Version name.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="targetSize")
    def target_size(self) -> Optional[pulumi.Input['RegionInstanceGroupManagerVersionTargetSizeArgs']]:
        """
        - The number of instances calculated as a fixed number or a percentage depending on the settings. Structure is documented below.
        """
        return pulumi.get(self, "target_size")

    @target_size.setter
    def target_size(self, value: Optional[pulumi.Input['RegionInstanceGroupManagerVersionTargetSizeArgs']]):
        pulumi.set(self, "target_size", value)


@pulumi.input_type
class RegionInstanceGroupManagerVersionTargetSizeArgs:
    def __init__(__self__, *,
                 fixed: Optional[pulumi.Input[int]] = None,
                 percent: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] fixed: , The number of instances which are managed for this version. Conflicts with `percent`.
        :param pulumi.Input[int] percent: , The number of instances (calculated as percentage) which are managed for this version. Conflicts with `fixed`.
               Note that when using `percent`, rounding will be in favor of explicitly set `target_size` values; a managed instance group with 2 instances and 2 `version`s,
               one of which has a `target_size.percent` of `60` will create 2 instances of that `version`.
        """
        if fixed is not None:
            pulumi.set(__self__, "fixed", fixed)
        if percent is not None:
            pulumi.set(__self__, "percent", percent)

    @property
    @pulumi.getter
    def fixed(self) -> Optional[pulumi.Input[int]]:
        """
        , The number of instances which are managed for this version. Conflicts with `percent`.
        """
        return pulumi.get(self, "fixed")

    @fixed.setter
    def fixed(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "fixed", value)

    @property
    @pulumi.getter
    def percent(self) -> Optional[pulumi.Input[int]]:
        """
        , The number of instances (calculated as percentage) which are managed for this version. Conflicts with `fixed`.
        Note that when using `percent`, rounding will be in favor of explicitly set `target_size` values; a managed instance group with 2 instances and 2 `version`s,
        one of which has a `target_size.percent` of `60` will create 2 instances of that `version`.
        """
        return pulumi.get(self, "percent")

    @percent.setter
    def percent(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "percent", value)


@pulumi.input_type
class RegionNetworkEndpointGroupAppEngineArgs:
    def __init__(__self__, *,
                 service: Optional[pulumi.Input[str]] = None,
                 url_mask: Optional[pulumi.Input[str]] = None,
                 version: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] service: Optional serving service.
               The service name must be 1-63 characters long, and comply with RFC1035.
               Example value: "default", "my-service".
        :param pulumi.Input[str] url_mask: A template to parse platform-specific fields from a request URL. URL mask allows for routing to multiple resources
               on the same serverless platform without having to create multiple Network Endpoint Groups and backend resources.
               The fields parsed by this template are platform-specific and are as follows: API Gateway: The gateway ID,
               App Engine: The service and version, Cloud Functions: The function name, Cloud Run: The service and tag
        :param pulumi.Input[str] version: The optional resource version. The version identified by this value is platform-specific and is follows:
               API Gateway: Unused, App Engine: The service version, Cloud Functions: Unused, Cloud Run: The service tag
        """
        if service is not None:
            pulumi.set(__self__, "service", service)
        if url_mask is not None:
            pulumi.set(__self__, "url_mask", url_mask)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def service(self) -> Optional[pulumi.Input[str]]:
        """
        Optional serving service.
        The service name must be 1-63 characters long, and comply with RFC1035.
        Example value: "default", "my-service".
        """
        return pulumi.get(self, "service")

    @service.setter
    def service(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service", value)

    @property
    @pulumi.getter(name="urlMask")
    def url_mask(self) -> Optional[pulumi.Input[str]]:
        """
        A template to parse platform-specific fields from a request URL. URL mask allows for routing to multiple resources
        on the same serverless platform without having to create multiple Network Endpoint Groups and backend resources.
        The fields parsed by this template are platform-specific and are as follows: API Gateway: The gateway ID,
        App Engine: The service and version, Cloud Functions: The function name, Cloud Run: The service and tag
        """
        return pulumi.get(self, "url_mask")

    @url_mask.setter
    def url_mask(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "url_mask", value)

    @property
    @pulumi.getter
    def version(self) -> Optional[pulumi.Input[str]]:
        """
        The optional resource version. The version identified by this value is platform-specific and is follows:
        API Gateway: Unused, App Engine: The service version, Cloud Functions: Unused, Cloud Run: The service tag
        """
        return pulumi.get(self, "version")

    @version.setter
    def version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "version", value)


@pulumi.input_type
class RegionNetworkEndpointGroupCloudFunctionArgs:
    def __init__(__self__, *,
                 function: Optional[pulumi.Input[str]] = None,
                 url_mask: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] function: A user-defined name of the Cloud Function.
               The function name is case-sensitive and must be 1-63 characters long.
               Example value: "func1".
        :param pulumi.Input[str] url_mask: A template to parse platform-specific fields from a request URL. URL mask allows for routing to multiple resources
               on the same serverless platform without having to create multiple Network Endpoint Groups and backend resources.
               The fields parsed by this template are platform-specific and are as follows: API Gateway: The gateway ID,
               App Engine: The service and version, Cloud Functions: The function name, Cloud Run: The service and tag
        """
        if function is not None:
            pulumi.set(__self__, "function", function)
        if url_mask is not None:
            pulumi.set(__self__, "url_mask", url_mask)

    @property
    @pulumi.getter
    def function(self) -> Optional[pulumi.Input[str]]:
        """
        A user-defined name of the Cloud Function.
        The function name is case-sensitive and must be 1-63 characters long.
        Example value: "func1".
        """
        return pulumi.get(self, "function")

    @function.setter
    def function(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "function", value)

    @property
    @pulumi.getter(name="urlMask")
    def url_mask(self) -> Optional[pulumi.Input[str]]:
        """
        A template to parse platform-specific fields from a request URL. URL mask allows for routing to multiple resources
        on the same serverless platform without having to create multiple Network Endpoint Groups and backend resources.
        The fields parsed by this template are platform-specific and are as follows: API Gateway: The gateway ID,
        App Engine: The service and version, Cloud Functions: The function name, Cloud Run: The service and tag
        """
        return pulumi.get(self, "url_mask")

    @url_mask.setter
    def url_mask(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "url_mask", value)


@pulumi.input_type
class RegionNetworkEndpointGroupCloudRunArgs:
    def __init__(__self__, *,
                 service: Optional[pulumi.Input[str]] = None,
                 tag: Optional[pulumi.Input[str]] = None,
                 url_mask: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] service: Optional serving service.
               The service name must be 1-63 characters long, and comply with RFC1035.
               Example value: "default", "my-service".
        :param pulumi.Input[str] tag: Cloud Run tag represents the "named-revision" to provide
               additional fine-grained traffic routing information.
               The tag must be 1-63 characters long, and comply with RFC1035.
               Example value: "revision-0010".
        :param pulumi.Input[str] url_mask: A template to parse platform-specific fields from a request URL. URL mask allows for routing to multiple resources
               on the same serverless platform without having to create multiple Network Endpoint Groups and backend resources.
               The fields parsed by this template are platform-specific and are as follows: API Gateway: The gateway ID,
               App Engine: The service and version, Cloud Functions: The function name, Cloud Run: The service and tag
        """
        if service is not None:
            pulumi.set(__self__, "service", service)
        if tag is not None:
            pulumi.set(__self__, "tag", tag)
        if url_mask is not None:
            pulumi.set(__self__, "url_mask", url_mask)

    @property
    @pulumi.getter
    def service(self) -> Optional[pulumi.Input[str]]:
        """
        Optional serving service.
        The service name must be 1-63 characters long, and comply with RFC1035.
        Example value: "default", "my-service".
        """
        return pulumi.get(self, "service")

    @service.setter
    def service(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service", value)

    @property
    @pulumi.getter
    def tag(self) -> Optional[pulumi.Input[str]]:
        """
        Cloud Run tag represents the "named-revision" to provide
        additional fine-grained traffic routing information.
        The tag must be 1-63 characters long, and comply with RFC1035.
        Example value: "revision-0010".
        """
        return pulumi.get(self, "tag")

    @tag.setter
    def tag(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tag", value)

    @property
    @pulumi.getter(name="urlMask")
    def url_mask(self) -> Optional[pulumi.Input[str]]:
        """
        A template to parse platform-specific fields from a request URL. URL mask allows for routing to multiple resources
        on the same serverless platform without having to create multiple Network Endpoint Groups and backend resources.
        The fields parsed by this template are platform-specific and are as follows: API Gateway: The gateway ID,
        App Engine: The service and version, Cloud Functions: The function name, Cloud Run: The service and tag
        """
        return pulumi.get(self, "url_mask")

    @url_mask.setter
    def url_mask(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "url_mask", value)


@pulumi.input_type
class RegionNetworkEndpointGroupServerlessDeploymentArgs:
    def __init__(__self__, *,
                 platform: pulumi.Input[str],
                 resource: Optional[pulumi.Input[str]] = None,
                 url_mask: Optional[pulumi.Input[str]] = None,
                 version: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] platform: The platform of the NEG backend target(s). Possible values:
               API Gateway: apigateway.googleapis.com
        :param pulumi.Input[str] resource: The user-defined name of the workload/instance. This value must be provided explicitly or in the urlMask.
               The resource identified by this value is platform-specific and is as follows: API Gateway: The gateway ID, App Engine: The service name,
               Cloud Functions: The function name, Cloud Run: The service name
        :param pulumi.Input[str] url_mask: A template to parse platform-specific fields from a request URL. URL mask allows for routing to multiple resources
               on the same serverless platform without having to create multiple Network Endpoint Groups and backend resources.
               The fields parsed by this template are platform-specific and are as follows: API Gateway: The gateway ID,
               App Engine: The service and version, Cloud Functions: The function name, Cloud Run: The service and tag
        :param pulumi.Input[str] version: The optional resource version. The version identified by this value is platform-specific and is follows:
               API Gateway: Unused, App Engine: The service version, Cloud Functions: Unused, Cloud Run: The service tag
        """
        pulumi.set(__self__, "platform", platform)
        if resource is not None:
            pulumi.set(__self__, "resource", resource)
        if url_mask is not None:
            pulumi.set(__self__, "url_mask", url_mask)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def platform(self) -> pulumi.Input[str]:
        """
        The platform of the NEG backend target(s). Possible values:
        API Gateway: apigateway.googleapis.com
        """
        return pulumi.get(self, "platform")

    @platform.setter
    def platform(self, value: pulumi.Input[str]):
        pulumi.set(self, "platform", value)

    @property
    @pulumi.getter
    def resource(self) -> Optional[pulumi.Input[str]]:
        """
        The user-defined name of the workload/instance. This value must be provided explicitly or in the urlMask.
        The resource identified by this value is platform-specific and is as follows: API Gateway: The gateway ID, App Engine: The service name,
        Cloud Functions: The function name, Cloud Run: The service name
        """
        return pulumi.get(self, "resource")

    @resource.setter
    def resource(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resource", value)

    @property
    @pulumi.getter(name="urlMask")
    def url_mask(self) -> Optional[pulumi.Input[str]]:
        """
        A template to parse platform-specific fields from a request URL. URL mask allows for routing to multiple resources
        on the same serverless platform without having to create multiple Network Endpoint Groups and backend resources.
        The fields parsed by this template are platform-specific and are as follows: API Gateway: The gateway ID,
        App Engine: The service and version, Cloud Functions: The function name, Cloud Run: The service and tag
        """
        return pulumi.get(self, "url_mask")

    @url_mask.setter
    def url_mask(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "url_mask", value)

    @property
    @pulumi.getter
    def version(self) -> Optional[pulumi.Input[str]]:
        """
        The optional resource version. The version identified by this value is platform-specific and is follows:
        API Gateway: Unused, App Engine: The service version, Cloud Functions: Unused, Cloud Run: The service tag
        """
        return pulumi.get(self, "version")

    @version.setter
    def version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "version", value)


@pulumi.input_type
class RegionPerInstanceConfigPreservedStateArgs:
    def __init__(__self__, *,
                 disks: Optional[pulumi.Input[Sequence[pulumi.Input['RegionPerInstanceConfigPreservedStateDiskArgs']]]] = None,
                 metadata: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['RegionPerInstanceConfigPreservedStateDiskArgs']]] disks: Stateful disks for the instance.
               Structure is documented below.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] metadata: Preserved metadata defined for this instance. This is a list of key->value pairs.
        """
        if disks is not None:
            pulumi.set(__self__, "disks", disks)
        if metadata is not None:
            pulumi.set(__self__, "metadata", metadata)

    @property
    @pulumi.getter
    def disks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionPerInstanceConfigPreservedStateDiskArgs']]]]:
        """
        Stateful disks for the instance.
        Structure is documented below.
        """
        return pulumi.get(self, "disks")

    @disks.setter
    def disks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionPerInstanceConfigPreservedStateDiskArgs']]]]):
        pulumi.set(self, "disks", value)

    @property
    @pulumi.getter
    def metadata(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        Preserved metadata defined for this instance. This is a list of key->value pairs.
        """
        return pulumi.get(self, "metadata")

    @metadata.setter
    def metadata(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "metadata", value)


@pulumi.input_type
class RegionPerInstanceConfigPreservedStateDiskArgs:
    def __init__(__self__, *,
                 device_name: pulumi.Input[str],
                 source: pulumi.Input[str],
                 delete_rule: Optional[pulumi.Input[str]] = None,
                 mode: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] device_name: A unique device name that is reflected into the /dev/ tree of a Linux operating system running within the instance.
        :param pulumi.Input[str] source: The URI of an existing persistent disk to attach under the specified device-name in the format
               `projects/project-id/zones/zone/disks/disk-name`.
        :param pulumi.Input[str] delete_rule: A value that prescribes what should happen to the stateful disk when the VM instance is deleted.
               The available options are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`.
               `NEVER` - detach the disk when the VM is deleted, but do not delete the disk.
               `ON_PERMANENT_INSTANCE_DELETION` will delete the stateful disk when the VM is permanently
               deleted from the instance group.
               Default value is `NEVER`.
               Possible values are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`.
        :param pulumi.Input[str] mode: The mode of the disk.
               Default value is `READ_WRITE`.
               Possible values are `READ_ONLY` and `READ_WRITE`.
        """
        pulumi.set(__self__, "device_name", device_name)
        pulumi.set(__self__, "source", source)
        if delete_rule is not None:
            pulumi.set(__self__, "delete_rule", delete_rule)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> pulumi.Input[str]:
        """
        A unique device name that is reflected into the /dev/ tree of a Linux operating system running within the instance.
        """
        return pulumi.get(self, "device_name")

    @device_name.setter
    def device_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "device_name", value)

    @property
    @pulumi.getter
    def source(self) -> pulumi.Input[str]:
        """
        The URI of an existing persistent disk to attach under the specified device-name in the format
        `projects/project-id/zones/zone/disks/disk-name`.
        """
        return pulumi.get(self, "source")

    @source.setter
    def source(self, value: pulumi.Input[str]):
        pulumi.set(self, "source", value)

    @property
    @pulumi.getter(name="deleteRule")
    def delete_rule(self) -> Optional[pulumi.Input[str]]:
        """
        A value that prescribes what should happen to the stateful disk when the VM instance is deleted.
        The available options are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`.
        `NEVER` - detach the disk when the VM is deleted, but do not delete the disk.
        `ON_PERMANENT_INSTANCE_DELETION` will delete the stateful disk when the VM is permanently
        deleted from the instance group.
        Default value is `NEVER`.
        Possible values are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`.
        """
        return pulumi.get(self, "delete_rule")

    @delete_rule.setter
    def delete_rule(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "delete_rule", value)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[str]]:
        """
        The mode of the disk.
        Default value is `READ_WRITE`.
        Possible values are `READ_ONLY` and `READ_WRITE`.
        """
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mode", value)


@pulumi.input_type
class RegionUrlMapDefaultUrlRedirectArgs:
    def __init__(__self__, *,
                 strip_query: pulumi.Input[bool],
                 host_redirect: Optional[pulumi.Input[str]] = None,
                 https_redirect: Optional[pulumi.Input[bool]] = None,
                 path_redirect: Optional[pulumi.Input[str]] = None,
                 prefix_redirect: Optional[pulumi.Input[str]] = None,
                 redirect_response_code: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] strip_query: If set to true, any accompanying query portion of the original URL is removed prior
               to redirecting the request. If set to false, the query portion of the original URL is
               retained.
               This field is required to ensure an empty block is not set. The normal default value is false.
        :param pulumi.Input[str] host_redirect: The host that will be used in the redirect response instead of the one that was
               supplied in the request. The value must be between 1 and 255 characters.
        :param pulumi.Input[bool] https_redirect: If set to true, the URL scheme in the redirected request is set to https. If set to
               false, the URL scheme of the redirected request will remain the same as that of the
               request. This must only be set for UrlMaps used in TargetHttpProxys. Setting this
               true for TargetHttpsProxy is not permitted. The default is set to false.
        :param pulumi.Input[str] path_redirect: The path that will be used in the redirect response instead of the one that was
               supplied in the request. pathRedirect cannot be supplied together with
               prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the
               original request will be used for the redirect. The value must be between 1 and 1024
               characters.
        :param pulumi.Input[str] prefix_redirect: The prefix that replaces the prefixMatch specified in the HttpRouteRuleMatch,
               retaining the remaining portion of the URL before redirecting the request.
               prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or
               neither. If neither is supplied, the path of the original request will be used for
               the redirect. The value must be between 1 and 1024 characters.
        :param pulumi.Input[str] redirect_response_code: The HTTP Status code to use for this RedirectAction. Supported values are:
               * MOVED_PERMANENTLY_DEFAULT, which is the default value and corresponds to 301.
               * FOUND, which corresponds to 302.
               * SEE_OTHER which corresponds to 303.
               * TEMPORARY_REDIRECT, which corresponds to 307. In this case, the request method
               will be retained.
               * PERMANENT_REDIRECT, which corresponds to 308. In this case,
               the request method will be retained.
        """
        pulumi.set(__self__, "strip_query", strip_query)
        if host_redirect is not None:
            pulumi.set(__self__, "host_redirect", host_redirect)
        if https_redirect is not None:
            pulumi.set(__self__, "https_redirect", https_redirect)
        if path_redirect is not None:
            pulumi.set(__self__, "path_redirect", path_redirect)
        if prefix_redirect is not None:
            pulumi.set(__self__, "prefix_redirect", prefix_redirect)
        if redirect_response_code is not None:
            pulumi.set(__self__, "redirect_response_code", redirect_response_code)

    @property
    @pulumi.getter(name="stripQuery")
    def strip_query(self) -> pulumi.Input[bool]:
        """
        If set to true, any accompanying query portion of the original URL is removed prior
        to redirecting the request. If set to false, the query portion of the original URL is
        retained.
        This field is required to ensure an empty block is not set. The normal default value is false.
        """
        return pulumi.get(self, "strip_query")

    @strip_query.setter
    def strip_query(self, value: pulumi.Input[bool]):
        pulumi.set(self, "strip_query", value)

    @property
    @pulumi.getter(name="hostRedirect")
    def host_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The host that will be used in the redirect response instead of the one that was
        supplied in the request. The value must be between 1 and 255 characters.
        """
        return pulumi.get(self, "host_redirect")

    @host_redirect.setter
    def host_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_redirect", value)

    @property
    @pulumi.getter(name="httpsRedirect")
    def https_redirect(self) -> Optional[pulumi.Input[bool]]:
        """
        If set to true, the URL scheme in the redirected request is set to https. If set to
        false, the URL scheme of the redirected request will remain the same as that of the
        request. This must only be set for UrlMaps used in TargetHttpProxys. Setting this
        true for TargetHttpsProxy is not permitted. The default is set to false.
        """
        return pulumi.get(self, "https_redirect")

    @https_redirect.setter
    def https_redirect(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "https_redirect", value)

    @property
    @pulumi.getter(name="pathRedirect")
    def path_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The path that will be used in the redirect response instead of the one that was
        supplied in the request. pathRedirect cannot be supplied together with
        prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the
        original request will be used for the redirect. The value must be between 1 and 1024
        characters.
        """
        return pulumi.get(self, "path_redirect")

    @path_redirect.setter
    def path_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path_redirect", value)

    @property
    @pulumi.getter(name="prefixRedirect")
    def prefix_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The prefix that replaces the prefixMatch specified in the HttpRouteRuleMatch,
        retaining the remaining portion of the URL before redirecting the request.
        prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or
        neither. If neither is supplied, the path of the original request will be used for
        the redirect. The value must be between 1 and 1024 characters.
        """
        return pulumi.get(self, "prefix_redirect")

    @prefix_redirect.setter
    def prefix_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "prefix_redirect", value)

    @property
    @pulumi.getter(name="redirectResponseCode")
    def redirect_response_code(self) -> Optional[pulumi.Input[str]]:
        """
        The HTTP Status code to use for this RedirectAction. Supported values are:
        * MOVED_PERMANENTLY_DEFAULT, which is the default value and corresponds to 301.
        * FOUND, which corresponds to 302.
        * SEE_OTHER which corresponds to 303.
        * TEMPORARY_REDIRECT, which corresponds to 307. In this case, the request method
        will be retained.
        * PERMANENT_REDIRECT, which corresponds to 308. In this case,
        the request method will be retained.
        """
        return pulumi.get(self, "redirect_response_code")

    @redirect_response_code.setter
    def redirect_response_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "redirect_response_code", value)


@pulumi.input_type
class RegionUrlMapHostRuleArgs:
    def __init__(__self__, *,
                 hosts: pulumi.Input[Sequence[pulumi.Input[str]]],
                 path_matcher: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] hosts: The list of host patterns to match. They must be valid
               hostnames, except * will match any string of ([a-z0-9-.]*). In
               that case, * must be the first character and must be followed in
               the pattern by either - or ..
        :param pulumi.Input[str] path_matcher: The name of the PathMatcher to use to match the path portion of
               the URL if the hostRule matches the URL's host portion.
        :param pulumi.Input[str] description: Description of this test case.
        """
        pulumi.set(__self__, "hosts", hosts)
        pulumi.set(__self__, "path_matcher", path_matcher)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def hosts(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        The list of host patterns to match. They must be valid
        hostnames, except * will match any string of ([a-z0-9-.]*). In
        that case, * must be the first character and must be followed in
        the pattern by either - or ..
        """
        return pulumi.get(self, "hosts")

    @hosts.setter
    def hosts(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "hosts", value)

    @property
    @pulumi.getter(name="pathMatcher")
    def path_matcher(self) -> pulumi.Input[str]:
        """
        The name of the PathMatcher to use to match the path portion of
        the URL if the hostRule matches the URL's host portion.
        """
        return pulumi.get(self, "path_matcher")

    @path_matcher.setter
    def path_matcher(self, value: pulumi.Input[str]):
        pulumi.set(self, "path_matcher", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        Description of this test case.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class RegionUrlMapPathMatcherArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 default_service: Optional[pulumi.Input[str]] = None,
                 default_url_redirect: Optional[pulumi.Input['RegionUrlMapPathMatcherDefaultUrlRedirectArgs']] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 path_rules: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherPathRuleArgs']]]] = None,
                 route_rules: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleArgs']]]] = None):
        """
        :param pulumi.Input[str] name: The name of the query parameter to match. The query parameter must exist in the
               request, in the absence of which the request match fails.
        :param pulumi.Input[str] default_service: A reference to a RegionBackendService resource. This will be used if
               none of the pathRules defined by this PathMatcher is matched by
               the URL's path portion.
        :param pulumi.Input['RegionUrlMapPathMatcherDefaultUrlRedirectArgs'] default_url_redirect: When none of the specified hostRules match, the request is redirected to a URL specified
               by defaultUrlRedirect. If defaultUrlRedirect is specified, defaultService or
               defaultRouteAction must not be set.
               Structure is documented below.
        :param pulumi.Input[str] description: Description of this test case.
        :param pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherPathRuleArgs']]] path_rules: The list of path rules. Use this list instead of routeRules when routing based
               on simple path matching is all that's required. The order by which path rules
               are specified does not matter. Matches are always done on the longest-path-first
               basis. For example: a pathRule with a path /a/b/c/* will match before /a/b/*
               irrespective of the order in which those paths appear in this list. Within a
               given pathMatcher, only one of pathRules or routeRules must be set.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleArgs']]] route_rules: The list of ordered HTTP route rules. Use this list instead of pathRules when
               advanced route matching and routing actions are desired. The order of specifying
               routeRules matters: the first rule that matches will cause its specified routing
               action to take effect. Within a given pathMatcher, only one of pathRules or
               routeRules must be set. routeRules are not supported in UrlMaps intended for
               External load balancers.
               Structure is documented below.
        """
        pulumi.set(__self__, "name", name)
        if default_service is not None:
            pulumi.set(__self__, "default_service", default_service)
        if default_url_redirect is not None:
            pulumi.set(__self__, "default_url_redirect", default_url_redirect)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if path_rules is not None:
            pulumi.set(__self__, "path_rules", path_rules)
        if route_rules is not None:
            pulumi.set(__self__, "route_rules", route_rules)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the query parameter to match. The query parameter must exist in the
        request, in the absence of which the request match fails.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="defaultService")
    def default_service(self) -> Optional[pulumi.Input[str]]:
        """
        A reference to a RegionBackendService resource. This will be used if
        none of the pathRules defined by this PathMatcher is matched by
        the URL's path portion.
        """
        return pulumi.get(self, "default_service")

    @default_service.setter
    def default_service(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "default_service", value)

    @property
    @pulumi.getter(name="defaultUrlRedirect")
    def default_url_redirect(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherDefaultUrlRedirectArgs']]:
        """
        When none of the specified hostRules match, the request is redirected to a URL specified
        by defaultUrlRedirect. If defaultUrlRedirect is specified, defaultService or
        defaultRouteAction must not be set.
        Structure is documented below.
        """
        return pulumi.get(self, "default_url_redirect")

    @default_url_redirect.setter
    def default_url_redirect(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherDefaultUrlRedirectArgs']]):
        pulumi.set(self, "default_url_redirect", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        Description of this test case.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)

    @property
    @pulumi.getter(name="pathRules")
    def path_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherPathRuleArgs']]]]:
        """
        The list of path rules. Use this list instead of routeRules when routing based
        on simple path matching is all that's required. The order by which path rules
        are specified does not matter. Matches are always done on the longest-path-first
        basis. For example: a pathRule with a path /a/b/c/* will match before /a/b/*
        irrespective of the order in which those paths appear in this list. Within a
        given pathMatcher, only one of pathRules or routeRules must be set.
        Structure is documented below.
        """
        return pulumi.get(self, "path_rules")

    @path_rules.setter
    def path_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherPathRuleArgs']]]]):
        pulumi.set(self, "path_rules", value)

    @property
    @pulumi.getter(name="routeRules")
    def route_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleArgs']]]]:
        """
        The list of ordered HTTP route rules. Use this list instead of pathRules when
        advanced route matching and routing actions are desired. The order of specifying
        routeRules matters: the first rule that matches will cause its specified routing
        action to take effect. Within a given pathMatcher, only one of pathRules or
        routeRules must be set. routeRules are not supported in UrlMaps intended for
        External load balancers.
        Structure is documented below.
        """
        return pulumi.get(self, "route_rules")

    @route_rules.setter
    def route_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleArgs']]]]):
        pulumi.set(self, "route_rules", value)


@pulumi.input_type
class RegionUrlMapPathMatcherDefaultUrlRedirectArgs:
    def __init__(__self__, *,
                 strip_query: pulumi.Input[bool],
                 host_redirect: Optional[pulumi.Input[str]] = None,
                 https_redirect: Optional[pulumi.Input[bool]] = None,
                 path_redirect: Optional[pulumi.Input[str]] = None,
                 prefix_redirect: Optional[pulumi.Input[str]] = None,
                 redirect_response_code: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] strip_query: If set to true, any accompanying query portion of the original URL is removed prior
               to redirecting the request. If set to false, the query portion of the original URL is
               retained.
               This field is required to ensure an empty block is not set. The normal default value is false.
        :param pulumi.Input[str] host_redirect: The host that will be used in the redirect response instead of the one that was
               supplied in the request. The value must be between 1 and 255 characters.
        :param pulumi.Input[bool] https_redirect: If set to true, the URL scheme in the redirected request is set to https. If set to
               false, the URL scheme of the redirected request will remain the same as that of the
               request. This must only be set for UrlMaps used in TargetHttpProxys. Setting this
               true for TargetHttpsProxy is not permitted. The default is set to false.
        :param pulumi.Input[str] path_redirect: The path that will be used in the redirect response instead of the one that was
               supplied in the request. pathRedirect cannot be supplied together with
               prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the
               original request will be used for the redirect. The value must be between 1 and 1024
               characters.
        :param pulumi.Input[str] prefix_redirect: The prefix that replaces the prefixMatch specified in the HttpRouteRuleMatch,
               retaining the remaining portion of the URL before redirecting the request.
               prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or
               neither. If neither is supplied, the path of the original request will be used for
               the redirect. The value must be between 1 and 1024 characters.
        :param pulumi.Input[str] redirect_response_code: The HTTP Status code to use for this RedirectAction. Supported values are:
               * MOVED_PERMANENTLY_DEFAULT, which is the default value and corresponds to 301.
               * FOUND, which corresponds to 302.
               * SEE_OTHER which corresponds to 303.
               * TEMPORARY_REDIRECT, which corresponds to 307. In this case, the request method
               will be retained.
               * PERMANENT_REDIRECT, which corresponds to 308. In this case,
               the request method will be retained.
        """
        pulumi.set(__self__, "strip_query", strip_query)
        if host_redirect is not None:
            pulumi.set(__self__, "host_redirect", host_redirect)
        if https_redirect is not None:
            pulumi.set(__self__, "https_redirect", https_redirect)
        if path_redirect is not None:
            pulumi.set(__self__, "path_redirect", path_redirect)
        if prefix_redirect is not None:
            pulumi.set(__self__, "prefix_redirect", prefix_redirect)
        if redirect_response_code is not None:
            pulumi.set(__self__, "redirect_response_code", redirect_response_code)

    @property
    @pulumi.getter(name="stripQuery")
    def strip_query(self) -> pulumi.Input[bool]:
        """
        If set to true, any accompanying query portion of the original URL is removed prior
        to redirecting the request. If set to false, the query portion of the original URL is
        retained.
        This field is required to ensure an empty block is not set. The normal default value is false.
        """
        return pulumi.get(self, "strip_query")

    @strip_query.setter
    def strip_query(self, value: pulumi.Input[bool]):
        pulumi.set(self, "strip_query", value)

    @property
    @pulumi.getter(name="hostRedirect")
    def host_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The host that will be used in the redirect response instead of the one that was
        supplied in the request. The value must be between 1 and 255 characters.
        """
        return pulumi.get(self, "host_redirect")

    @host_redirect.setter
    def host_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_redirect", value)

    @property
    @pulumi.getter(name="httpsRedirect")
    def https_redirect(self) -> Optional[pulumi.Input[bool]]:
        """
        If set to true, the URL scheme in the redirected request is set to https. If set to
        false, the URL scheme of the redirected request will remain the same as that of the
        request. This must only be set for UrlMaps used in TargetHttpProxys. Setting this
        true for TargetHttpsProxy is not permitted. The default is set to false.
        """
        return pulumi.get(self, "https_redirect")

    @https_redirect.setter
    def https_redirect(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "https_redirect", value)

    @property
    @pulumi.getter(name="pathRedirect")
    def path_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The path that will be used in the redirect response instead of the one that was
        supplied in the request. pathRedirect cannot be supplied together with
        prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the
        original request will be used for the redirect. The value must be between 1 and 1024
        characters.
        """
        return pulumi.get(self, "path_redirect")

    @path_redirect.setter
    def path_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path_redirect", value)

    @property
    @pulumi.getter(name="prefixRedirect")
    def prefix_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The prefix that replaces the prefixMatch specified in the HttpRouteRuleMatch,
        retaining the remaining portion of the URL before redirecting the request.
        prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or
        neither. If neither is supplied, the path of the original request will be used for
        the redirect. The value must be between 1 and 1024 characters.
        """
        return pulumi.get(self, "prefix_redirect")

    @prefix_redirect.setter
    def prefix_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "prefix_redirect", value)

    @property
    @pulumi.getter(name="redirectResponseCode")
    def redirect_response_code(self) -> Optional[pulumi.Input[str]]:
        """
        The HTTP Status code to use for this RedirectAction. Supported values are:
        * MOVED_PERMANENTLY_DEFAULT, which is the default value and corresponds to 301.
        * FOUND, which corresponds to 302.
        * SEE_OTHER which corresponds to 303.
        * TEMPORARY_REDIRECT, which corresponds to 307. In this case, the request method
        will be retained.
        * PERMANENT_REDIRECT, which corresponds to 308. In this case,
        the request method will be retained.
        """
        return pulumi.get(self, "redirect_response_code")

    @redirect_response_code.setter
    def redirect_response_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "redirect_response_code", value)


@pulumi.input_type
class RegionUrlMapPathMatcherPathRuleArgs:
    def __init__(__self__, *,
                 paths: pulumi.Input[Sequence[pulumi.Input[str]]],
                 route_action: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionArgs']] = None,
                 service: Optional[pulumi.Input[str]] = None,
                 url_redirect: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleUrlRedirectArgs']] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] paths: The list of path patterns to match. Each must start with / and the only place a
               \\* is allowed is at the end following a /. The string fed to the path matcher
               does not include any text after the first ? or #, and those chars are not
               allowed here.
        :param pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionArgs'] route_action: In response to a matching path, the load balancer performs advanced routing
               actions like URL rewrites, header transformations, etc. prior to forwarding the
               request to the selected backend. If routeAction specifies any
               weightedBackendServices, service must not be set. Conversely if service is set,
               routeAction cannot contain any  weightedBackendServices. Only one of routeAction
               or urlRedirect must be set.
               Structure is documented below.
        :param pulumi.Input[str] service: A reference to expected RegionBackendService resource the given URL should be mapped to.
        :param pulumi.Input['RegionUrlMapPathMatcherPathRuleUrlRedirectArgs'] url_redirect: When a path pattern is matched, the request is redirected to a URL specified
               by urlRedirect. If urlRedirect is specified, service or routeAction must not
               be set.
               Structure is documented below.
        """
        pulumi.set(__self__, "paths", paths)
        if route_action is not None:
            pulumi.set(__self__, "route_action", route_action)
        if service is not None:
            pulumi.set(__self__, "service", service)
        if url_redirect is not None:
            pulumi.set(__self__, "url_redirect", url_redirect)

    @property
    @pulumi.getter
    def paths(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        The list of path patterns to match. Each must start with / and the only place a
        \\* is allowed is at the end following a /. The string fed to the path matcher
        does not include any text after the first ? or #, and those chars are not
        allowed here.
        """
        return pulumi.get(self, "paths")

    @paths.setter
    def paths(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "paths", value)

    @property
    @pulumi.getter(name="routeAction")
    def route_action(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionArgs']]:
        """
        In response to a matching path, the load balancer performs advanced routing
        actions like URL rewrites, header transformations, etc. prior to forwarding the
        request to the selected backend. If routeAction specifies any
        weightedBackendServices, service must not be set. Conversely if service is set,
        routeAction cannot contain any  weightedBackendServices. Only one of routeAction
        or urlRedirect must be set.
        Structure is documented below.
        """
        return pulumi.get(self, "route_action")

    @route_action.setter
    def route_action(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionArgs']]):
        pulumi.set(self, "route_action", value)

    @property
    @pulumi.getter
    def service(self) -> Optional[pulumi.Input[str]]:
        """
        A reference to expected RegionBackendService resource the given URL should be mapped to.
        """
        return pulumi.get(self, "service")

    @service.setter
    def service(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service", value)

    @property
    @pulumi.getter(name="urlRedirect")
    def url_redirect(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleUrlRedirectArgs']]:
        """
        When a path pattern is matched, the request is redirected to a URL specified
        by urlRedirect. If urlRedirect is specified, service or routeAction must not
        be set.
        Structure is documented below.
        """
        return pulumi.get(self, "url_redirect")

    @url_redirect.setter
    def url_redirect(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleUrlRedirectArgs']]):
        pulumi.set(self, "url_redirect", value)


@pulumi.input_type
class RegionUrlMapPathMatcherPathRuleRouteActionArgs:
    def __init__(__self__, *,
                 cors_policy: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionCorsPolicyArgs']] = None,
                 fault_injection_policy: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs']] = None,
                 request_mirror_policy: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs']] = None,
                 retry_policy: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyArgs']] = None,
                 timeout: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionTimeoutArgs']] = None,
                 url_rewrite: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionUrlRewriteArgs']] = None,
                 weighted_backend_services: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs']]]] = None):
        """
        :param pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionCorsPolicyArgs'] cors_policy: The specification for allowing client side cross-origin requests. Please see W3C
               Recommendation for Cross Origin Resource Sharing
               Structure is documented below.
        :param pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs'] fault_injection_policy: The specification for fault injection introduced into traffic to test the
               resiliency of clients to backend service failure. As part of fault injection,
               when clients send requests to a backend service, delays can be introduced by
               Loadbalancer on a percentage of requests before sending those request to the
               backend service. Similarly requests from clients can be aborted by the
               Loadbalancer for a percentage of requests. timeout and retry_policy will be
               ignored by clients that are configured with a fault_injection_policy.
               Structure is documented below.
        :param pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs'] request_mirror_policy: Specifies the policy on how requests intended for the route's backends are
               shadowed to a separate mirrored backend service. Loadbalancer does not wait for
               responses from the shadow service. Prior to sending traffic to the shadow
               service, the host / authority header is suffixed with -shadow.
               Structure is documented below.
        :param pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyArgs'] retry_policy: Specifies the retry policy associated with this route.
               Structure is documented below.
        :param pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionTimeoutArgs'] timeout: Specifies the timeout for the selected route. Timeout is computed from the time
               the request is has been fully processed (i.e. end-of-stream) up until the
               response has been completely processed. Timeout includes all retries. If not
               specified, the default value is 15 seconds.
               Structure is documented below.
        :param pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionUrlRewriteArgs'] url_rewrite: The spec to modify the URL of the request, prior to forwarding the request to
               the matched service
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs']]] weighted_backend_services: A list of weighted backend services to send traffic to when a route match
               occurs. The weights determine the fraction of traffic that flows to their
               corresponding backend service. If all traffic needs to go to a single backend
               service, there must be one  weightedBackendService with weight set to a non 0
               number. Once a backendService is identified and before forwarding the request to
               the backend service, advanced routing actions like Url rewrites and header
               transformations are applied depending on additional settings specified in this
               HttpRouteAction.
               Structure is documented below.
        """
        if cors_policy is not None:
            pulumi.set(__self__, "cors_policy", cors_policy)
        if fault_injection_policy is not None:
            pulumi.set(__self__, "fault_injection_policy", fault_injection_policy)
        if request_mirror_policy is not None:
            pulumi.set(__self__, "request_mirror_policy", request_mirror_policy)
        if retry_policy is not None:
            pulumi.set(__self__, "retry_policy", retry_policy)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)
        if url_rewrite is not None:
            pulumi.set(__self__, "url_rewrite", url_rewrite)
        if weighted_backend_services is not None:
            pulumi.set(__self__, "weighted_backend_services", weighted_backend_services)

    @property
    @pulumi.getter(name="corsPolicy")
    def cors_policy(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionCorsPolicyArgs']]:
        """
        The specification for allowing client side cross-origin requests. Please see W3C
        Recommendation for Cross Origin Resource Sharing
        Structure is documented below.
        """
        return pulumi.get(self, "cors_policy")

    @cors_policy.setter
    def cors_policy(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionCorsPolicyArgs']]):
        pulumi.set(self, "cors_policy", value)

    @property
    @pulumi.getter(name="faultInjectionPolicy")
    def fault_injection_policy(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs']]:
        """
        The specification for fault injection introduced into traffic to test the
        resiliency of clients to backend service failure. As part of fault injection,
        when clients send requests to a backend service, delays can be introduced by
        Loadbalancer on a percentage of requests before sending those request to the
        backend service. Similarly requests from clients can be aborted by the
        Loadbalancer for a percentage of requests. timeout and retry_policy will be
        ignored by clients that are configured with a fault_injection_policy.
        Structure is documented below.
        """
        return pulumi.get(self, "fault_injection_policy")

    @fault_injection_policy.setter
    def fault_injection_policy(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs']]):
        pulumi.set(self, "fault_injection_policy", value)

    @property
    @pulumi.getter(name="requestMirrorPolicy")
    def request_mirror_policy(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs']]:
        """
        Specifies the policy on how requests intended for the route's backends are
        shadowed to a separate mirrored backend service. Loadbalancer does not wait for
        responses from the shadow service. Prior to sending traffic to the shadow
        service, the host / authority header is suffixed with -shadow.
        Structure is documented below.
        """
        return pulumi.get(self, "request_mirror_policy")

    @request_mirror_policy.setter
    def request_mirror_policy(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs']]):
        pulumi.set(self, "request_mirror_policy", value)

    @property
    @pulumi.getter(name="retryPolicy")
    def retry_policy(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyArgs']]:
        """
        Specifies the retry policy associated with this route.
        Structure is documented below.
        """
        return pulumi.get(self, "retry_policy")

    @retry_policy.setter
    def retry_policy(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyArgs']]):
        pulumi.set(self, "retry_policy", value)

    @property
    @pulumi.getter
    def timeout(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionTimeoutArgs']]:
        """
        Specifies the timeout for the selected route. Timeout is computed from the time
        the request is has been fully processed (i.e. end-of-stream) up until the
        response has been completely processed. Timeout includes all retries. If not
        specified, the default value is 15 seconds.
        Structure is documented below.
        """
        return pulumi.get(self, "timeout")

    @timeout.setter
    def timeout(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionTimeoutArgs']]):
        pulumi.set(self, "timeout", value)

    @property
    @pulumi.getter(name="urlRewrite")
    def url_rewrite(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionUrlRewriteArgs']]:
        """
        The spec to modify the URL of the request, prior to forwarding the request to
        the matched service
        Structure is documented below.
        """
        return pulumi.get(self, "url_rewrite")

    @url_rewrite.setter
    def url_rewrite(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionUrlRewriteArgs']]):
        pulumi.set(self, "url_rewrite", value)

    @property
    @pulumi.getter(name="weightedBackendServices")
    def weighted_backend_services(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs']]]]:
        """
        A list of weighted backend services to send traffic to when a route match
        occurs. The weights determine the fraction of traffic that flows to their
        corresponding backend service. If all traffic needs to go to a single backend
        service, there must be one  weightedBackendService with weight set to a non 0
        number. Once a backendService is identified and before forwarding the request to
        the backend service, advanced routing actions like Url rewrites and header
        transformations are applied depending on additional settings specified in this
        HttpRouteAction.
        Structure is documented below.
        """
        return pulumi.get(self, "weighted_backend_services")

    @weighted_backend_services.setter
    def weighted_backend_services(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs']]]]):
        pulumi.set(self, "weighted_backend_services", value)


@pulumi.input_type
class RegionUrlMapPathMatcherPathRuleRouteActionCorsPolicyArgs:
    def __init__(__self__, *,
                 disabled: pulumi.Input[bool],
                 allow_credentials: Optional[pulumi.Input[bool]] = None,
                 allow_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_methods: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_origin_regexes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_origins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 expose_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 max_age: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[bool] disabled: If true, specifies the CORS policy is disabled.
        :param pulumi.Input[bool] allow_credentials: In response to a preflight request, setting this to true indicates that the
               actual request can include user credentials. This translates to the Access-
               Control-Allow-Credentials header. Defaults to false.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_headers: Specifies the content for the Access-Control-Allow-Headers header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_methods: Specifies the content for the Access-Control-Allow-Methods header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_origin_regexes: Specifies the regular expression patterns that match allowed origins. For
               regular expression grammar please see en.cppreference.com/w/cpp/regex/ecmascript
               An origin is allowed if it matches either allow_origins or allow_origin_regex.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_origins: Specifies the list of origins that will be allowed to do CORS requests. An
               origin is allowed if it matches either allow_origins or allow_origin_regex.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] expose_headers: Specifies the content for the Access-Control-Expose-Headers header.
        :param pulumi.Input[int] max_age: Specifies how long the results of a preflight request can be cached. This
               translates to the content for the Access-Control-Max-Age header.
        """
        pulumi.set(__self__, "disabled", disabled)
        if allow_credentials is not None:
            pulumi.set(__self__, "allow_credentials", allow_credentials)
        if allow_headers is not None:
            pulumi.set(__self__, "allow_headers", allow_headers)
        if allow_methods is not None:
            pulumi.set(__self__, "allow_methods", allow_methods)
        if allow_origin_regexes is not None:
            pulumi.set(__self__, "allow_origin_regexes", allow_origin_regexes)
        if allow_origins is not None:
            pulumi.set(__self__, "allow_origins", allow_origins)
        if expose_headers is not None:
            pulumi.set(__self__, "expose_headers", expose_headers)
        if max_age is not None:
            pulumi.set(__self__, "max_age", max_age)

    @property
    @pulumi.getter
    def disabled(self) -> pulumi.Input[bool]:
        """
        If true, specifies the CORS policy is disabled.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: pulumi.Input[bool]):
        pulumi.set(self, "disabled", value)

    @property
    @pulumi.getter(name="allowCredentials")
    def allow_credentials(self) -> Optional[pulumi.Input[bool]]:
        """
        In response to a preflight request, setting this to true indicates that the
        actual request can include user credentials. This translates to the Access-
        Control-Allow-Credentials header. Defaults to false.
        """
        return pulumi.get(self, "allow_credentials")

    @allow_credentials.setter
    def allow_credentials(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_credentials", value)

    @property
    @pulumi.getter(name="allowHeaders")
    def allow_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for the Access-Control-Allow-Headers header.
        """
        return pulumi.get(self, "allow_headers")

    @allow_headers.setter
    def allow_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_headers", value)

    @property
    @pulumi.getter(name="allowMethods")
    def allow_methods(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for the Access-Control-Allow-Methods header.
        """
        return pulumi.get(self, "allow_methods")

    @allow_methods.setter
    def allow_methods(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_methods", value)

    @property
    @pulumi.getter(name="allowOriginRegexes")
    def allow_origin_regexes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the regular expression patterns that match allowed origins. For
        regular expression grammar please see en.cppreference.com/w/cpp/regex/ecmascript
        An origin is allowed if it matches either allow_origins or allow_origin_regex.
        """
        return pulumi.get(self, "allow_origin_regexes")

    @allow_origin_regexes.setter
    def allow_origin_regexes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_origin_regexes", value)

    @property
    @pulumi.getter(name="allowOrigins")
    def allow_origins(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the list of origins that will be allowed to do CORS requests. An
        origin is allowed if it matches either allow_origins or allow_origin_regex.
        """
        return pulumi.get(self, "allow_origins")

    @allow_origins.setter
    def allow_origins(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_origins", value)

    @property
    @pulumi.getter(name="exposeHeaders")
    def expose_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for the Access-Control-Expose-Headers header.
        """
        return pulumi.get(self, "expose_headers")

    @expose_headers.setter
    def expose_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "expose_headers", value)

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies how long the results of a preflight request can be cached. This
        translates to the content for the Access-Control-Max-Age header.
        """
        return pulumi.get(self, "max_age")

    @max_age.setter
    def max_age(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_age", value)


@pulumi.input_type
class RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs:
    def __init__(__self__, *,
                 abort: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs']] = None,
                 delay: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs']] = None):
        """
        :param pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs'] abort: The specification for how client requests are aborted as part of fault
               injection.
               Structure is documented below.
        :param pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs'] delay: The specification for how client requests are delayed as part of fault
               injection, before being sent to a backend service.
               Structure is documented below.
        """
        if abort is not None:
            pulumi.set(__self__, "abort", abort)
        if delay is not None:
            pulumi.set(__self__, "delay", delay)

    @property
    @pulumi.getter
    def abort(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs']]:
        """
        The specification for how client requests are aborted as part of fault
        injection.
        Structure is documented below.
        """
        return pulumi.get(self, "abort")

    @abort.setter
    def abort(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs']]):
        pulumi.set(self, "abort", value)

    @property
    @pulumi.getter
    def delay(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs']]:
        """
        The specification for how client requests are delayed as part of fault
        injection, before being sent to a backend service.
        Structure is documented below.
        """
        return pulumi.get(self, "delay")

    @delay.setter
    def delay(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs']]):
        pulumi.set(self, "delay", value)


@pulumi.input_type
class RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs:
    def __init__(__self__, *,
                 http_status: pulumi.Input[int],
                 percentage: pulumi.Input[float]):
        """
        :param pulumi.Input[int] http_status: The HTTP status code used to abort the request. The value must be between 200
               and 599 inclusive.
        :param pulumi.Input[float] percentage: The percentage of traffic (connections/operations/requests) on which delay will
               be introduced as part of fault injection. The value must be between 0.0 and
               100.0 inclusive.
        """
        pulumi.set(__self__, "http_status", http_status)
        pulumi.set(__self__, "percentage", percentage)

    @property
    @pulumi.getter(name="httpStatus")
    def http_status(self) -> pulumi.Input[int]:
        """
        The HTTP status code used to abort the request. The value must be between 200
        and 599 inclusive.
        """
        return pulumi.get(self, "http_status")

    @http_status.setter
    def http_status(self, value: pulumi.Input[int]):
        pulumi.set(self, "http_status", value)

    @property
    @pulumi.getter
    def percentage(self) -> pulumi.Input[float]:
        """
        The percentage of traffic (connections/operations/requests) on which delay will
        be introduced as part of fault injection. The value must be between 0.0 and
        100.0 inclusive.
        """
        return pulumi.get(self, "percentage")

    @percentage.setter
    def percentage(self, value: pulumi.Input[float]):
        pulumi.set(self, "percentage", value)


@pulumi.input_type
class RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs:
    def __init__(__self__, *,
                 fixed_delay: pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs'],
                 percentage: pulumi.Input[float]):
        """
        :param pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs'] fixed_delay: Specifies the value of the fixed delay interval.
               Structure is documented below.
        :param pulumi.Input[float] percentage: The percentage of traffic (connections/operations/requests) on which delay will
               be introduced as part of fault injection. The value must be between 0.0 and
               100.0 inclusive.
        """
        pulumi.set(__self__, "fixed_delay", fixed_delay)
        pulumi.set(__self__, "percentage", percentage)

    @property
    @pulumi.getter(name="fixedDelay")
    def fixed_delay(self) -> pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs']:
        """
        Specifies the value of the fixed delay interval.
        Structure is documented below.
        """
        return pulumi.get(self, "fixed_delay")

    @fixed_delay.setter
    def fixed_delay(self, value: pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs']):
        pulumi.set(self, "fixed_delay", value)

    @property
    @pulumi.getter
    def percentage(self) -> pulumi.Input[float]:
        """
        The percentage of traffic (connections/operations/requests) on which delay will
        be introduced as part of fault injection. The value must be between 0.0 and
        100.0 inclusive.
        """
        return pulumi.get(self, "percentage")

    @percentage.setter
    def percentage(self, value: pulumi.Input[float]):
        pulumi.set(self, "percentage", value)


@pulumi.input_type
class RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs:
    def __init__(__self__, *,
                 seconds: pulumi.Input[str],
                 nanos: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
               inclusive.
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations
               less than one second are represented with a 0 `seconds` field and a positive
               `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        pulumi.set(__self__, "seconds", seconds)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)

    @property
    @pulumi.getter
    def seconds(self) -> pulumi.Input[str]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
        inclusive.
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: pulumi.Input[str]):
        pulumi.set(self, "seconds", value)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations
        less than one second are represented with a 0 `seconds` field and a positive
        `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)


@pulumi.input_type
class RegionUrlMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs:
    def __init__(__self__, *,
                 backend_service: pulumi.Input[str]):
        """
        :param pulumi.Input[str] backend_service: The default RegionBackendService resource. Before
               forwarding the request to backendService, the loadbalancer applies any relevant
               headerActions specified as part of this backendServiceWeight.
        """
        pulumi.set(__self__, "backend_service", backend_service)

    @property
    @pulumi.getter(name="backendService")
    def backend_service(self) -> pulumi.Input[str]:
        """
        The default RegionBackendService resource. Before
        forwarding the request to backendService, the loadbalancer applies any relevant
        headerActions specified as part of this backendServiceWeight.
        """
        return pulumi.get(self, "backend_service")

    @backend_service.setter
    def backend_service(self, value: pulumi.Input[str]):
        pulumi.set(self, "backend_service", value)


@pulumi.input_type
class RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyArgs:
    def __init__(__self__, *,
                 num_retries: Optional[pulumi.Input[int]] = None,
                 per_try_timeout: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs']] = None,
                 retry_conditions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[int] num_retries: Specifies the allowed number retries. This number must be > 0.
        :param pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs'] per_try_timeout: Specifies a non-zero timeout per retry attempt.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] retry_conditions: Specifies one or more conditions when this retry rule applies. Valid values are:
               - 5xx: Loadbalancer will attempt a retry if the backend service responds with
               any 5xx response code, or if the backend service does not respond at all,
               example: disconnects, reset, read timeout, connection failure, and refused
               streams.
               - gateway-error: Similar to 5xx, but only applies to response codes
               502, 503 or 504.
               - connect-failure: Loadbalancer will retry on failures
               connecting to backend services, for example due to connection timeouts.
               - retriable-4xx: Loadbalancer will retry for retriable 4xx response codes.
               Currently the only retriable error supported is 409.
               - refused-stream: Loadbalancer will retry if the backend service resets the stream with a
               REFUSED_STREAM error code. This reset type indicates that it is safe to retry.
               - cancelled: Loadbalancer will retry if the gRPC status code in the response
               header is set to cancelled
               - deadline-exceeded: Loadbalancer will retry if the
               gRPC status code in the response header is set to deadline-exceeded
               - resource-exhausted: Loadbalancer will retry if the gRPC status code in the response
               header is set to resource-exhausted
               - unavailable: Loadbalancer will retry if
               the gRPC status code in the response header is set to unavailable
        """
        if num_retries is not None:
            pulumi.set(__self__, "num_retries", num_retries)
        if per_try_timeout is not None:
            pulumi.set(__self__, "per_try_timeout", per_try_timeout)
        if retry_conditions is not None:
            pulumi.set(__self__, "retry_conditions", retry_conditions)

    @property
    @pulumi.getter(name="numRetries")
    def num_retries(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the allowed number retries. This number must be > 0.
        """
        return pulumi.get(self, "num_retries")

    @num_retries.setter
    def num_retries(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "num_retries", value)

    @property
    @pulumi.getter(name="perTryTimeout")
    def per_try_timeout(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs']]:
        """
        Specifies a non-zero timeout per retry attempt.
        Structure is documented below.
        """
        return pulumi.get(self, "per_try_timeout")

    @per_try_timeout.setter
    def per_try_timeout(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs']]):
        pulumi.set(self, "per_try_timeout", value)

    @property
    @pulumi.getter(name="retryConditions")
    def retry_conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies one or more conditions when this retry rule applies. Valid values are:
        - 5xx: Loadbalancer will attempt a retry if the backend service responds with
        any 5xx response code, or if the backend service does not respond at all,
        example: disconnects, reset, read timeout, connection failure, and refused
        streams.
        - gateway-error: Similar to 5xx, but only applies to response codes
        502, 503 or 504.
        - connect-failure: Loadbalancer will retry on failures
        connecting to backend services, for example due to connection timeouts.
        - retriable-4xx: Loadbalancer will retry for retriable 4xx response codes.
        Currently the only retriable error supported is 409.
        - refused-stream: Loadbalancer will retry if the backend service resets the stream with a
        REFUSED_STREAM error code. This reset type indicates that it is safe to retry.
        - cancelled: Loadbalancer will retry if the gRPC status code in the response
        header is set to cancelled
        - deadline-exceeded: Loadbalancer will retry if the
        gRPC status code in the response header is set to deadline-exceeded
        - resource-exhausted: Loadbalancer will retry if the gRPC status code in the response
        header is set to resource-exhausted
        - unavailable: Loadbalancer will retry if
        the gRPC status code in the response header is set to unavailable
        """
        return pulumi.get(self, "retry_conditions")

    @retry_conditions.setter
    def retry_conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "retry_conditions", value)


@pulumi.input_type
class RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs:
    def __init__(__self__, *,
                 seconds: pulumi.Input[str],
                 nanos: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
               inclusive.
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations
               less than one second are represented with a 0 `seconds` field and a positive
               `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        pulumi.set(__self__, "seconds", seconds)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)

    @property
    @pulumi.getter
    def seconds(self) -> pulumi.Input[str]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
        inclusive.
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: pulumi.Input[str]):
        pulumi.set(self, "seconds", value)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations
        less than one second are represented with a 0 `seconds` field and a positive
        `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)


@pulumi.input_type
class RegionUrlMapPathMatcherPathRuleRouteActionTimeoutArgs:
    def __init__(__self__, *,
                 seconds: pulumi.Input[str],
                 nanos: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
               inclusive.
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations
               less than one second are represented with a 0 `seconds` field and a positive
               `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        pulumi.set(__self__, "seconds", seconds)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)

    @property
    @pulumi.getter
    def seconds(self) -> pulumi.Input[str]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
        inclusive.
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: pulumi.Input[str]):
        pulumi.set(self, "seconds", value)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations
        less than one second are represented with a 0 `seconds` field and a positive
        `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)


@pulumi.input_type
class RegionUrlMapPathMatcherPathRuleRouteActionUrlRewriteArgs:
    def __init__(__self__, *,
                 host_rewrite: Optional[pulumi.Input[str]] = None,
                 path_prefix_rewrite: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host_rewrite: Prior to forwarding the request to the selected service, the request's host
               header is replaced with contents of hostRewrite. The value must be between 1 and
               255 characters.
        :param pulumi.Input[str] path_prefix_rewrite: Prior to forwarding the request to the selected backend service, the matching
               portion of the request's path is replaced by pathPrefixRewrite. The value must
               be between 1 and 1024 characters.
        """
        if host_rewrite is not None:
            pulumi.set(__self__, "host_rewrite", host_rewrite)
        if path_prefix_rewrite is not None:
            pulumi.set(__self__, "path_prefix_rewrite", path_prefix_rewrite)

    @property
    @pulumi.getter(name="hostRewrite")
    def host_rewrite(self) -> Optional[pulumi.Input[str]]:
        """
        Prior to forwarding the request to the selected service, the request's host
        header is replaced with contents of hostRewrite. The value must be between 1 and
        255 characters.
        """
        return pulumi.get(self, "host_rewrite")

    @host_rewrite.setter
    def host_rewrite(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_rewrite", value)

    @property
    @pulumi.getter(name="pathPrefixRewrite")
    def path_prefix_rewrite(self) -> Optional[pulumi.Input[str]]:
        """
        Prior to forwarding the request to the selected backend service, the matching
        portion of the request's path is replaced by pathPrefixRewrite. The value must
        be between 1 and 1024 characters.
        """
        return pulumi.get(self, "path_prefix_rewrite")

    @path_prefix_rewrite.setter
    def path_prefix_rewrite(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path_prefix_rewrite", value)


@pulumi.input_type
class RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs:
    def __init__(__self__, *,
                 backend_service: pulumi.Input[str],
                 weight: pulumi.Input[int],
                 header_action: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs']] = None):
        """
        :param pulumi.Input[str] backend_service: The default RegionBackendService resource. Before
               forwarding the request to backendService, the loadbalancer applies any relevant
               headerActions specified as part of this backendServiceWeight.
        :param pulumi.Input[int] weight: Specifies the fraction of traffic sent to backendService, computed as weight /
               (sum of all weightedBackendService weights in routeAction) . The selection of a
               backend service is determined only for new traffic. Once a user's request has
               been directed to a backendService, subsequent requests will be sent to the same
               backendService as determined by the BackendService's session affinity policy.
               The value must be between 0 and 1000
        :param pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs'] header_action: Specifies changes to request and response headers that need to take effect for
               the selected backendService. headerAction specified here take effect before
               headerAction in the enclosing HttpRouteRule, PathMatcher and UrlMap.
               Structure is documented below.
        """
        pulumi.set(__self__, "backend_service", backend_service)
        pulumi.set(__self__, "weight", weight)
        if header_action is not None:
            pulumi.set(__self__, "header_action", header_action)

    @property
    @pulumi.getter(name="backendService")
    def backend_service(self) -> pulumi.Input[str]:
        """
        The default RegionBackendService resource. Before
        forwarding the request to backendService, the loadbalancer applies any relevant
        headerActions specified as part of this backendServiceWeight.
        """
        return pulumi.get(self, "backend_service")

    @backend_service.setter
    def backend_service(self, value: pulumi.Input[str]):
        pulumi.set(self, "backend_service", value)

    @property
    @pulumi.getter
    def weight(self) -> pulumi.Input[int]:
        """
        Specifies the fraction of traffic sent to backendService, computed as weight /
        (sum of all weightedBackendService weights in routeAction) . The selection of a
        backend service is determined only for new traffic. Once a user's request has
        been directed to a backendService, subsequent requests will be sent to the same
        backendService as determined by the BackendService's session affinity policy.
        The value must be between 0 and 1000
        """
        return pulumi.get(self, "weight")

    @weight.setter
    def weight(self, value: pulumi.Input[int]):
        pulumi.set(self, "weight", value)

    @property
    @pulumi.getter(name="headerAction")
    def header_action(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs']]:
        """
        Specifies changes to request and response headers that need to take effect for
        the selected backendService. headerAction specified here take effect before
        headerAction in the enclosing HttpRouteRule, PathMatcher and UrlMap.
        Structure is documented below.
        """
        return pulumi.get(self, "header_action")

    @header_action.setter
    def header_action(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs']]):
        pulumi.set(self, "header_action", value)


@pulumi.input_type
class RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs:
    def __init__(__self__, *,
                 request_headers_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]]] = None,
                 request_headers_to_removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 response_headers_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]]] = None,
                 response_headers_to_removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]] request_headers_to_adds: Headers to add to a matching request prior to forwarding the request to the
               backendService.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] request_headers_to_removes: A list of header names for headers that need to be removed from the request
               prior to forwarding the request to the backendService.
        :param pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]] response_headers_to_adds: Headers to add the response prior to sending the response back to the client.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] response_headers_to_removes: A list of header names for headers that need to be removed from the response
               prior to sending the response back to the client.
        """
        if request_headers_to_adds is not None:
            pulumi.set(__self__, "request_headers_to_adds", request_headers_to_adds)
        if request_headers_to_removes is not None:
            pulumi.set(__self__, "request_headers_to_removes", request_headers_to_removes)
        if response_headers_to_adds is not None:
            pulumi.set(__self__, "response_headers_to_adds", response_headers_to_adds)
        if response_headers_to_removes is not None:
            pulumi.set(__self__, "response_headers_to_removes", response_headers_to_removes)

    @property
    @pulumi.getter(name="requestHeadersToAdds")
    def request_headers_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]]]:
        """
        Headers to add to a matching request prior to forwarding the request to the
        backendService.
        Structure is documented below.
        """
        return pulumi.get(self, "request_headers_to_adds")

    @request_headers_to_adds.setter
    def request_headers_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]]]):
        pulumi.set(self, "request_headers_to_adds", value)

    @property
    @pulumi.getter(name="requestHeadersToRemoves")
    def request_headers_to_removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of header names for headers that need to be removed from the request
        prior to forwarding the request to the backendService.
        """
        return pulumi.get(self, "request_headers_to_removes")

    @request_headers_to_removes.setter
    def request_headers_to_removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "request_headers_to_removes", value)

    @property
    @pulumi.getter(name="responseHeadersToAdds")
    def response_headers_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]]]:
        """
        Headers to add the response prior to sending the response back to the client.
        Structure is documented below.
        """
        return pulumi.get(self, "response_headers_to_adds")

    @response_headers_to_adds.setter
    def response_headers_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]]]):
        pulumi.set(self, "response_headers_to_adds", value)

    @property
    @pulumi.getter(name="responseHeadersToRemoves")
    def response_headers_to_removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of header names for headers that need to be removed from the response
        prior to sending the response back to the client.
        """
        return pulumi.get(self, "response_headers_to_removes")

    @response_headers_to_removes.setter
    def response_headers_to_removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "response_headers_to_removes", value)


@pulumi.input_type
class RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 header_value: pulumi.Input[str],
                 replace: pulumi.Input[bool]):
        """
        :param pulumi.Input[str] header_name: The name of the header.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: If false, headerValue is appended to any values that already exist for the
               header. If true, headerValue is set for the header, discarding any values that
               were set for that header.
        """
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)
        pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The name of the header.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> pulumi.Input[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> pulumi.Input[bool]:
        """
        If false, headerValue is appended to any values that already exist for the
        header. If true, headerValue is set for the header, discarding any values that
        were set for that header.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: pulumi.Input[bool]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 header_value: pulumi.Input[str],
                 replace: pulumi.Input[bool]):
        """
        :param pulumi.Input[str] header_name: The name of the header.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: If false, headerValue is appended to any values that already exist for the
               header. If true, headerValue is set for the header, discarding any values that
               were set for that header.
        """
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)
        pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The name of the header.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> pulumi.Input[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> pulumi.Input[bool]:
        """
        If false, headerValue is appended to any values that already exist for the
        header. If true, headerValue is set for the header, discarding any values that
        were set for that header.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: pulumi.Input[bool]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class RegionUrlMapPathMatcherPathRuleUrlRedirectArgs:
    def __init__(__self__, *,
                 strip_query: pulumi.Input[bool],
                 host_redirect: Optional[pulumi.Input[str]] = None,
                 https_redirect: Optional[pulumi.Input[bool]] = None,
                 path_redirect: Optional[pulumi.Input[str]] = None,
                 prefix_redirect: Optional[pulumi.Input[str]] = None,
                 redirect_response_code: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] strip_query: If set to true, any accompanying query portion of the original URL is removed prior
               to redirecting the request. If set to false, the query portion of the original URL is
               retained.
               This field is required to ensure an empty block is not set. The normal default value is false.
        :param pulumi.Input[str] host_redirect: The host that will be used in the redirect response instead of the one that was
               supplied in the request. The value must be between 1 and 255 characters.
        :param pulumi.Input[bool] https_redirect: If set to true, the URL scheme in the redirected request is set to https. If set to
               false, the URL scheme of the redirected request will remain the same as that of the
               request. This must only be set for UrlMaps used in TargetHttpProxys. Setting this
               true for TargetHttpsProxy is not permitted. The default is set to false.
        :param pulumi.Input[str] path_redirect: The path that will be used in the redirect response instead of the one that was
               supplied in the request. pathRedirect cannot be supplied together with
               prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the
               original request will be used for the redirect. The value must be between 1 and 1024
               characters.
        :param pulumi.Input[str] prefix_redirect: The prefix that replaces the prefixMatch specified in the HttpRouteRuleMatch,
               retaining the remaining portion of the URL before redirecting the request.
               prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or
               neither. If neither is supplied, the path of the original request will be used for
               the redirect. The value must be between 1 and 1024 characters.
        :param pulumi.Input[str] redirect_response_code: The HTTP Status code to use for this RedirectAction. Supported values are:
               * MOVED_PERMANENTLY_DEFAULT, which is the default value and corresponds to 301.
               * FOUND, which corresponds to 302.
               * SEE_OTHER which corresponds to 303.
               * TEMPORARY_REDIRECT, which corresponds to 307. In this case, the request method
               will be retained.
               * PERMANENT_REDIRECT, which corresponds to 308. In this case,
               the request method will be retained.
        """
        pulumi.set(__self__, "strip_query", strip_query)
        if host_redirect is not None:
            pulumi.set(__self__, "host_redirect", host_redirect)
        if https_redirect is not None:
            pulumi.set(__self__, "https_redirect", https_redirect)
        if path_redirect is not None:
            pulumi.set(__self__, "path_redirect", path_redirect)
        if prefix_redirect is not None:
            pulumi.set(__self__, "prefix_redirect", prefix_redirect)
        if redirect_response_code is not None:
            pulumi.set(__self__, "redirect_response_code", redirect_response_code)

    @property
    @pulumi.getter(name="stripQuery")
    def strip_query(self) -> pulumi.Input[bool]:
        """
        If set to true, any accompanying query portion of the original URL is removed prior
        to redirecting the request. If set to false, the query portion of the original URL is
        retained.
        This field is required to ensure an empty block is not set. The normal default value is false.
        """
        return pulumi.get(self, "strip_query")

    @strip_query.setter
    def strip_query(self, value: pulumi.Input[bool]):
        pulumi.set(self, "strip_query", value)

    @property
    @pulumi.getter(name="hostRedirect")
    def host_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The host that will be used in the redirect response instead of the one that was
        supplied in the request. The value must be between 1 and 255 characters.
        """
        return pulumi.get(self, "host_redirect")

    @host_redirect.setter
    def host_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_redirect", value)

    @property
    @pulumi.getter(name="httpsRedirect")
    def https_redirect(self) -> Optional[pulumi.Input[bool]]:
        """
        If set to true, the URL scheme in the redirected request is set to https. If set to
        false, the URL scheme of the redirected request will remain the same as that of the
        request. This must only be set for UrlMaps used in TargetHttpProxys. Setting this
        true for TargetHttpsProxy is not permitted. The default is set to false.
        """
        return pulumi.get(self, "https_redirect")

    @https_redirect.setter
    def https_redirect(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "https_redirect", value)

    @property
    @pulumi.getter(name="pathRedirect")
    def path_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The path that will be used in the redirect response instead of the one that was
        supplied in the request. pathRedirect cannot be supplied together with
        prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the
        original request will be used for the redirect. The value must be between 1 and 1024
        characters.
        """
        return pulumi.get(self, "path_redirect")

    @path_redirect.setter
    def path_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path_redirect", value)

    @property
    @pulumi.getter(name="prefixRedirect")
    def prefix_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The prefix that replaces the prefixMatch specified in the HttpRouteRuleMatch,
        retaining the remaining portion of the URL before redirecting the request.
        prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or
        neither. If neither is supplied, the path of the original request will be used for
        the redirect. The value must be between 1 and 1024 characters.
        """
        return pulumi.get(self, "prefix_redirect")

    @prefix_redirect.setter
    def prefix_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "prefix_redirect", value)

    @property
    @pulumi.getter(name="redirectResponseCode")
    def redirect_response_code(self) -> Optional[pulumi.Input[str]]:
        """
        The HTTP Status code to use for this RedirectAction. Supported values are:
        * MOVED_PERMANENTLY_DEFAULT, which is the default value and corresponds to 301.
        * FOUND, which corresponds to 302.
        * SEE_OTHER which corresponds to 303.
        * TEMPORARY_REDIRECT, which corresponds to 307. In this case, the request method
        will be retained.
        * PERMANENT_REDIRECT, which corresponds to 308. In this case,
        the request method will be retained.
        """
        return pulumi.get(self, "redirect_response_code")

    @redirect_response_code.setter
    def redirect_response_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "redirect_response_code", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleArgs:
    def __init__(__self__, *,
                 priority: pulumi.Input[int],
                 header_action: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleHeaderActionArgs']] = None,
                 match_rules: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleArgs']]]] = None,
                 route_action: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionArgs']] = None,
                 service: Optional[pulumi.Input[str]] = None,
                 url_redirect: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleUrlRedirectArgs']] = None):
        """
        :param pulumi.Input[int] priority: For routeRules within a given pathMatcher, priority determines the order
               in which load balancer will interpret routeRules. RouteRules are evaluated
               in order of priority, from the lowest to highest number. The priority of
               a rule decreases as its number increases (1, 2, 3, N+1). The first rule
               that matches the request is applied.
               You cannot configure two or more routeRules with the same priority.
               Priority for each rule must be set to a number between 0 and
               2147483647 inclusive.
               Priority numbers can have gaps, which enable you to add or remove rules
               in the future without affecting the rest of the rules. For example,
               1, 2, 3, 4, 5, 9, 12, 16 is a valid series of priority numbers to which
               you could add rules numbered from 6 to 8, 10 to 11, and 13 to 15 in the
               future without any impact on existing rules.
        :param pulumi.Input['RegionUrlMapPathMatcherRouteRuleHeaderActionArgs'] header_action: Specifies changes to request and response headers that need to take effect for
               the selected backendService. headerAction specified here take effect before
               headerAction in the enclosing HttpRouteRule, PathMatcher and UrlMap.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleArgs']]] match_rules: The rules for determining a match.
               Structure is documented below.
        :param pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionArgs'] route_action: In response to a matching path, the load balancer performs advanced routing
               actions like URL rewrites, header transformations, etc. prior to forwarding the
               request to the selected backend. If routeAction specifies any
               weightedBackendServices, service must not be set. Conversely if service is set,
               routeAction cannot contain any  weightedBackendServices. Only one of routeAction
               or urlRedirect must be set.
               Structure is documented below.
        :param pulumi.Input[str] service: A reference to expected RegionBackendService resource the given URL should be mapped to.
        :param pulumi.Input['RegionUrlMapPathMatcherRouteRuleUrlRedirectArgs'] url_redirect: When a path pattern is matched, the request is redirected to a URL specified
               by urlRedirect. If urlRedirect is specified, service or routeAction must not
               be set.
               Structure is documented below.
        """
        pulumi.set(__self__, "priority", priority)
        if header_action is not None:
            pulumi.set(__self__, "header_action", header_action)
        if match_rules is not None:
            pulumi.set(__self__, "match_rules", match_rules)
        if route_action is not None:
            pulumi.set(__self__, "route_action", route_action)
        if service is not None:
            pulumi.set(__self__, "service", service)
        if url_redirect is not None:
            pulumi.set(__self__, "url_redirect", url_redirect)

    @property
    @pulumi.getter
    def priority(self) -> pulumi.Input[int]:
        """
        For routeRules within a given pathMatcher, priority determines the order
        in which load balancer will interpret routeRules. RouteRules are evaluated
        in order of priority, from the lowest to highest number. The priority of
        a rule decreases as its number increases (1, 2, 3, N+1). The first rule
        that matches the request is applied.
        You cannot configure two or more routeRules with the same priority.
        Priority for each rule must be set to a number between 0 and
        2147483647 inclusive.
        Priority numbers can have gaps, which enable you to add or remove rules
        in the future without affecting the rest of the rules. For example,
        1, 2, 3, 4, 5, 9, 12, 16 is a valid series of priority numbers to which
        you could add rules numbered from 6 to 8, 10 to 11, and 13 to 15 in the
        future without any impact on existing rules.
        """
        return pulumi.get(self, "priority")

    @priority.setter
    def priority(self, value: pulumi.Input[int]):
        pulumi.set(self, "priority", value)

    @property
    @pulumi.getter(name="headerAction")
    def header_action(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleHeaderActionArgs']]:
        """
        Specifies changes to request and response headers that need to take effect for
        the selected backendService. headerAction specified here take effect before
        headerAction in the enclosing HttpRouteRule, PathMatcher and UrlMap.
        Structure is documented below.
        """
        return pulumi.get(self, "header_action")

    @header_action.setter
    def header_action(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleHeaderActionArgs']]):
        pulumi.set(self, "header_action", value)

    @property
    @pulumi.getter(name="matchRules")
    def match_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleArgs']]]]:
        """
        The rules for determining a match.
        Structure is documented below.
        """
        return pulumi.get(self, "match_rules")

    @match_rules.setter
    def match_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleArgs']]]]):
        pulumi.set(self, "match_rules", value)

    @property
    @pulumi.getter(name="routeAction")
    def route_action(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionArgs']]:
        """
        In response to a matching path, the load balancer performs advanced routing
        actions like URL rewrites, header transformations, etc. prior to forwarding the
        request to the selected backend. If routeAction specifies any
        weightedBackendServices, service must not be set. Conversely if service is set,
        routeAction cannot contain any  weightedBackendServices. Only one of routeAction
        or urlRedirect must be set.
        Structure is documented below.
        """
        return pulumi.get(self, "route_action")

    @route_action.setter
    def route_action(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionArgs']]):
        pulumi.set(self, "route_action", value)

    @property
    @pulumi.getter
    def service(self) -> Optional[pulumi.Input[str]]:
        """
        A reference to expected RegionBackendService resource the given URL should be mapped to.
        """
        return pulumi.get(self, "service")

    @service.setter
    def service(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service", value)

    @property
    @pulumi.getter(name="urlRedirect")
    def url_redirect(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleUrlRedirectArgs']]:
        """
        When a path pattern is matched, the request is redirected to a URL specified
        by urlRedirect. If urlRedirect is specified, service or routeAction must not
        be set.
        Structure is documented below.
        """
        return pulumi.get(self, "url_redirect")

    @url_redirect.setter
    def url_redirect(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleUrlRedirectArgs']]):
        pulumi.set(self, "url_redirect", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleHeaderActionArgs:
    def __init__(__self__, *,
                 request_headers_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs']]]] = None,
                 request_headers_to_removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 response_headers_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs']]]] = None,
                 response_headers_to_removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs']]] request_headers_to_adds: Headers to add to a matching request prior to forwarding the request to the
               backendService.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] request_headers_to_removes: A list of header names for headers that need to be removed from the request
               prior to forwarding the request to the backendService.
        :param pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs']]] response_headers_to_adds: Headers to add the response prior to sending the response back to the client.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] response_headers_to_removes: A list of header names for headers that need to be removed from the response
               prior to sending the response back to the client.
        """
        if request_headers_to_adds is not None:
            pulumi.set(__self__, "request_headers_to_adds", request_headers_to_adds)
        if request_headers_to_removes is not None:
            pulumi.set(__self__, "request_headers_to_removes", request_headers_to_removes)
        if response_headers_to_adds is not None:
            pulumi.set(__self__, "response_headers_to_adds", response_headers_to_adds)
        if response_headers_to_removes is not None:
            pulumi.set(__self__, "response_headers_to_removes", response_headers_to_removes)

    @property
    @pulumi.getter(name="requestHeadersToAdds")
    def request_headers_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs']]]]:
        """
        Headers to add to a matching request prior to forwarding the request to the
        backendService.
        Structure is documented below.
        """
        return pulumi.get(self, "request_headers_to_adds")

    @request_headers_to_adds.setter
    def request_headers_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs']]]]):
        pulumi.set(self, "request_headers_to_adds", value)

    @property
    @pulumi.getter(name="requestHeadersToRemoves")
    def request_headers_to_removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of header names for headers that need to be removed from the request
        prior to forwarding the request to the backendService.
        """
        return pulumi.get(self, "request_headers_to_removes")

    @request_headers_to_removes.setter
    def request_headers_to_removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "request_headers_to_removes", value)

    @property
    @pulumi.getter(name="responseHeadersToAdds")
    def response_headers_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs']]]]:
        """
        Headers to add the response prior to sending the response back to the client.
        Structure is documented below.
        """
        return pulumi.get(self, "response_headers_to_adds")

    @response_headers_to_adds.setter
    def response_headers_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs']]]]):
        pulumi.set(self, "response_headers_to_adds", value)

    @property
    @pulumi.getter(name="responseHeadersToRemoves")
    def response_headers_to_removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of header names for headers that need to be removed from the response
        prior to sending the response back to the client.
        """
        return pulumi.get(self, "response_headers_to_removes")

    @response_headers_to_removes.setter
    def response_headers_to_removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "response_headers_to_removes", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 header_value: pulumi.Input[str],
                 replace: pulumi.Input[bool]):
        """
        :param pulumi.Input[str] header_name: The name of the header.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: If false, headerValue is appended to any values that already exist for the
               header. If true, headerValue is set for the header, discarding any values that
               were set for that header.
        """
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)
        pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The name of the header.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> pulumi.Input[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> pulumi.Input[bool]:
        """
        If false, headerValue is appended to any values that already exist for the
        header. If true, headerValue is set for the header, discarding any values that
        were set for that header.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: pulumi.Input[bool]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 header_value: pulumi.Input[str],
                 replace: pulumi.Input[bool]):
        """
        :param pulumi.Input[str] header_name: The name of the header.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: If false, headerValue is appended to any values that already exist for the
               header. If true, headerValue is set for the header, discarding any values that
               were set for that header.
        """
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)
        pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The name of the header.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> pulumi.Input[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> pulumi.Input[bool]:
        """
        If false, headerValue is appended to any values that already exist for the
        header. If true, headerValue is set for the header, discarding any values that
        were set for that header.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: pulumi.Input[bool]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleMatchRuleArgs:
    def __init__(__self__, *,
                 full_path_match: Optional[pulumi.Input[str]] = None,
                 header_matches: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs']]]] = None,
                 ignore_case: Optional[pulumi.Input[bool]] = None,
                 metadata_filters: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs']]]] = None,
                 prefix_match: Optional[pulumi.Input[str]] = None,
                 query_parameter_matches: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs']]]] = None,
                 regex_match: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] full_path_match: For satisfying the matchRule condition, the path of the request must exactly
               match the value specified in fullPathMatch after removing any query parameters
               and anchor that may be part of the original URL. FullPathMatch must be between 1
               and 1024 characters. Only one of prefixMatch, fullPathMatch or regexMatch must
               be specified.
        :param pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs']]] header_matches: Specifies a list of header match criteria, all of which must match corresponding
               headers in the request.
               Structure is documented below.
        :param pulumi.Input[bool] ignore_case: Specifies that prefixMatch and fullPathMatch matches are case sensitive.
               Defaults to false.
        :param pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs']]] metadata_filters: Opaque filter criteria used by Loadbalancer to restrict routing configuration to
               a limited set xDS compliant clients. In their xDS requests to Loadbalancer, xDS
               clients present node metadata. If a match takes place, the relevant routing
               configuration is made available to those proxies. For each metadataFilter in
               this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the
               filterLabels must match the corresponding label provided in the metadata. If its
               filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match
               with corresponding labels in the provided metadata. metadataFilters specified
               here can be overrides those specified in ForwardingRule that refers to this
               UrlMap. metadataFilters only applies to Loadbalancers that have their
               loadBalancingScheme set to INTERNAL_SELF_MANAGED.
               Structure is documented below.
        :param pulumi.Input[str] prefix_match: The value of the header must start with the contents of prefixMatch. Only one of
               exactMatch, prefixMatch, suffixMatch, regexMatch, presentMatch or rangeMatch
               must be set.
        :param pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs']]] query_parameter_matches: Specifies a list of query parameter match criteria, all of which must match
               corresponding query parameters in the request.
               Structure is documented below.
        :param pulumi.Input[str] regex_match: The queryParameterMatch matches if the value of the parameter matches the
               regular expression specified by regexMatch. For the regular expression grammar,
               please see en.cppreference.com/w/cpp/regex/ecmascript  Only one of presentMatch,
               exactMatch and regexMatch must be set.
        """
        if full_path_match is not None:
            pulumi.set(__self__, "full_path_match", full_path_match)
        if header_matches is not None:
            pulumi.set(__self__, "header_matches", header_matches)
        if ignore_case is not None:
            pulumi.set(__self__, "ignore_case", ignore_case)
        if metadata_filters is not None:
            pulumi.set(__self__, "metadata_filters", metadata_filters)
        if prefix_match is not None:
            pulumi.set(__self__, "prefix_match", prefix_match)
        if query_parameter_matches is not None:
            pulumi.set(__self__, "query_parameter_matches", query_parameter_matches)
        if regex_match is not None:
            pulumi.set(__self__, "regex_match", regex_match)

    @property
    @pulumi.getter(name="fullPathMatch")
    def full_path_match(self) -> Optional[pulumi.Input[str]]:
        """
        For satisfying the matchRule condition, the path of the request must exactly
        match the value specified in fullPathMatch after removing any query parameters
        and anchor that may be part of the original URL. FullPathMatch must be between 1
        and 1024 characters. Only one of prefixMatch, fullPathMatch or regexMatch must
        be specified.
        """
        return pulumi.get(self, "full_path_match")

    @full_path_match.setter
    def full_path_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "full_path_match", value)

    @property
    @pulumi.getter(name="headerMatches")
    def header_matches(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs']]]]:
        """
        Specifies a list of header match criteria, all of which must match corresponding
        headers in the request.
        Structure is documented below.
        """
        return pulumi.get(self, "header_matches")

    @header_matches.setter
    def header_matches(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs']]]]):
        pulumi.set(self, "header_matches", value)

    @property
    @pulumi.getter(name="ignoreCase")
    def ignore_case(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies that prefixMatch and fullPathMatch matches are case sensitive.
        Defaults to false.
        """
        return pulumi.get(self, "ignore_case")

    @ignore_case.setter
    def ignore_case(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ignore_case", value)

    @property
    @pulumi.getter(name="metadataFilters")
    def metadata_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs']]]]:
        """
        Opaque filter criteria used by Loadbalancer to restrict routing configuration to
        a limited set xDS compliant clients. In their xDS requests to Loadbalancer, xDS
        clients present node metadata. If a match takes place, the relevant routing
        configuration is made available to those proxies. For each metadataFilter in
        this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the
        filterLabels must match the corresponding label provided in the metadata. If its
        filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match
        with corresponding labels in the provided metadata. metadataFilters specified
        here can be overrides those specified in ForwardingRule that refers to this
        UrlMap. metadataFilters only applies to Loadbalancers that have their
        loadBalancingScheme set to INTERNAL_SELF_MANAGED.
        Structure is documented below.
        """
        return pulumi.get(self, "metadata_filters")

    @metadata_filters.setter
    def metadata_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs']]]]):
        pulumi.set(self, "metadata_filters", value)

    @property
    @pulumi.getter(name="prefixMatch")
    def prefix_match(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the header must start with the contents of prefixMatch. Only one of
        exactMatch, prefixMatch, suffixMatch, regexMatch, presentMatch or rangeMatch
        must be set.
        """
        return pulumi.get(self, "prefix_match")

    @prefix_match.setter
    def prefix_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "prefix_match", value)

    @property
    @pulumi.getter(name="queryParameterMatches")
    def query_parameter_matches(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs']]]]:
        """
        Specifies a list of query parameter match criteria, all of which must match
        corresponding query parameters in the request.
        Structure is documented below.
        """
        return pulumi.get(self, "query_parameter_matches")

    @query_parameter_matches.setter
    def query_parameter_matches(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs']]]]):
        pulumi.set(self, "query_parameter_matches", value)

    @property
    @pulumi.getter(name="regexMatch")
    def regex_match(self) -> Optional[pulumi.Input[str]]:
        """
        The queryParameterMatch matches if the value of the parameter matches the
        regular expression specified by regexMatch. For the regular expression grammar,
        please see en.cppreference.com/w/cpp/regex/ecmascript  Only one of presentMatch,
        exactMatch and regexMatch must be set.
        """
        return pulumi.get(self, "regex_match")

    @regex_match.setter
    def regex_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "regex_match", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 exact_match: Optional[pulumi.Input[str]] = None,
                 invert_match: Optional[pulumi.Input[bool]] = None,
                 prefix_match: Optional[pulumi.Input[str]] = None,
                 present_match: Optional[pulumi.Input[bool]] = None,
                 range_match: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatchArgs']] = None,
                 regex_match: Optional[pulumi.Input[str]] = None,
                 suffix_match: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] header_name: The name of the header.
        :param pulumi.Input[str] exact_match: The queryParameterMatch matches if the value of the parameter exactly matches
               the contents of exactMatch. Only one of presentMatch, exactMatch and regexMatch
               must be set.
        :param pulumi.Input[bool] invert_match: If set to false, the headerMatch is considered a match if the match criteria
               above are met. If set to true, the headerMatch is considered a match if the
               match criteria above are NOT met. Defaults to false.
        :param pulumi.Input[str] prefix_match: The value of the header must start with the contents of prefixMatch. Only one of
               exactMatch, prefixMatch, suffixMatch, regexMatch, presentMatch or rangeMatch
               must be set.
        :param pulumi.Input[bool] present_match: Specifies that the queryParameterMatch matches if the request contains the query
               parameter, irrespective of whether the parameter has a value or not. Only one of
               presentMatch, exactMatch and regexMatch must be set.
        :param pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatchArgs'] range_match: The header value must be an integer and its value must be in the range specified
               in rangeMatch. If the header does not contain an integer, number or is empty,
               the match fails. For example for a range [-5, 0]
               * -3 will match
               * 0 will not match
               * 0.25 will not match
               * -3someString will not match.
               Only one of exactMatch, prefixMatch, suffixMatch, regexMatch, presentMatch or
               rangeMatch must be set.
               Structure is documented below.
        :param pulumi.Input[str] regex_match: The queryParameterMatch matches if the value of the parameter matches the
               regular expression specified by regexMatch. For the regular expression grammar,
               please see en.cppreference.com/w/cpp/regex/ecmascript  Only one of presentMatch,
               exactMatch and regexMatch must be set.
        :param pulumi.Input[str] suffix_match: The value of the header must end with the contents of suffixMatch. Only one of
               exactMatch, prefixMatch, suffixMatch, regexMatch, presentMatch or rangeMatch
               must be set.
        """
        pulumi.set(__self__, "header_name", header_name)
        if exact_match is not None:
            pulumi.set(__self__, "exact_match", exact_match)
        if invert_match is not None:
            pulumi.set(__self__, "invert_match", invert_match)
        if prefix_match is not None:
            pulumi.set(__self__, "prefix_match", prefix_match)
        if present_match is not None:
            pulumi.set(__self__, "present_match", present_match)
        if range_match is not None:
            pulumi.set(__self__, "range_match", range_match)
        if regex_match is not None:
            pulumi.set(__self__, "regex_match", regex_match)
        if suffix_match is not None:
            pulumi.set(__self__, "suffix_match", suffix_match)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The name of the header.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="exactMatch")
    def exact_match(self) -> Optional[pulumi.Input[str]]:
        """
        The queryParameterMatch matches if the value of the parameter exactly matches
        the contents of exactMatch. Only one of presentMatch, exactMatch and regexMatch
        must be set.
        """
        return pulumi.get(self, "exact_match")

    @exact_match.setter
    def exact_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "exact_match", value)

    @property
    @pulumi.getter(name="invertMatch")
    def invert_match(self) -> Optional[pulumi.Input[bool]]:
        """
        If set to false, the headerMatch is considered a match if the match criteria
        above are met. If set to true, the headerMatch is considered a match if the
        match criteria above are NOT met. Defaults to false.
        """
        return pulumi.get(self, "invert_match")

    @invert_match.setter
    def invert_match(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "invert_match", value)

    @property
    @pulumi.getter(name="prefixMatch")
    def prefix_match(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the header must start with the contents of prefixMatch. Only one of
        exactMatch, prefixMatch, suffixMatch, regexMatch, presentMatch or rangeMatch
        must be set.
        """
        return pulumi.get(self, "prefix_match")

    @prefix_match.setter
    def prefix_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "prefix_match", value)

    @property
    @pulumi.getter(name="presentMatch")
    def present_match(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies that the queryParameterMatch matches if the request contains the query
        parameter, irrespective of whether the parameter has a value or not. Only one of
        presentMatch, exactMatch and regexMatch must be set.
        """
        return pulumi.get(self, "present_match")

    @present_match.setter
    def present_match(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "present_match", value)

    @property
    @pulumi.getter(name="rangeMatch")
    def range_match(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatchArgs']]:
        """
        The header value must be an integer and its value must be in the range specified
        in rangeMatch. If the header does not contain an integer, number or is empty,
        the match fails. For example for a range [-5, 0]
        * -3 will match
        * 0 will not match
        * 0.25 will not match
        * -3someString will not match.
        Only one of exactMatch, prefixMatch, suffixMatch, regexMatch, presentMatch or
        rangeMatch must be set.
        Structure is documented below.
        """
        return pulumi.get(self, "range_match")

    @range_match.setter
    def range_match(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatchArgs']]):
        pulumi.set(self, "range_match", value)

    @property
    @pulumi.getter(name="regexMatch")
    def regex_match(self) -> Optional[pulumi.Input[str]]:
        """
        The queryParameterMatch matches if the value of the parameter matches the
        regular expression specified by regexMatch. For the regular expression grammar,
        please see en.cppreference.com/w/cpp/regex/ecmascript  Only one of presentMatch,
        exactMatch and regexMatch must be set.
        """
        return pulumi.get(self, "regex_match")

    @regex_match.setter
    def regex_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "regex_match", value)

    @property
    @pulumi.getter(name="suffixMatch")
    def suffix_match(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the header must end with the contents of suffixMatch. Only one of
        exactMatch, prefixMatch, suffixMatch, regexMatch, presentMatch or rangeMatch
        must be set.
        """
        return pulumi.get(self, "suffix_match")

    @suffix_match.setter
    def suffix_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "suffix_match", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatchArgs:
    def __init__(__self__, *,
                 range_end: pulumi.Input[int],
                 range_start: pulumi.Input[int]):
        """
        :param pulumi.Input[int] range_end: The end of the range (exclusive).
        :param pulumi.Input[int] range_start: The start of the range (inclusive).
        """
        pulumi.set(__self__, "range_end", range_end)
        pulumi.set(__self__, "range_start", range_start)

    @property
    @pulumi.getter(name="rangeEnd")
    def range_end(self) -> pulumi.Input[int]:
        """
        The end of the range (exclusive).
        """
        return pulumi.get(self, "range_end")

    @range_end.setter
    def range_end(self, value: pulumi.Input[int]):
        pulumi.set(self, "range_end", value)

    @property
    @pulumi.getter(name="rangeStart")
    def range_start(self) -> pulumi.Input[int]:
        """
        The start of the range (inclusive).
        """
        return pulumi.get(self, "range_start")

    @range_start.setter
    def range_start(self, value: pulumi.Input[int]):
        pulumi.set(self, "range_start", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs:
    def __init__(__self__, *,
                 filter_labels: pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs']]],
                 filter_match_criteria: pulumi.Input[str]):
        """
        :param pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs']]] filter_labels: The list of label value pairs that must match labels in the provided metadata
               based on filterMatchCriteria  This list must not be empty and can have at the
               most 64 entries.
               Structure is documented below.
        :param pulumi.Input[str] filter_match_criteria: Specifies how individual filterLabel matches within the list of filterLabels
               contribute towards the overall metadataFilter match. Supported values are:
               * MATCH_ANY: At least one of the filterLabels must have a matching label in the
               provided metadata.
               * MATCH_ALL: All filterLabels must have matching labels in
               the provided metadata.
               Possible values are `MATCH_ALL` and `MATCH_ANY`.
        """
        pulumi.set(__self__, "filter_labels", filter_labels)
        pulumi.set(__self__, "filter_match_criteria", filter_match_criteria)

    @property
    @pulumi.getter(name="filterLabels")
    def filter_labels(self) -> pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs']]]:
        """
        The list of label value pairs that must match labels in the provided metadata
        based on filterMatchCriteria  This list must not be empty and can have at the
        most 64 entries.
        Structure is documented below.
        """
        return pulumi.get(self, "filter_labels")

    @filter_labels.setter
    def filter_labels(self, value: pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs']]]):
        pulumi.set(self, "filter_labels", value)

    @property
    @pulumi.getter(name="filterMatchCriteria")
    def filter_match_criteria(self) -> pulumi.Input[str]:
        """
        Specifies how individual filterLabel matches within the list of filterLabels
        contribute towards the overall metadataFilter match. Supported values are:
        * MATCH_ANY: At least one of the filterLabels must have a matching label in the
        provided metadata.
        * MATCH_ALL: All filterLabels must have matching labels in
        the provided metadata.
        Possible values are `MATCH_ALL` and `MATCH_ANY`.
        """
        return pulumi.get(self, "filter_match_criteria")

    @filter_match_criteria.setter
    def filter_match_criteria(self, value: pulumi.Input[str]):
        pulumi.set(self, "filter_match_criteria", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] name: The name of the query parameter to match. The query parameter must exist in the
               request, in the absence of which the request match fails.
        :param pulumi.Input[str] value: The value of the label must match the specified value. value can have a maximum
               length of 1024 characters.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the query parameter to match. The query parameter must exist in the
        request, in the absence of which the request match fails.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        The value of the label must match the specified value. value can have a maximum
        length of 1024 characters.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 exact_match: Optional[pulumi.Input[str]] = None,
                 present_match: Optional[pulumi.Input[bool]] = None,
                 regex_match: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The name of the query parameter to match. The query parameter must exist in the
               request, in the absence of which the request match fails.
        :param pulumi.Input[str] exact_match: The queryParameterMatch matches if the value of the parameter exactly matches
               the contents of exactMatch. Only one of presentMatch, exactMatch and regexMatch
               must be set.
        :param pulumi.Input[bool] present_match: Specifies that the queryParameterMatch matches if the request contains the query
               parameter, irrespective of whether the parameter has a value or not. Only one of
               presentMatch, exactMatch and regexMatch must be set.
        :param pulumi.Input[str] regex_match: The queryParameterMatch matches if the value of the parameter matches the
               regular expression specified by regexMatch. For the regular expression grammar,
               please see en.cppreference.com/w/cpp/regex/ecmascript  Only one of presentMatch,
               exactMatch and regexMatch must be set.
        """
        pulumi.set(__self__, "name", name)
        if exact_match is not None:
            pulumi.set(__self__, "exact_match", exact_match)
        if present_match is not None:
            pulumi.set(__self__, "present_match", present_match)
        if regex_match is not None:
            pulumi.set(__self__, "regex_match", regex_match)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the query parameter to match. The query parameter must exist in the
        request, in the absence of which the request match fails.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="exactMatch")
    def exact_match(self) -> Optional[pulumi.Input[str]]:
        """
        The queryParameterMatch matches if the value of the parameter exactly matches
        the contents of exactMatch. Only one of presentMatch, exactMatch and regexMatch
        must be set.
        """
        return pulumi.get(self, "exact_match")

    @exact_match.setter
    def exact_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "exact_match", value)

    @property
    @pulumi.getter(name="presentMatch")
    def present_match(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies that the queryParameterMatch matches if the request contains the query
        parameter, irrespective of whether the parameter has a value or not. Only one of
        presentMatch, exactMatch and regexMatch must be set.
        """
        return pulumi.get(self, "present_match")

    @present_match.setter
    def present_match(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "present_match", value)

    @property
    @pulumi.getter(name="regexMatch")
    def regex_match(self) -> Optional[pulumi.Input[str]]:
        """
        The queryParameterMatch matches if the value of the parameter matches the
        regular expression specified by regexMatch. For the regular expression grammar,
        please see en.cppreference.com/w/cpp/regex/ecmascript  Only one of presentMatch,
        exactMatch and regexMatch must be set.
        """
        return pulumi.get(self, "regex_match")

    @regex_match.setter
    def regex_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "regex_match", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleRouteActionArgs:
    def __init__(__self__, *,
                 cors_policy: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionCorsPolicyArgs']] = None,
                 fault_injection_policy: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyArgs']] = None,
                 request_mirror_policy: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionRequestMirrorPolicyArgs']] = None,
                 retry_policy: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyArgs']] = None,
                 timeout: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionTimeoutArgs']] = None,
                 url_rewrite: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionUrlRewriteArgs']] = None,
                 weighted_backend_services: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceArgs']]]] = None):
        """
        :param pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionCorsPolicyArgs'] cors_policy: The specification for allowing client side cross-origin requests. Please see W3C
               Recommendation for Cross Origin Resource Sharing
               Structure is documented below.
        :param pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyArgs'] fault_injection_policy: The specification for fault injection introduced into traffic to test the
               resiliency of clients to backend service failure. As part of fault injection,
               when clients send requests to a backend service, delays can be introduced by
               Loadbalancer on a percentage of requests before sending those request to the
               backend service. Similarly requests from clients can be aborted by the
               Loadbalancer for a percentage of requests. timeout and retry_policy will be
               ignored by clients that are configured with a fault_injection_policy.
               Structure is documented below.
        :param pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionRequestMirrorPolicyArgs'] request_mirror_policy: Specifies the policy on how requests intended for the route's backends are
               shadowed to a separate mirrored backend service. Loadbalancer does not wait for
               responses from the shadow service. Prior to sending traffic to the shadow
               service, the host / authority header is suffixed with -shadow.
               Structure is documented below.
        :param pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyArgs'] retry_policy: Specifies the retry policy associated with this route.
               Structure is documented below.
        :param pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionTimeoutArgs'] timeout: Specifies the timeout for the selected route. Timeout is computed from the time
               the request is has been fully processed (i.e. end-of-stream) up until the
               response has been completely processed. Timeout includes all retries. If not
               specified, the default value is 15 seconds.
               Structure is documented below.
        :param pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionUrlRewriteArgs'] url_rewrite: The spec to modify the URL of the request, prior to forwarding the request to
               the matched service
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceArgs']]] weighted_backend_services: A list of weighted backend services to send traffic to when a route match
               occurs. The weights determine the fraction of traffic that flows to their
               corresponding backend service. If all traffic needs to go to a single backend
               service, there must be one  weightedBackendService with weight set to a non 0
               number. Once a backendService is identified and before forwarding the request to
               the backend service, advanced routing actions like Url rewrites and header
               transformations are applied depending on additional settings specified in this
               HttpRouteAction.
               Structure is documented below.
        """
        if cors_policy is not None:
            pulumi.set(__self__, "cors_policy", cors_policy)
        if fault_injection_policy is not None:
            pulumi.set(__self__, "fault_injection_policy", fault_injection_policy)
        if request_mirror_policy is not None:
            pulumi.set(__self__, "request_mirror_policy", request_mirror_policy)
        if retry_policy is not None:
            pulumi.set(__self__, "retry_policy", retry_policy)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)
        if url_rewrite is not None:
            pulumi.set(__self__, "url_rewrite", url_rewrite)
        if weighted_backend_services is not None:
            pulumi.set(__self__, "weighted_backend_services", weighted_backend_services)

    @property
    @pulumi.getter(name="corsPolicy")
    def cors_policy(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionCorsPolicyArgs']]:
        """
        The specification for allowing client side cross-origin requests. Please see W3C
        Recommendation for Cross Origin Resource Sharing
        Structure is documented below.
        """
        return pulumi.get(self, "cors_policy")

    @cors_policy.setter
    def cors_policy(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionCorsPolicyArgs']]):
        pulumi.set(self, "cors_policy", value)

    @property
    @pulumi.getter(name="faultInjectionPolicy")
    def fault_injection_policy(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyArgs']]:
        """
        The specification for fault injection introduced into traffic to test the
        resiliency of clients to backend service failure. As part of fault injection,
        when clients send requests to a backend service, delays can be introduced by
        Loadbalancer on a percentage of requests before sending those request to the
        backend service. Similarly requests from clients can be aborted by the
        Loadbalancer for a percentage of requests. timeout and retry_policy will be
        ignored by clients that are configured with a fault_injection_policy.
        Structure is documented below.
        """
        return pulumi.get(self, "fault_injection_policy")

    @fault_injection_policy.setter
    def fault_injection_policy(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyArgs']]):
        pulumi.set(self, "fault_injection_policy", value)

    @property
    @pulumi.getter(name="requestMirrorPolicy")
    def request_mirror_policy(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionRequestMirrorPolicyArgs']]:
        """
        Specifies the policy on how requests intended for the route's backends are
        shadowed to a separate mirrored backend service. Loadbalancer does not wait for
        responses from the shadow service. Prior to sending traffic to the shadow
        service, the host / authority header is suffixed with -shadow.
        Structure is documented below.
        """
        return pulumi.get(self, "request_mirror_policy")

    @request_mirror_policy.setter
    def request_mirror_policy(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionRequestMirrorPolicyArgs']]):
        pulumi.set(self, "request_mirror_policy", value)

    @property
    @pulumi.getter(name="retryPolicy")
    def retry_policy(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyArgs']]:
        """
        Specifies the retry policy associated with this route.
        Structure is documented below.
        """
        return pulumi.get(self, "retry_policy")

    @retry_policy.setter
    def retry_policy(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyArgs']]):
        pulumi.set(self, "retry_policy", value)

    @property
    @pulumi.getter
    def timeout(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionTimeoutArgs']]:
        """
        Specifies the timeout for the selected route. Timeout is computed from the time
        the request is has been fully processed (i.e. end-of-stream) up until the
        response has been completely processed. Timeout includes all retries. If not
        specified, the default value is 15 seconds.
        Structure is documented below.
        """
        return pulumi.get(self, "timeout")

    @timeout.setter
    def timeout(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionTimeoutArgs']]):
        pulumi.set(self, "timeout", value)

    @property
    @pulumi.getter(name="urlRewrite")
    def url_rewrite(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionUrlRewriteArgs']]:
        """
        The spec to modify the URL of the request, prior to forwarding the request to
        the matched service
        Structure is documented below.
        """
        return pulumi.get(self, "url_rewrite")

    @url_rewrite.setter
    def url_rewrite(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionUrlRewriteArgs']]):
        pulumi.set(self, "url_rewrite", value)

    @property
    @pulumi.getter(name="weightedBackendServices")
    def weighted_backend_services(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceArgs']]]]:
        """
        A list of weighted backend services to send traffic to when a route match
        occurs. The weights determine the fraction of traffic that flows to their
        corresponding backend service. If all traffic needs to go to a single backend
        service, there must be one  weightedBackendService with weight set to a non 0
        number. Once a backendService is identified and before forwarding the request to
        the backend service, advanced routing actions like Url rewrites and header
        transformations are applied depending on additional settings specified in this
        HttpRouteAction.
        Structure is documented below.
        """
        return pulumi.get(self, "weighted_backend_services")

    @weighted_backend_services.setter
    def weighted_backend_services(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceArgs']]]]):
        pulumi.set(self, "weighted_backend_services", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleRouteActionCorsPolicyArgs:
    def __init__(__self__, *,
                 allow_credentials: Optional[pulumi.Input[bool]] = None,
                 allow_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_methods: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_origin_regexes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_origins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 disabled: Optional[pulumi.Input[bool]] = None,
                 expose_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 max_age: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[bool] allow_credentials: In response to a preflight request, setting this to true indicates that the
               actual request can include user credentials. This translates to the Access-
               Control-Allow-Credentials header. Defaults to false.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_headers: Specifies the content for the Access-Control-Allow-Headers header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_methods: Specifies the content for the Access-Control-Allow-Methods header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_origin_regexes: Specifies the regular expression patterns that match allowed origins. For
               regular expression grammar please see en.cppreference.com/w/cpp/regex/ecmascript
               An origin is allowed if it matches either allow_origins or allow_origin_regex.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_origins: Specifies the list of origins that will be allowed to do CORS requests. An
               origin is allowed if it matches either allow_origins or allow_origin_regex.
        :param pulumi.Input[bool] disabled: If true, specifies the CORS policy is disabled.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] expose_headers: Specifies the content for the Access-Control-Expose-Headers header.
        :param pulumi.Input[int] max_age: Specifies how long the results of a preflight request can be cached. This
               translates to the content for the Access-Control-Max-Age header.
        """
        if allow_credentials is not None:
            pulumi.set(__self__, "allow_credentials", allow_credentials)
        if allow_headers is not None:
            pulumi.set(__self__, "allow_headers", allow_headers)
        if allow_methods is not None:
            pulumi.set(__self__, "allow_methods", allow_methods)
        if allow_origin_regexes is not None:
            pulumi.set(__self__, "allow_origin_regexes", allow_origin_regexes)
        if allow_origins is not None:
            pulumi.set(__self__, "allow_origins", allow_origins)
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)
        if expose_headers is not None:
            pulumi.set(__self__, "expose_headers", expose_headers)
        if max_age is not None:
            pulumi.set(__self__, "max_age", max_age)

    @property
    @pulumi.getter(name="allowCredentials")
    def allow_credentials(self) -> Optional[pulumi.Input[bool]]:
        """
        In response to a preflight request, setting this to true indicates that the
        actual request can include user credentials. This translates to the Access-
        Control-Allow-Credentials header. Defaults to false.
        """
        return pulumi.get(self, "allow_credentials")

    @allow_credentials.setter
    def allow_credentials(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_credentials", value)

    @property
    @pulumi.getter(name="allowHeaders")
    def allow_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for the Access-Control-Allow-Headers header.
        """
        return pulumi.get(self, "allow_headers")

    @allow_headers.setter
    def allow_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_headers", value)

    @property
    @pulumi.getter(name="allowMethods")
    def allow_methods(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for the Access-Control-Allow-Methods header.
        """
        return pulumi.get(self, "allow_methods")

    @allow_methods.setter
    def allow_methods(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_methods", value)

    @property
    @pulumi.getter(name="allowOriginRegexes")
    def allow_origin_regexes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the regular expression patterns that match allowed origins. For
        regular expression grammar please see en.cppreference.com/w/cpp/regex/ecmascript
        An origin is allowed if it matches either allow_origins or allow_origin_regex.
        """
        return pulumi.get(self, "allow_origin_regexes")

    @allow_origin_regexes.setter
    def allow_origin_regexes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_origin_regexes", value)

    @property
    @pulumi.getter(name="allowOrigins")
    def allow_origins(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the list of origins that will be allowed to do CORS requests. An
        origin is allowed if it matches either allow_origins or allow_origin_regex.
        """
        return pulumi.get(self, "allow_origins")

    @allow_origins.setter
    def allow_origins(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_origins", value)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        If true, specifies the CORS policy is disabled.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)

    @property
    @pulumi.getter(name="exposeHeaders")
    def expose_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for the Access-Control-Expose-Headers header.
        """
        return pulumi.get(self, "expose_headers")

    @expose_headers.setter
    def expose_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "expose_headers", value)

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies how long the results of a preflight request can be cached. This
        translates to the content for the Access-Control-Max-Age header.
        """
        return pulumi.get(self, "max_age")

    @max_age.setter
    def max_age(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_age", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyArgs:
    def __init__(__self__, *,
                 abort: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbortArgs']] = None,
                 delay: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayArgs']] = None):
        """
        :param pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbortArgs'] abort: The specification for how client requests are aborted as part of fault
               injection.
               Structure is documented below.
        :param pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayArgs'] delay: The specification for how client requests are delayed as part of fault
               injection, before being sent to a backend service.
               Structure is documented below.
        """
        if abort is not None:
            pulumi.set(__self__, "abort", abort)
        if delay is not None:
            pulumi.set(__self__, "delay", delay)

    @property
    @pulumi.getter
    def abort(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbortArgs']]:
        """
        The specification for how client requests are aborted as part of fault
        injection.
        Structure is documented below.
        """
        return pulumi.get(self, "abort")

    @abort.setter
    def abort(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbortArgs']]):
        pulumi.set(self, "abort", value)

    @property
    @pulumi.getter
    def delay(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayArgs']]:
        """
        The specification for how client requests are delayed as part of fault
        injection, before being sent to a backend service.
        Structure is documented below.
        """
        return pulumi.get(self, "delay")

    @delay.setter
    def delay(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayArgs']]):
        pulumi.set(self, "delay", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbortArgs:
    def __init__(__self__, *,
                 http_status: Optional[pulumi.Input[int]] = None,
                 percentage: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[int] http_status: The HTTP status code used to abort the request. The value must be between 200
               and 599 inclusive.
        :param pulumi.Input[float] percentage: The percentage of traffic (connections/operations/requests) on which delay will
               be introduced as part of fault injection. The value must be between 0.0 and
               100.0 inclusive.
        """
        if http_status is not None:
            pulumi.set(__self__, "http_status", http_status)
        if percentage is not None:
            pulumi.set(__self__, "percentage", percentage)

    @property
    @pulumi.getter(name="httpStatus")
    def http_status(self) -> Optional[pulumi.Input[int]]:
        """
        The HTTP status code used to abort the request. The value must be between 200
        and 599 inclusive.
        """
        return pulumi.get(self, "http_status")

    @http_status.setter
    def http_status(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "http_status", value)

    @property
    @pulumi.getter
    def percentage(self) -> Optional[pulumi.Input[float]]:
        """
        The percentage of traffic (connections/operations/requests) on which delay will
        be introduced as part of fault injection. The value must be between 0.0 and
        100.0 inclusive.
        """
        return pulumi.get(self, "percentage")

    @percentage.setter
    def percentage(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "percentage", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayArgs:
    def __init__(__self__, *,
                 fixed_delay: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs']] = None,
                 percentage: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs'] fixed_delay: Specifies the value of the fixed delay interval.
               Structure is documented below.
        :param pulumi.Input[float] percentage: The percentage of traffic (connections/operations/requests) on which delay will
               be introduced as part of fault injection. The value must be between 0.0 and
               100.0 inclusive.
        """
        if fixed_delay is not None:
            pulumi.set(__self__, "fixed_delay", fixed_delay)
        if percentage is not None:
            pulumi.set(__self__, "percentage", percentage)

    @property
    @pulumi.getter(name="fixedDelay")
    def fixed_delay(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs']]:
        """
        Specifies the value of the fixed delay interval.
        Structure is documented below.
        """
        return pulumi.get(self, "fixed_delay")

    @fixed_delay.setter
    def fixed_delay(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs']]):
        pulumi.set(self, "fixed_delay", value)

    @property
    @pulumi.getter
    def percentage(self) -> Optional[pulumi.Input[float]]:
        """
        The percentage of traffic (connections/operations/requests) on which delay will
        be introduced as part of fault injection. The value must be between 0.0 and
        100.0 inclusive.
        """
        return pulumi.get(self, "percentage")

    @percentage.setter
    def percentage(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "percentage", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs:
    def __init__(__self__, *,
                 seconds: pulumi.Input[str],
                 nanos: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
               inclusive.
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations
               less than one second are represented with a 0 `seconds` field and a positive
               `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        pulumi.set(__self__, "seconds", seconds)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)

    @property
    @pulumi.getter
    def seconds(self) -> pulumi.Input[str]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
        inclusive.
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: pulumi.Input[str]):
        pulumi.set(self, "seconds", value)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations
        less than one second are represented with a 0 `seconds` field and a positive
        `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleRouteActionRequestMirrorPolicyArgs:
    def __init__(__self__, *,
                 backend_service: pulumi.Input[str]):
        """
        :param pulumi.Input[str] backend_service: The default RegionBackendService resource. Before
               forwarding the request to backendService, the loadbalancer applies any relevant
               headerActions specified as part of this backendServiceWeight.
        """
        pulumi.set(__self__, "backend_service", backend_service)

    @property
    @pulumi.getter(name="backendService")
    def backend_service(self) -> pulumi.Input[str]:
        """
        The default RegionBackendService resource. Before
        forwarding the request to backendService, the loadbalancer applies any relevant
        headerActions specified as part of this backendServiceWeight.
        """
        return pulumi.get(self, "backend_service")

    @backend_service.setter
    def backend_service(self, value: pulumi.Input[str]):
        pulumi.set(self, "backend_service", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyArgs:
    def __init__(__self__, *,
                 num_retries: pulumi.Input[int],
                 per_try_timeout: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeoutArgs']] = None,
                 retry_conditions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[int] num_retries: Specifies the allowed number retries. This number must be > 0.
        :param pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeoutArgs'] per_try_timeout: Specifies a non-zero timeout per retry attempt.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] retry_conditions: Specifies one or more conditions when this retry rule applies. Valid values are:
               - 5xx: Loadbalancer will attempt a retry if the backend service responds with
               any 5xx response code, or if the backend service does not respond at all,
               example: disconnects, reset, read timeout, connection failure, and refused
               streams.
               - gateway-error: Similar to 5xx, but only applies to response codes
               502, 503 or 504.
               - connect-failure: Loadbalancer will retry on failures
               connecting to backend services, for example due to connection timeouts.
               - retriable-4xx: Loadbalancer will retry for retriable 4xx response codes.
               Currently the only retriable error supported is 409.
               - refused-stream: Loadbalancer will retry if the backend service resets the stream with a
               REFUSED_STREAM error code. This reset type indicates that it is safe to retry.
               - cancelled: Loadbalancer will retry if the gRPC status code in the response
               header is set to cancelled
               - deadline-exceeded: Loadbalancer will retry if the
               gRPC status code in the response header is set to deadline-exceeded
               - resource-exhausted: Loadbalancer will retry if the gRPC status code in the response
               header is set to resource-exhausted
               - unavailable: Loadbalancer will retry if
               the gRPC status code in the response header is set to unavailable
        """
        pulumi.set(__self__, "num_retries", num_retries)
        if per_try_timeout is not None:
            pulumi.set(__self__, "per_try_timeout", per_try_timeout)
        if retry_conditions is not None:
            pulumi.set(__self__, "retry_conditions", retry_conditions)

    @property
    @pulumi.getter(name="numRetries")
    def num_retries(self) -> pulumi.Input[int]:
        """
        Specifies the allowed number retries. This number must be > 0.
        """
        return pulumi.get(self, "num_retries")

    @num_retries.setter
    def num_retries(self, value: pulumi.Input[int]):
        pulumi.set(self, "num_retries", value)

    @property
    @pulumi.getter(name="perTryTimeout")
    def per_try_timeout(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeoutArgs']]:
        """
        Specifies a non-zero timeout per retry attempt.
        Structure is documented below.
        """
        return pulumi.get(self, "per_try_timeout")

    @per_try_timeout.setter
    def per_try_timeout(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeoutArgs']]):
        pulumi.set(self, "per_try_timeout", value)

    @property
    @pulumi.getter(name="retryConditions")
    def retry_conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies one or more conditions when this retry rule applies. Valid values are:
        - 5xx: Loadbalancer will attempt a retry if the backend service responds with
        any 5xx response code, or if the backend service does not respond at all,
        example: disconnects, reset, read timeout, connection failure, and refused
        streams.
        - gateway-error: Similar to 5xx, but only applies to response codes
        502, 503 or 504.
        - connect-failure: Loadbalancer will retry on failures
        connecting to backend services, for example due to connection timeouts.
        - retriable-4xx: Loadbalancer will retry for retriable 4xx response codes.
        Currently the only retriable error supported is 409.
        - refused-stream: Loadbalancer will retry if the backend service resets the stream with a
        REFUSED_STREAM error code. This reset type indicates that it is safe to retry.
        - cancelled: Loadbalancer will retry if the gRPC status code in the response
        header is set to cancelled
        - deadline-exceeded: Loadbalancer will retry if the
        gRPC status code in the response header is set to deadline-exceeded
        - resource-exhausted: Loadbalancer will retry if the gRPC status code in the response
        header is set to resource-exhausted
        - unavailable: Loadbalancer will retry if
        the gRPC status code in the response header is set to unavailable
        """
        return pulumi.get(self, "retry_conditions")

    @retry_conditions.setter
    def retry_conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "retry_conditions", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeoutArgs:
    def __init__(__self__, *,
                 seconds: pulumi.Input[str],
                 nanos: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
               inclusive.
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations
               less than one second are represented with a 0 `seconds` field and a positive
               `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        pulumi.set(__self__, "seconds", seconds)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)

    @property
    @pulumi.getter
    def seconds(self) -> pulumi.Input[str]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
        inclusive.
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: pulumi.Input[str]):
        pulumi.set(self, "seconds", value)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations
        less than one second are represented with a 0 `seconds` field and a positive
        `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleRouteActionTimeoutArgs:
    def __init__(__self__, *,
                 seconds: pulumi.Input[str],
                 nanos: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
               inclusive.
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations
               less than one second are represented with a 0 `seconds` field and a positive
               `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        pulumi.set(__self__, "seconds", seconds)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)

    @property
    @pulumi.getter
    def seconds(self) -> pulumi.Input[str]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
        inclusive.
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: pulumi.Input[str]):
        pulumi.set(self, "seconds", value)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations
        less than one second are represented with a 0 `seconds` field and a positive
        `nanos` field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleRouteActionUrlRewriteArgs:
    def __init__(__self__, *,
                 host_rewrite: Optional[pulumi.Input[str]] = None,
                 path_prefix_rewrite: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host_rewrite: Prior to forwarding the request to the selected service, the request's host
               header is replaced with contents of hostRewrite. The value must be between 1 and
               255 characters.
        :param pulumi.Input[str] path_prefix_rewrite: Prior to forwarding the request to the selected backend service, the matching
               portion of the request's path is replaced by pathPrefixRewrite. The value must
               be between 1 and 1024 characters.
        """
        if host_rewrite is not None:
            pulumi.set(__self__, "host_rewrite", host_rewrite)
        if path_prefix_rewrite is not None:
            pulumi.set(__self__, "path_prefix_rewrite", path_prefix_rewrite)

    @property
    @pulumi.getter(name="hostRewrite")
    def host_rewrite(self) -> Optional[pulumi.Input[str]]:
        """
        Prior to forwarding the request to the selected service, the request's host
        header is replaced with contents of hostRewrite. The value must be between 1 and
        255 characters.
        """
        return pulumi.get(self, "host_rewrite")

    @host_rewrite.setter
    def host_rewrite(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_rewrite", value)

    @property
    @pulumi.getter(name="pathPrefixRewrite")
    def path_prefix_rewrite(self) -> Optional[pulumi.Input[str]]:
        """
        Prior to forwarding the request to the selected backend service, the matching
        portion of the request's path is replaced by pathPrefixRewrite. The value must
        be between 1 and 1024 characters.
        """
        return pulumi.get(self, "path_prefix_rewrite")

    @path_prefix_rewrite.setter
    def path_prefix_rewrite(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path_prefix_rewrite", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceArgs:
    def __init__(__self__, *,
                 backend_service: pulumi.Input[str],
                 weight: pulumi.Input[int],
                 header_action: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionArgs']] = None):
        """
        :param pulumi.Input[str] backend_service: The default RegionBackendService resource. Before
               forwarding the request to backendService, the loadbalancer applies any relevant
               headerActions specified as part of this backendServiceWeight.
        :param pulumi.Input[int] weight: Specifies the fraction of traffic sent to backendService, computed as weight /
               (sum of all weightedBackendService weights in routeAction) . The selection of a
               backend service is determined only for new traffic. Once a user's request has
               been directed to a backendService, subsequent requests will be sent to the same
               backendService as determined by the BackendService's session affinity policy.
               The value must be between 0 and 1000
        :param pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionArgs'] header_action: Specifies changes to request and response headers that need to take effect for
               the selected backendService. headerAction specified here take effect before
               headerAction in the enclosing HttpRouteRule, PathMatcher and UrlMap.
               Structure is documented below.
        """
        pulumi.set(__self__, "backend_service", backend_service)
        pulumi.set(__self__, "weight", weight)
        if header_action is not None:
            pulumi.set(__self__, "header_action", header_action)

    @property
    @pulumi.getter(name="backendService")
    def backend_service(self) -> pulumi.Input[str]:
        """
        The default RegionBackendService resource. Before
        forwarding the request to backendService, the loadbalancer applies any relevant
        headerActions specified as part of this backendServiceWeight.
        """
        return pulumi.get(self, "backend_service")

    @backend_service.setter
    def backend_service(self, value: pulumi.Input[str]):
        pulumi.set(self, "backend_service", value)

    @property
    @pulumi.getter
    def weight(self) -> pulumi.Input[int]:
        """
        Specifies the fraction of traffic sent to backendService, computed as weight /
        (sum of all weightedBackendService weights in routeAction) . The selection of a
        backend service is determined only for new traffic. Once a user's request has
        been directed to a backendService, subsequent requests will be sent to the same
        backendService as determined by the BackendService's session affinity policy.
        The value must be between 0 and 1000
        """
        return pulumi.get(self, "weight")

    @weight.setter
    def weight(self, value: pulumi.Input[int]):
        pulumi.set(self, "weight", value)

    @property
    @pulumi.getter(name="headerAction")
    def header_action(self) -> Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionArgs']]:
        """
        Specifies changes to request and response headers that need to take effect for
        the selected backendService. headerAction specified here take effect before
        headerAction in the enclosing HttpRouteRule, PathMatcher and UrlMap.
        Structure is documented below.
        """
        return pulumi.get(self, "header_action")

    @header_action.setter
    def header_action(self, value: Optional[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionArgs']]):
        pulumi.set(self, "header_action", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionArgs:
    def __init__(__self__, *,
                 request_headers_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]]] = None,
                 request_headers_to_removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 response_headers_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]]] = None,
                 response_headers_to_removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]] request_headers_to_adds: Headers to add to a matching request prior to forwarding the request to the
               backendService.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] request_headers_to_removes: A list of header names for headers that need to be removed from the request
               prior to forwarding the request to the backendService.
        :param pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]] response_headers_to_adds: Headers to add the response prior to sending the response back to the client.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] response_headers_to_removes: A list of header names for headers that need to be removed from the response
               prior to sending the response back to the client.
        """
        if request_headers_to_adds is not None:
            pulumi.set(__self__, "request_headers_to_adds", request_headers_to_adds)
        if request_headers_to_removes is not None:
            pulumi.set(__self__, "request_headers_to_removes", request_headers_to_removes)
        if response_headers_to_adds is not None:
            pulumi.set(__self__, "response_headers_to_adds", response_headers_to_adds)
        if response_headers_to_removes is not None:
            pulumi.set(__self__, "response_headers_to_removes", response_headers_to_removes)

    @property
    @pulumi.getter(name="requestHeadersToAdds")
    def request_headers_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]]]:
        """
        Headers to add to a matching request prior to forwarding the request to the
        backendService.
        Structure is documented below.
        """
        return pulumi.get(self, "request_headers_to_adds")

    @request_headers_to_adds.setter
    def request_headers_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]]]):
        pulumi.set(self, "request_headers_to_adds", value)

    @property
    @pulumi.getter(name="requestHeadersToRemoves")
    def request_headers_to_removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of header names for headers that need to be removed from the request
        prior to forwarding the request to the backendService.
        """
        return pulumi.get(self, "request_headers_to_removes")

    @request_headers_to_removes.setter
    def request_headers_to_removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "request_headers_to_removes", value)

    @property
    @pulumi.getter(name="responseHeadersToAdds")
    def response_headers_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]]]:
        """
        Headers to add the response prior to sending the response back to the client.
        Structure is documented below.
        """
        return pulumi.get(self, "response_headers_to_adds")

    @response_headers_to_adds.setter
    def response_headers_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]]]):
        pulumi.set(self, "response_headers_to_adds", value)

    @property
    @pulumi.getter(name="responseHeadersToRemoves")
    def response_headers_to_removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of header names for headers that need to be removed from the response
        prior to sending the response back to the client.
        """
        return pulumi.get(self, "response_headers_to_removes")

    @response_headers_to_removes.setter
    def response_headers_to_removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "response_headers_to_removes", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 header_value: pulumi.Input[str],
                 replace: pulumi.Input[bool]):
        """
        :param pulumi.Input[str] header_name: The name of the header.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: If false, headerValue is appended to any values that already exist for the
               header. If true, headerValue is set for the header, discarding any values that
               were set for that header.
        """
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)
        pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The name of the header.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> pulumi.Input[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> pulumi.Input[bool]:
        """
        If false, headerValue is appended to any values that already exist for the
        header. If true, headerValue is set for the header, discarding any values that
        were set for that header.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: pulumi.Input[bool]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 header_value: pulumi.Input[str],
                 replace: pulumi.Input[bool]):
        """
        :param pulumi.Input[str] header_name: The name of the header.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: If false, headerValue is appended to any values that already exist for the
               header. If true, headerValue is set for the header, discarding any values that
               were set for that header.
        """
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)
        pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The name of the header.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> pulumi.Input[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> pulumi.Input[bool]:
        """
        If false, headerValue is appended to any values that already exist for the
        header. If true, headerValue is set for the header, discarding any values that
        were set for that header.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: pulumi.Input[bool]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class RegionUrlMapPathMatcherRouteRuleUrlRedirectArgs:
    def __init__(__self__, *,
                 host_redirect: Optional[pulumi.Input[str]] = None,
                 https_redirect: Optional[pulumi.Input[bool]] = None,
                 path_redirect: Optional[pulumi.Input[str]] = None,
                 prefix_redirect: Optional[pulumi.Input[str]] = None,
                 redirect_response_code: Optional[pulumi.Input[str]] = None,
                 strip_query: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] host_redirect: The host that will be used in the redirect response instead of the one that was
               supplied in the request. The value must be between 1 and 255 characters.
        :param pulumi.Input[bool] https_redirect: If set to true, the URL scheme in the redirected request is set to https. If set to
               false, the URL scheme of the redirected request will remain the same as that of the
               request. This must only be set for UrlMaps used in TargetHttpProxys. Setting this
               true for TargetHttpsProxy is not permitted. The default is set to false.
        :param pulumi.Input[str] path_redirect: The path that will be used in the redirect response instead of the one that was
               supplied in the request. pathRedirect cannot be supplied together with
               prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the
               original request will be used for the redirect. The value must be between 1 and 1024
               characters.
        :param pulumi.Input[str] prefix_redirect: The prefix that replaces the prefixMatch specified in the HttpRouteRuleMatch,
               retaining the remaining portion of the URL before redirecting the request.
               prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or
               neither. If neither is supplied, the path of the original request will be used for
               the redirect. The value must be between 1 and 1024 characters.
        :param pulumi.Input[str] redirect_response_code: The HTTP Status code to use for this RedirectAction. Supported values are:
               * MOVED_PERMANENTLY_DEFAULT, which is the default value and corresponds to 301.
               * FOUND, which corresponds to 302.
               * SEE_OTHER which corresponds to 303.
               * TEMPORARY_REDIRECT, which corresponds to 307. In this case, the request method
               will be retained.
               * PERMANENT_REDIRECT, which corresponds to 308. In this case,
               the request method will be retained.
        :param pulumi.Input[bool] strip_query: If set to true, any accompanying query portion of the original URL is removed prior
               to redirecting the request. If set to false, the query portion of the original URL is
               retained.
               This field is required to ensure an empty block is not set. The normal default value is false.
        """
        if host_redirect is not None:
            pulumi.set(__self__, "host_redirect", host_redirect)
        if https_redirect is not None:
            pulumi.set(__self__, "https_redirect", https_redirect)
        if path_redirect is not None:
            pulumi.set(__self__, "path_redirect", path_redirect)
        if prefix_redirect is not None:
            pulumi.set(__self__, "prefix_redirect", prefix_redirect)
        if redirect_response_code is not None:
            pulumi.set(__self__, "redirect_response_code", redirect_response_code)
        if strip_query is not None:
            pulumi.set(__self__, "strip_query", strip_query)

    @property
    @pulumi.getter(name="hostRedirect")
    def host_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The host that will be used in the redirect response instead of the one that was
        supplied in the request. The value must be between 1 and 255 characters.
        """
        return pulumi.get(self, "host_redirect")

    @host_redirect.setter
    def host_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_redirect", value)

    @property
    @pulumi.getter(name="httpsRedirect")
    def https_redirect(self) -> Optional[pulumi.Input[bool]]:
        """
        If set to true, the URL scheme in the redirected request is set to https. If set to
        false, the URL scheme of the redirected request will remain the same as that of the
        request. This must only be set for UrlMaps used in TargetHttpProxys. Setting this
        true for TargetHttpsProxy is not permitted. The default is set to false.
        """
        return pulumi.get(self, "https_redirect")

    @https_redirect.setter
    def https_redirect(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "https_redirect", value)

    @property
    @pulumi.getter(name="pathRedirect")
    def path_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The path that will be used in the redirect response instead of the one that was
        supplied in the request. pathRedirect cannot be supplied together with
        prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the
        original request will be used for the redirect. The value must be between 1 and 1024
        characters.
        """
        return pulumi.get(self, "path_redirect")

    @path_redirect.setter
    def path_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path_redirect", value)

    @property
    @pulumi.getter(name="prefixRedirect")
    def prefix_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The prefix that replaces the prefixMatch specified in the HttpRouteRuleMatch,
        retaining the remaining portion of the URL before redirecting the request.
        prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or
        neither. If neither is supplied, the path of the original request will be used for
        the redirect. The value must be between 1 and 1024 characters.
        """
        return pulumi.get(self, "prefix_redirect")

    @prefix_redirect.setter
    def prefix_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "prefix_redirect", value)

    @property
    @pulumi.getter(name="redirectResponseCode")
    def redirect_response_code(self) -> Optional[pulumi.Input[str]]:
        """
        The HTTP Status code to use for this RedirectAction. Supported values are:
        * MOVED_PERMANENTLY_DEFAULT, which is the default value and corresponds to 301.
        * FOUND, which corresponds to 302.
        * SEE_OTHER which corresponds to 303.
        * TEMPORARY_REDIRECT, which corresponds to 307. In this case, the request method
        will be retained.
        * PERMANENT_REDIRECT, which corresponds to 308. In this case,
        the request method will be retained.
        """
        return pulumi.get(self, "redirect_response_code")

    @redirect_response_code.setter
    def redirect_response_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "redirect_response_code", value)

    @property
    @pulumi.getter(name="stripQuery")
    def strip_query(self) -> Optional[pulumi.Input[bool]]:
        """
        If set to true, any accompanying query portion of the original URL is removed prior
        to redirecting the request. If set to false, the query portion of the original URL is
        retained.
        This field is required to ensure an empty block is not set. The normal default value is false.
        """
        return pulumi.get(self, "strip_query")

    @strip_query.setter
    def strip_query(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "strip_query", value)


@pulumi.input_type
class RegionUrlMapTestArgs:
    def __init__(__self__, *,
                 host: pulumi.Input[str],
                 path: pulumi.Input[str],
                 service: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host: Host portion of the URL.
        :param pulumi.Input[str] path: Path portion of the URL.
        :param pulumi.Input[str] service: A reference to expected RegionBackendService resource the given URL should be mapped to.
        :param pulumi.Input[str] description: Description of this test case.
        """
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "service", service)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def host(self) -> pulumi.Input[str]:
        """
        Host portion of the URL.
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: pulumi.Input[str]):
        pulumi.set(self, "host", value)

    @property
    @pulumi.getter
    def path(self) -> pulumi.Input[str]:
        """
        Path portion of the URL.
        """
        return pulumi.get(self, "path")

    @path.setter
    def path(self, value: pulumi.Input[str]):
        pulumi.set(self, "path", value)

    @property
    @pulumi.getter
    def service(self) -> pulumi.Input[str]:
        """
        A reference to expected RegionBackendService resource the given URL should be mapped to.
        """
        return pulumi.get(self, "service")

    @service.setter
    def service(self, value: pulumi.Input[str]):
        pulumi.set(self, "service", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        Description of this test case.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class ReservationShareSettingsArgs:
    def __init__(__self__, *,
                 project_maps: Optional[pulumi.Input[Sequence[pulumi.Input['ReservationShareSettingsProjectMapArgs']]]] = None,
                 share_type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ReservationShareSettingsProjectMapArgs']]] project_maps: A map of project number and project config. This is only valid when shareType's value is SPECIFIC_PROJECTS.
               Structure is documented below.
        :param pulumi.Input[str] share_type: Type of sharing for this shared-reservation
               Possible values are `LOCAL` and `SPECIFIC_PROJECTS`.
        """
        if project_maps is not None:
            pulumi.set(__self__, "project_maps", project_maps)
        if share_type is not None:
            pulumi.set(__self__, "share_type", share_type)

    @property
    @pulumi.getter(name="projectMaps")
    def project_maps(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ReservationShareSettingsProjectMapArgs']]]]:
        """
        A map of project number and project config. This is only valid when shareType's value is SPECIFIC_PROJECTS.
        Structure is documented below.
        """
        return pulumi.get(self, "project_maps")

    @project_maps.setter
    def project_maps(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ReservationShareSettingsProjectMapArgs']]]]):
        pulumi.set(self, "project_maps", value)

    @property
    @pulumi.getter(name="shareType")
    def share_type(self) -> Optional[pulumi.Input[str]]:
        """
        Type of sharing for this shared-reservation
        Possible values are `LOCAL` and `SPECIFIC_PROJECTS`.
        """
        return pulumi.get(self, "share_type")

    @share_type.setter
    def share_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "share_type", value)


@pulumi.input_type
class ReservationShareSettingsProjectMapArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str],
                 project_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] id: The identifier for this object. Format specified above.
        :param pulumi.Input[str] project_id: The project id/number, should be same as the key of this project config in the project map.
        """
        pulumi.set(__self__, "id", id)
        if project_id is not None:
            pulumi.set(__self__, "project_id", project_id)

    @property
    @pulumi.getter
    def id(self) -> pulumi.Input[str]:
        """
        The identifier for this object. Format specified above.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> Optional[pulumi.Input[str]]:
        """
        The project id/number, should be same as the key of this project config in the project map.
        """
        return pulumi.get(self, "project_id")

    @project_id.setter
    def project_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "project_id", value)


@pulumi.input_type
class ReservationSpecificReservationArgs:
    def __init__(__self__, *,
                 count: pulumi.Input[int],
                 instance_properties: pulumi.Input['ReservationSpecificReservationInstancePropertiesArgs'],
                 in_use_count: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] count: The number of resources that are allocated.
        :param pulumi.Input['ReservationSpecificReservationInstancePropertiesArgs'] instance_properties: The instance properties for the reservation.
               Structure is documented below.
        :param pulumi.Input[int] in_use_count: -
               How many instances are in use.
        """
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "instance_properties", instance_properties)
        if in_use_count is not None:
            pulumi.set(__self__, "in_use_count", in_use_count)

    @property
    @pulumi.getter
    def count(self) -> pulumi.Input[int]:
        """
        The number of resources that are allocated.
        """
        return pulumi.get(self, "count")

    @count.setter
    def count(self, value: pulumi.Input[int]):
        pulumi.set(self, "count", value)

    @property
    @pulumi.getter(name="instanceProperties")
    def instance_properties(self) -> pulumi.Input['ReservationSpecificReservationInstancePropertiesArgs']:
        """
        The instance properties for the reservation.
        Structure is documented below.
        """
        return pulumi.get(self, "instance_properties")

    @instance_properties.setter
    def instance_properties(self, value: pulumi.Input['ReservationSpecificReservationInstancePropertiesArgs']):
        pulumi.set(self, "instance_properties", value)

    @property
    @pulumi.getter(name="inUseCount")
    def in_use_count(self) -> Optional[pulumi.Input[int]]:
        """
        -
        How many instances are in use.
        """
        return pulumi.get(self, "in_use_count")

    @in_use_count.setter
    def in_use_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "in_use_count", value)


@pulumi.input_type
class ReservationSpecificReservationInstancePropertiesArgs:
    def __init__(__self__, *,
                 machine_type: pulumi.Input[str],
                 guest_accelerators: Optional[pulumi.Input[Sequence[pulumi.Input['ReservationSpecificReservationInstancePropertiesGuestAcceleratorArgs']]]] = None,
                 local_ssds: Optional[pulumi.Input[Sequence[pulumi.Input['ReservationSpecificReservationInstancePropertiesLocalSsdArgs']]]] = None,
                 min_cpu_platform: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] machine_type: The name of the machine type to reserve.
        :param pulumi.Input[Sequence[pulumi.Input['ReservationSpecificReservationInstancePropertiesGuestAcceleratorArgs']]] guest_accelerators: Guest accelerator type and count.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['ReservationSpecificReservationInstancePropertiesLocalSsdArgs']]] local_ssds: The amount of local ssd to reserve with each instance. This
               reserves disks of type `local-ssd`.
               Structure is documented below.
        :param pulumi.Input[str] min_cpu_platform: The minimum CPU platform for the reservation. For example,
               `"Intel Skylake"`. See
               the CPU platform availability reference](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform#availablezones)
               for information on available CPU platforms.
        """
        pulumi.set(__self__, "machine_type", machine_type)
        if guest_accelerators is not None:
            pulumi.set(__self__, "guest_accelerators", guest_accelerators)
        if local_ssds is not None:
            pulumi.set(__self__, "local_ssds", local_ssds)
        if min_cpu_platform is not None:
            pulumi.set(__self__, "min_cpu_platform", min_cpu_platform)

    @property
    @pulumi.getter(name="machineType")
    def machine_type(self) -> pulumi.Input[str]:
        """
        The name of the machine type to reserve.
        """
        return pulumi.get(self, "machine_type")

    @machine_type.setter
    def machine_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "machine_type", value)

    @property
    @pulumi.getter(name="guestAccelerators")
    def guest_accelerators(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ReservationSpecificReservationInstancePropertiesGuestAcceleratorArgs']]]]:
        """
        Guest accelerator type and count.
        Structure is documented below.
        """
        return pulumi.get(self, "guest_accelerators")

    @guest_accelerators.setter
    def guest_accelerators(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ReservationSpecificReservationInstancePropertiesGuestAcceleratorArgs']]]]):
        pulumi.set(self, "guest_accelerators", value)

    @property
    @pulumi.getter(name="localSsds")
    def local_ssds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ReservationSpecificReservationInstancePropertiesLocalSsdArgs']]]]:
        """
        The amount of local ssd to reserve with each instance. This
        reserves disks of type `local-ssd`.
        Structure is documented below.
        """
        return pulumi.get(self, "local_ssds")

    @local_ssds.setter
    def local_ssds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ReservationSpecificReservationInstancePropertiesLocalSsdArgs']]]]):
        pulumi.set(self, "local_ssds", value)

    @property
    @pulumi.getter(name="minCpuPlatform")
    def min_cpu_platform(self) -> Optional[pulumi.Input[str]]:
        """
        The minimum CPU platform for the reservation. For example,
        `"Intel Skylake"`. See
        the CPU platform availability reference](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform#availablezones)
        for information on available CPU platforms.
        """
        return pulumi.get(self, "min_cpu_platform")

    @min_cpu_platform.setter
    def min_cpu_platform(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "min_cpu_platform", value)


@pulumi.input_type
class ReservationSpecificReservationInstancePropertiesGuestAcceleratorArgs:
    def __init__(__self__, *,
                 accelerator_count: pulumi.Input[int],
                 accelerator_type: pulumi.Input[str]):
        """
        :param pulumi.Input[int] accelerator_count: The number of the guest accelerator cards exposed to
               this instance.
        :param pulumi.Input[str] accelerator_type: The full or partial URL of the accelerator type to
               attach to this instance. For example:
               `projects/my-project/zones/us-central1-c/acceleratorTypes/nvidia-tesla-p100`
               If you are creating an instance template, specify only the accelerator name.
        """
        pulumi.set(__self__, "accelerator_count", accelerator_count)
        pulumi.set(__self__, "accelerator_type", accelerator_type)

    @property
    @pulumi.getter(name="acceleratorCount")
    def accelerator_count(self) -> pulumi.Input[int]:
        """
        The number of the guest accelerator cards exposed to
        this instance.
        """
        return pulumi.get(self, "accelerator_count")

    @accelerator_count.setter
    def accelerator_count(self, value: pulumi.Input[int]):
        pulumi.set(self, "accelerator_count", value)

    @property
    @pulumi.getter(name="acceleratorType")
    def accelerator_type(self) -> pulumi.Input[str]:
        """
        The full or partial URL of the accelerator type to
        attach to this instance. For example:
        `projects/my-project/zones/us-central1-c/acceleratorTypes/nvidia-tesla-p100`
        If you are creating an instance template, specify only the accelerator name.
        """
        return pulumi.get(self, "accelerator_type")

    @accelerator_type.setter
    def accelerator_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "accelerator_type", value)


@pulumi.input_type
class ReservationSpecificReservationInstancePropertiesLocalSsdArgs:
    def __init__(__self__, *,
                 disk_size_gb: pulumi.Input[int],
                 interface: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] disk_size_gb: The size of the disk in base-2 GB.
        :param pulumi.Input[str] interface: The disk interface to use for attaching this disk.
               Default value is `SCSI`.
               Possible values are `SCSI` and `NVME`.
        """
        pulumi.set(__self__, "disk_size_gb", disk_size_gb)
        if interface is not None:
            pulumi.set(__self__, "interface", interface)

    @property
    @pulumi.getter(name="diskSizeGb")
    def disk_size_gb(self) -> pulumi.Input[int]:
        """
        The size of the disk in base-2 GB.
        """
        return pulumi.get(self, "disk_size_gb")

    @disk_size_gb.setter
    def disk_size_gb(self, value: pulumi.Input[int]):
        pulumi.set(self, "disk_size_gb", value)

    @property
    @pulumi.getter
    def interface(self) -> Optional[pulumi.Input[str]]:
        """
        The disk interface to use for attaching this disk.
        Default value is `SCSI`.
        Possible values are `SCSI` and `NVME`.
        """
        return pulumi.get(self, "interface")

    @interface.setter
    def interface(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "interface", value)


@pulumi.input_type
class ResourcePolicyGroupPlacementPolicyArgs:
    def __init__(__self__, *,
                 availability_domain_count: Optional[pulumi.Input[int]] = None,
                 collocation: Optional[pulumi.Input[str]] = None,
                 vm_count: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] availability_domain_count: The number of availability domains instances will be spread across. If two instances are in different
               availability domain, they will not be put in the same low latency network
        :param pulumi.Input[str] collocation: Collocation specifies whether to place VMs inside the same availability domain on the same low-latency network.
               Specify `COLLOCATED` to enable collocation. Can only be specified with `vm_count`. If compute instances are created
               with a COLLOCATED policy, then exactly `vm_count` instances must be created at the same time with the resource policy
               attached.
               Possible values are `COLLOCATED`.
        :param pulumi.Input[int] vm_count: Number of VMs in this placement group. Google does not recommend that you use this field
               unless you use a compact policy and you want your policy to work only if it contains this
               exact number of VMs.
        """
        if availability_domain_count is not None:
            pulumi.set(__self__, "availability_domain_count", availability_domain_count)
        if collocation is not None:
            pulumi.set(__self__, "collocation", collocation)
        if vm_count is not None:
            pulumi.set(__self__, "vm_count", vm_count)

    @property
    @pulumi.getter(name="availabilityDomainCount")
    def availability_domain_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of availability domains instances will be spread across. If two instances are in different
        availability domain, they will not be put in the same low latency network
        """
        return pulumi.get(self, "availability_domain_count")

    @availability_domain_count.setter
    def availability_domain_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "availability_domain_count", value)

    @property
    @pulumi.getter
    def collocation(self) -> Optional[pulumi.Input[str]]:
        """
        Collocation specifies whether to place VMs inside the same availability domain on the same low-latency network.
        Specify `COLLOCATED` to enable collocation. Can only be specified with `vm_count`. If compute instances are created
        with a COLLOCATED policy, then exactly `vm_count` instances must be created at the same time with the resource policy
        attached.
        Possible values are `COLLOCATED`.
        """
        return pulumi.get(self, "collocation")

    @collocation.setter
    def collocation(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "collocation", value)

    @property
    @pulumi.getter(name="vmCount")
    def vm_count(self) -> Optional[pulumi.Input[int]]:
        """
        Number of VMs in this placement group. Google does not recommend that you use this field
        unless you use a compact policy and you want your policy to work only if it contains this
        exact number of VMs.
        """
        return pulumi.get(self, "vm_count")

    @vm_count.setter
    def vm_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "vm_count", value)


@pulumi.input_type
class ResourcePolicyInstanceSchedulePolicyArgs:
    def __init__(__self__, *,
                 time_zone: pulumi.Input[str],
                 expiration_time: Optional[pulumi.Input[str]] = None,
                 start_time: Optional[pulumi.Input[str]] = None,
                 vm_start_schedule: Optional[pulumi.Input['ResourcePolicyInstanceSchedulePolicyVmStartScheduleArgs']] = None,
                 vm_stop_schedule: Optional[pulumi.Input['ResourcePolicyInstanceSchedulePolicyVmStopScheduleArgs']] = None):
        """
        :param pulumi.Input[str] time_zone: Specifies the time zone to be used in interpreting the schedule. The value of this field must be a time zone name
               from the tz database: http://en.wikipedia.org/wiki/Tz_database.
        :param pulumi.Input[str] expiration_time: The expiration time of the schedule. The timestamp is an RFC3339 string.
        :param pulumi.Input[str] start_time: The start time of the schedule. The timestamp is an RFC3339 string.
        :param pulumi.Input['ResourcePolicyInstanceSchedulePolicyVmStartScheduleArgs'] vm_start_schedule: Specifies the schedule for starting instances.
               Structure is documented below.
        :param pulumi.Input['ResourcePolicyInstanceSchedulePolicyVmStopScheduleArgs'] vm_stop_schedule: Specifies the schedule for stopping instances.
               Structure is documented below.
        """
        pulumi.set(__self__, "time_zone", time_zone)
        if expiration_time is not None:
            pulumi.set(__self__, "expiration_time", expiration_time)
        if start_time is not None:
            pulumi.set(__self__, "start_time", start_time)
        if vm_start_schedule is not None:
            pulumi.set(__self__, "vm_start_schedule", vm_start_schedule)
        if vm_stop_schedule is not None:
            pulumi.set(__self__, "vm_stop_schedule", vm_stop_schedule)

    @property
    @pulumi.getter(name="timeZone")
    def time_zone(self) -> pulumi.Input[str]:
        """
        Specifies the time zone to be used in interpreting the schedule. The value of this field must be a time zone name
        from the tz database: http://en.wikipedia.org/wiki/Tz_database.
        """
        return pulumi.get(self, "time_zone")

    @time_zone.setter
    def time_zone(self, value: pulumi.Input[str]):
        pulumi.set(self, "time_zone", value)

    @property
    @pulumi.getter(name="expirationTime")
    def expiration_time(self) -> Optional[pulumi.Input[str]]:
        """
        The expiration time of the schedule. The timestamp is an RFC3339 string.
        """
        return pulumi.get(self, "expiration_time")

    @expiration_time.setter
    def expiration_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "expiration_time", value)

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> Optional[pulumi.Input[str]]:
        """
        The start time of the schedule. The timestamp is an RFC3339 string.
        """
        return pulumi.get(self, "start_time")

    @start_time.setter
    def start_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "start_time", value)

    @property
    @pulumi.getter(name="vmStartSchedule")
    def vm_start_schedule(self) -> Optional[pulumi.Input['ResourcePolicyInstanceSchedulePolicyVmStartScheduleArgs']]:
        """
        Specifies the schedule for starting instances.
        Structure is documented below.
        """
        return pulumi.get(self, "vm_start_schedule")

    @vm_start_schedule.setter
    def vm_start_schedule(self, value: Optional[pulumi.Input['ResourcePolicyInstanceSchedulePolicyVmStartScheduleArgs']]):
        pulumi.set(self, "vm_start_schedule", value)

    @property
    @pulumi.getter(name="vmStopSchedule")
    def vm_stop_schedule(self) -> Optional[pulumi.Input['ResourcePolicyInstanceSchedulePolicyVmStopScheduleArgs']]:
        """
        Specifies the schedule for stopping instances.
        Structure is documented below.
        """
        return pulumi.get(self, "vm_stop_schedule")

    @vm_stop_schedule.setter
    def vm_stop_schedule(self, value: Optional[pulumi.Input['ResourcePolicyInstanceSchedulePolicyVmStopScheduleArgs']]):
        pulumi.set(self, "vm_stop_schedule", value)


@pulumi.input_type
class ResourcePolicyInstanceSchedulePolicyVmStartScheduleArgs:
    def __init__(__self__, *,
                 schedule: pulumi.Input[str]):
        """
        :param pulumi.Input[str] schedule: Specifies the frequency for the operation, using the unix-cron format.
        """
        pulumi.set(__self__, "schedule", schedule)

    @property
    @pulumi.getter
    def schedule(self) -> pulumi.Input[str]:
        """
        Specifies the frequency for the operation, using the unix-cron format.
        """
        return pulumi.get(self, "schedule")

    @schedule.setter
    def schedule(self, value: pulumi.Input[str]):
        pulumi.set(self, "schedule", value)


@pulumi.input_type
class ResourcePolicyInstanceSchedulePolicyVmStopScheduleArgs:
    def __init__(__self__, *,
                 schedule: pulumi.Input[str]):
        """
        :param pulumi.Input[str] schedule: Specifies the frequency for the operation, using the unix-cron format.
        """
        pulumi.set(__self__, "schedule", schedule)

    @property
    @pulumi.getter
    def schedule(self) -> pulumi.Input[str]:
        """
        Specifies the frequency for the operation, using the unix-cron format.
        """
        return pulumi.get(self, "schedule")

    @schedule.setter
    def schedule(self, value: pulumi.Input[str]):
        pulumi.set(self, "schedule", value)


@pulumi.input_type
class ResourcePolicySnapshotSchedulePolicyArgs:
    def __init__(__self__, *,
                 schedule: pulumi.Input['ResourcePolicySnapshotSchedulePolicyScheduleArgs'],
                 retention_policy: Optional[pulumi.Input['ResourcePolicySnapshotSchedulePolicyRetentionPolicyArgs']] = None,
                 snapshot_properties: Optional[pulumi.Input['ResourcePolicySnapshotSchedulePolicySnapshotPropertiesArgs']] = None):
        """
        :param pulumi.Input['ResourcePolicySnapshotSchedulePolicyScheduleArgs'] schedule: Specifies the frequency for the operation, using the unix-cron format.
        :param pulumi.Input['ResourcePolicySnapshotSchedulePolicyRetentionPolicyArgs'] retention_policy: Retention policy applied to snapshots created by this resource policy.
               Structure is documented below.
        :param pulumi.Input['ResourcePolicySnapshotSchedulePolicySnapshotPropertiesArgs'] snapshot_properties: Properties with which the snapshots are created, such as labels.
               Structure is documented below.
        """
        pulumi.set(__self__, "schedule", schedule)
        if retention_policy is not None:
            pulumi.set(__self__, "retention_policy", retention_policy)
        if snapshot_properties is not None:
            pulumi.set(__self__, "snapshot_properties", snapshot_properties)

    @property
    @pulumi.getter
    def schedule(self) -> pulumi.Input['ResourcePolicySnapshotSchedulePolicyScheduleArgs']:
        """
        Specifies the frequency for the operation, using the unix-cron format.
        """
        return pulumi.get(self, "schedule")

    @schedule.setter
    def schedule(self, value: pulumi.Input['ResourcePolicySnapshotSchedulePolicyScheduleArgs']):
        pulumi.set(self, "schedule", value)

    @property
    @pulumi.getter(name="retentionPolicy")
    def retention_policy(self) -> Optional[pulumi.Input['ResourcePolicySnapshotSchedulePolicyRetentionPolicyArgs']]:
        """
        Retention policy applied to snapshots created by this resource policy.
        Structure is documented below.
        """
        return pulumi.get(self, "retention_policy")

    @retention_policy.setter
    def retention_policy(self, value: Optional[pulumi.Input['ResourcePolicySnapshotSchedulePolicyRetentionPolicyArgs']]):
        pulumi.set(self, "retention_policy", value)

    @property
    @pulumi.getter(name="snapshotProperties")
    def snapshot_properties(self) -> Optional[pulumi.Input['ResourcePolicySnapshotSchedulePolicySnapshotPropertiesArgs']]:
        """
        Properties with which the snapshots are created, such as labels.
        Structure is documented below.
        """
        return pulumi.get(self, "snapshot_properties")

    @snapshot_properties.setter
    def snapshot_properties(self, value: Optional[pulumi.Input['ResourcePolicySnapshotSchedulePolicySnapshotPropertiesArgs']]):
        pulumi.set(self, "snapshot_properties", value)


@pulumi.input_type
class ResourcePolicySnapshotSchedulePolicyRetentionPolicyArgs:
    def __init__(__self__, *,
                 max_retention_days: pulumi.Input[int],
                 on_source_disk_delete: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] max_retention_days: Maximum age of the snapshot that is allowed to be kept.
        :param pulumi.Input[str] on_source_disk_delete: Specifies the behavior to apply to scheduled snapshots when
               the source disk is deleted.
               Default value is `KEEP_AUTO_SNAPSHOTS`.
               Possible values are `KEEP_AUTO_SNAPSHOTS` and `APPLY_RETENTION_POLICY`.
        """
        pulumi.set(__self__, "max_retention_days", max_retention_days)
        if on_source_disk_delete is not None:
            pulumi.set(__self__, "on_source_disk_delete", on_source_disk_delete)

    @property
    @pulumi.getter(name="maxRetentionDays")
    def max_retention_days(self) -> pulumi.Input[int]:
        """
        Maximum age of the snapshot that is allowed to be kept.
        """
        return pulumi.get(self, "max_retention_days")

    @max_retention_days.setter
    def max_retention_days(self, value: pulumi.Input[int]):
        pulumi.set(self, "max_retention_days", value)

    @property
    @pulumi.getter(name="onSourceDiskDelete")
    def on_source_disk_delete(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the behavior to apply to scheduled snapshots when
        the source disk is deleted.
        Default value is `KEEP_AUTO_SNAPSHOTS`.
        Possible values are `KEEP_AUTO_SNAPSHOTS` and `APPLY_RETENTION_POLICY`.
        """
        return pulumi.get(self, "on_source_disk_delete")

    @on_source_disk_delete.setter
    def on_source_disk_delete(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "on_source_disk_delete", value)


@pulumi.input_type
class ResourcePolicySnapshotSchedulePolicyScheduleArgs:
    def __init__(__self__, *,
                 daily_schedule: Optional[pulumi.Input['ResourcePolicySnapshotSchedulePolicyScheduleDailyScheduleArgs']] = None,
                 hourly_schedule: Optional[pulumi.Input['ResourcePolicySnapshotSchedulePolicyScheduleHourlyScheduleArgs']] = None,
                 weekly_schedule: Optional[pulumi.Input['ResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleArgs']] = None):
        """
        :param pulumi.Input['ResourcePolicySnapshotSchedulePolicyScheduleDailyScheduleArgs'] daily_schedule: The policy will execute every nth day at the specified time.
               Structure is documented below.
        :param pulumi.Input['ResourcePolicySnapshotSchedulePolicyScheduleHourlyScheduleArgs'] hourly_schedule: The policy will execute every nth hour starting at the specified time.
               Structure is documented below.
        :param pulumi.Input['ResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleArgs'] weekly_schedule: Allows specifying a snapshot time for each day of the week.
               Structure is documented below.
        """
        if daily_schedule is not None:
            pulumi.set(__self__, "daily_schedule", daily_schedule)
        if hourly_schedule is not None:
            pulumi.set(__self__, "hourly_schedule", hourly_schedule)
        if weekly_schedule is not None:
            pulumi.set(__self__, "weekly_schedule", weekly_schedule)

    @property
    @pulumi.getter(name="dailySchedule")
    def daily_schedule(self) -> Optional[pulumi.Input['ResourcePolicySnapshotSchedulePolicyScheduleDailyScheduleArgs']]:
        """
        The policy will execute every nth day at the specified time.
        Structure is documented below.
        """
        return pulumi.get(self, "daily_schedule")

    @daily_schedule.setter
    def daily_schedule(self, value: Optional[pulumi.Input['ResourcePolicySnapshotSchedulePolicyScheduleDailyScheduleArgs']]):
        pulumi.set(self, "daily_schedule", value)

    @property
    @pulumi.getter(name="hourlySchedule")
    def hourly_schedule(self) -> Optional[pulumi.Input['ResourcePolicySnapshotSchedulePolicyScheduleHourlyScheduleArgs']]:
        """
        The policy will execute every nth hour starting at the specified time.
        Structure is documented below.
        """
        return pulumi.get(self, "hourly_schedule")

    @hourly_schedule.setter
    def hourly_schedule(self, value: Optional[pulumi.Input['ResourcePolicySnapshotSchedulePolicyScheduleHourlyScheduleArgs']]):
        pulumi.set(self, "hourly_schedule", value)

    @property
    @pulumi.getter(name="weeklySchedule")
    def weekly_schedule(self) -> Optional[pulumi.Input['ResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleArgs']]:
        """
        Allows specifying a snapshot time for each day of the week.
        Structure is documented below.
        """
        return pulumi.get(self, "weekly_schedule")

    @weekly_schedule.setter
    def weekly_schedule(self, value: Optional[pulumi.Input['ResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleArgs']]):
        pulumi.set(self, "weekly_schedule", value)


@pulumi.input_type
class ResourcePolicySnapshotSchedulePolicyScheduleDailyScheduleArgs:
    def __init__(__self__, *,
                 days_in_cycle: pulumi.Input[int],
                 start_time: pulumi.Input[str]):
        """
        :param pulumi.Input[int] days_in_cycle: The number of days between snapshots.
        :param pulumi.Input[str] start_time: The start time of the schedule. The timestamp is an RFC3339 string.
        """
        pulumi.set(__self__, "days_in_cycle", days_in_cycle)
        pulumi.set(__self__, "start_time", start_time)

    @property
    @pulumi.getter(name="daysInCycle")
    def days_in_cycle(self) -> pulumi.Input[int]:
        """
        The number of days between snapshots.
        """
        return pulumi.get(self, "days_in_cycle")

    @days_in_cycle.setter
    def days_in_cycle(self, value: pulumi.Input[int]):
        pulumi.set(self, "days_in_cycle", value)

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> pulumi.Input[str]:
        """
        The start time of the schedule. The timestamp is an RFC3339 string.
        """
        return pulumi.get(self, "start_time")

    @start_time.setter
    def start_time(self, value: pulumi.Input[str]):
        pulumi.set(self, "start_time", value)


@pulumi.input_type
class ResourcePolicySnapshotSchedulePolicyScheduleHourlyScheduleArgs:
    def __init__(__self__, *,
                 hours_in_cycle: pulumi.Input[int],
                 start_time: pulumi.Input[str]):
        """
        :param pulumi.Input[int] hours_in_cycle: The number of hours between snapshots.
        :param pulumi.Input[str] start_time: The start time of the schedule. The timestamp is an RFC3339 string.
        """
        pulumi.set(__self__, "hours_in_cycle", hours_in_cycle)
        pulumi.set(__self__, "start_time", start_time)

    @property
    @pulumi.getter(name="hoursInCycle")
    def hours_in_cycle(self) -> pulumi.Input[int]:
        """
        The number of hours between snapshots.
        """
        return pulumi.get(self, "hours_in_cycle")

    @hours_in_cycle.setter
    def hours_in_cycle(self, value: pulumi.Input[int]):
        pulumi.set(self, "hours_in_cycle", value)

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> pulumi.Input[str]:
        """
        The start time of the schedule. The timestamp is an RFC3339 string.
        """
        return pulumi.get(self, "start_time")

    @start_time.setter
    def start_time(self, value: pulumi.Input[str]):
        pulumi.set(self, "start_time", value)


@pulumi.input_type
class ResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleArgs:
    def __init__(__self__, *,
                 day_of_weeks: pulumi.Input[Sequence[pulumi.Input['ResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleDayOfWeekArgs']]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleDayOfWeekArgs']]] day_of_weeks: May contain up to seven (one for each day of the week) snapshot times.
               Structure is documented below.
        """
        pulumi.set(__self__, "day_of_weeks", day_of_weeks)

    @property
    @pulumi.getter(name="dayOfWeeks")
    def day_of_weeks(self) -> pulumi.Input[Sequence[pulumi.Input['ResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleDayOfWeekArgs']]]:
        """
        May contain up to seven (one for each day of the week) snapshot times.
        Structure is documented below.
        """
        return pulumi.get(self, "day_of_weeks")

    @day_of_weeks.setter
    def day_of_weeks(self, value: pulumi.Input[Sequence[pulumi.Input['ResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleDayOfWeekArgs']]]):
        pulumi.set(self, "day_of_weeks", value)


@pulumi.input_type
class ResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleDayOfWeekArgs:
    def __init__(__self__, *,
                 day: pulumi.Input[str],
                 start_time: pulumi.Input[str]):
        """
        :param pulumi.Input[str] day: The day of the week to create the snapshot. e.g. MONDAY
               Possible values are `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`, and `SUNDAY`.
        :param pulumi.Input[str] start_time: The start time of the schedule. The timestamp is an RFC3339 string.
        """
        pulumi.set(__self__, "day", day)
        pulumi.set(__self__, "start_time", start_time)

    @property
    @pulumi.getter
    def day(self) -> pulumi.Input[str]:
        """
        The day of the week to create the snapshot. e.g. MONDAY
        Possible values are `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`, and `SUNDAY`.
        """
        return pulumi.get(self, "day")

    @day.setter
    def day(self, value: pulumi.Input[str]):
        pulumi.set(self, "day", value)

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> pulumi.Input[str]:
        """
        The start time of the schedule. The timestamp is an RFC3339 string.
        """
        return pulumi.get(self, "start_time")

    @start_time.setter
    def start_time(self, value: pulumi.Input[str]):
        pulumi.set(self, "start_time", value)


@pulumi.input_type
class ResourcePolicySnapshotSchedulePolicySnapshotPropertiesArgs:
    def __init__(__self__, *,
                 guest_flush: Optional[pulumi.Input[bool]] = None,
                 labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 storage_locations: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] guest_flush: Whether to perform a 'guest aware' snapshot.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: A set of key-value pairs.
        :param pulumi.Input[str] storage_locations: Cloud Storage bucket location to store the auto snapshot
               (regional or multi-regional)
        """
        if guest_flush is not None:
            pulumi.set(__self__, "guest_flush", guest_flush)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if storage_locations is not None:
            pulumi.set(__self__, "storage_locations", storage_locations)

    @property
    @pulumi.getter(name="guestFlush")
    def guest_flush(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to perform a 'guest aware' snapshot.
        """
        return pulumi.get(self, "guest_flush")

    @guest_flush.setter
    def guest_flush(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "guest_flush", value)

    @property
    @pulumi.getter
    def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        A set of key-value pairs.
        """
        return pulumi.get(self, "labels")

    @labels.setter
    def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "labels", value)

    @property
    @pulumi.getter(name="storageLocations")
    def storage_locations(self) -> Optional[pulumi.Input[str]]:
        """
        Cloud Storage bucket location to store the auto snapshot
        (regional or multi-regional)
        """
        return pulumi.get(self, "storage_locations")

    @storage_locations.setter
    def storage_locations(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "storage_locations", value)


@pulumi.input_type
class RouterBgpArgs:
    def __init__(__self__, *,
                 asn: pulumi.Input[int],
                 advertise_mode: Optional[pulumi.Input[str]] = None,
                 advertised_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 advertised_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['RouterBgpAdvertisedIpRangeArgs']]]] = None,
                 keepalive_interval: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] asn: Local BGP Autonomous System Number (ASN). Must be an RFC6996
               private ASN, either 16-bit or 32-bit. The value will be fixed for
               this router resource. All VPN tunnels that link to this router
               will have the same local ASN.
        :param pulumi.Input[str] advertise_mode: User-specified flag to indicate which mode to use for advertisement.
               Default value is `DEFAULT`.
               Possible values are `DEFAULT` and `CUSTOM`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] advertised_groups: User-specified list of prefix groups to advertise in custom mode.
               This field can only be populated if advertiseMode is CUSTOM and
               is advertised to all peers of the router. These groups will be
               advertised in addition to any specified prefixes. Leave this field
               blank to advertise no custom groups.
               This enum field has the one valid value: ALL_SUBNETS
        :param pulumi.Input[Sequence[pulumi.Input['RouterBgpAdvertisedIpRangeArgs']]] advertised_ip_ranges: User-specified list of individual IP ranges to advertise in
               custom mode. This field can only be populated if advertiseMode
               is CUSTOM and is advertised to all peers of the router. These IP
               ranges will be advertised in addition to any specified groups.
               Leave this field blank to advertise no custom IP ranges.
               Structure is documented below.
        :param pulumi.Input[int] keepalive_interval: The interval in seconds between BGP keepalive messages that are sent to the peer.
               Hold time is three times the interval at which keepalive messages are sent, and the hold time is the
               maximum number of seconds allowed to elapse between successive keepalive messages that BGP receives from a peer.
               BGP will use the smaller of either the local hold time value or the peer's hold time value as the hold time for
               the BGP connection between the two peers. If set, this value must be between 20 and 60. The default is 20.
        """
        pulumi.set(__self__, "asn", asn)
        if advertise_mode is not None:
            pulumi.set(__self__, "advertise_mode", advertise_mode)
        if advertised_groups is not None:
            pulumi.set(__self__, "advertised_groups", advertised_groups)
        if advertised_ip_ranges is not None:
            pulumi.set(__self__, "advertised_ip_ranges", advertised_ip_ranges)
        if keepalive_interval is not None:
            pulumi.set(__self__, "keepalive_interval", keepalive_interval)

    @property
    @pulumi.getter
    def asn(self) -> pulumi.Input[int]:
        """
        Local BGP Autonomous System Number (ASN). Must be an RFC6996
        private ASN, either 16-bit or 32-bit. The value will be fixed for
        this router resource. All VPN tunnels that link to this router
        will have the same local ASN.
        """
        return pulumi.get(self, "asn")

    @asn.setter
    def asn(self, value: pulumi.Input[int]):
        pulumi.set(self, "asn", value)

    @property
    @pulumi.getter(name="advertiseMode")
    def advertise_mode(self) -> Optional[pulumi.Input[str]]:
        """
        User-specified flag to indicate which mode to use for advertisement.
        Default value is `DEFAULT`.
        Possible values are `DEFAULT` and `CUSTOM`.
        """
        return pulumi.get(self, "advertise_mode")

    @advertise_mode.setter
    def advertise_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "advertise_mode", value)

    @property
    @pulumi.getter(name="advertisedGroups")
    def advertised_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        User-specified list of prefix groups to advertise in custom mode.
        This field can only be populated if advertiseMode is CUSTOM and
        is advertised to all peers of the router. These groups will be
        advertised in addition to any specified prefixes. Leave this field
        blank to advertise no custom groups.
        This enum field has the one valid value: ALL_SUBNETS
        """
        return pulumi.get(self, "advertised_groups")

    @advertised_groups.setter
    def advertised_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "advertised_groups", value)

    @property
    @pulumi.getter(name="advertisedIpRanges")
    def advertised_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RouterBgpAdvertisedIpRangeArgs']]]]:
        """
        User-specified list of individual IP ranges to advertise in
        custom mode. This field can only be populated if advertiseMode
        is CUSTOM and is advertised to all peers of the router. These IP
        ranges will be advertised in addition to any specified groups.
        Leave this field blank to advertise no custom IP ranges.
        Structure is documented below.
        """
        return pulumi.get(self, "advertised_ip_ranges")

    @advertised_ip_ranges.setter
    def advertised_ip_ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RouterBgpAdvertisedIpRangeArgs']]]]):
        pulumi.set(self, "advertised_ip_ranges", value)

    @property
    @pulumi.getter(name="keepaliveInterval")
    def keepalive_interval(self) -> Optional[pulumi.Input[int]]:
        """
        The interval in seconds between BGP keepalive messages that are sent to the peer.
        Hold time is three times the interval at which keepalive messages are sent, and the hold time is the
        maximum number of seconds allowed to elapse between successive keepalive messages that BGP receives from a peer.
        BGP will use the smaller of either the local hold time value or the peer's hold time value as the hold time for
        the BGP connection between the two peers. If set, this value must be between 20 and 60. The default is 20.
        """
        return pulumi.get(self, "keepalive_interval")

    @keepalive_interval.setter
    def keepalive_interval(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "keepalive_interval", value)


@pulumi.input_type
class RouterBgpAdvertisedIpRangeArgs:
    def __init__(__self__, *,
                 range: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] range: The IP range to advertise. The value must be a
               CIDR-formatted string.
        :param pulumi.Input[str] description: User-specified description for the IP range.
        """
        pulumi.set(__self__, "range", range)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def range(self) -> pulumi.Input[str]:
        """
        The IP range to advertise. The value must be a
        CIDR-formatted string.
        """
        return pulumi.get(self, "range")

    @range.setter
    def range(self, value: pulumi.Input[str]):
        pulumi.set(self, "range", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        User-specified description for the IP range.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class RouterNatLogConfigArgs:
    def __init__(__self__, *,
                 enable: pulumi.Input[bool],
                 filter: pulumi.Input[str]):
        """
        :param pulumi.Input[bool] enable: Indicates whether or not to export logs.
        :param pulumi.Input[str] filter: Specifies the desired filtering of logs on this NAT.
               Possible values are `ERRORS_ONLY`, `TRANSLATIONS_ONLY`, and `ALL`.
        """
        pulumi.set(__self__, "enable", enable)
        pulumi.set(__self__, "filter", filter)

    @property
    @pulumi.getter
    def enable(self) -> pulumi.Input[bool]:
        """
        Indicates whether or not to export logs.
        """
        return pulumi.get(self, "enable")

    @enable.setter
    def enable(self, value: pulumi.Input[bool]):
        pulumi.set(self, "enable", value)

    @property
    @pulumi.getter
    def filter(self) -> pulumi.Input[str]:
        """
        Specifies the desired filtering of logs on this NAT.
        Possible values are `ERRORS_ONLY`, `TRANSLATIONS_ONLY`, and `ALL`.
        """
        return pulumi.get(self, "filter")

    @filter.setter
    def filter(self, value: pulumi.Input[str]):
        pulumi.set(self, "filter", value)


@pulumi.input_type
class RouterNatSubnetworkArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 source_ip_ranges_to_nats: pulumi.Input[Sequence[pulumi.Input[str]]],
                 secondary_ip_range_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] name: Self-link of subnetwork to NAT
        :param pulumi.Input[Sequence[pulumi.Input[str]]] source_ip_ranges_to_nats: List of options for which source IPs in the subnetwork
               should have NAT enabled. Supported values include:
               `ALL_IP_RANGES`, `LIST_OF_SECONDARY_IP_RANGES`,
               `PRIMARY_IP_RANGE`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] secondary_ip_range_names: List of the secondary ranges of the subnetwork that are allowed
               to use NAT. This can be populated only if
               `LIST_OF_SECONDARY_IP_RANGES` is one of the values in
               sourceIpRangesToNat
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "source_ip_ranges_to_nats", source_ip_ranges_to_nats)
        if secondary_ip_range_names is not None:
            pulumi.set(__self__, "secondary_ip_range_names", secondary_ip_range_names)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        Self-link of subnetwork to NAT
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="sourceIpRangesToNats")
    def source_ip_ranges_to_nats(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        List of options for which source IPs in the subnetwork
        should have NAT enabled. Supported values include:
        `ALL_IP_RANGES`, `LIST_OF_SECONDARY_IP_RANGES`,
        `PRIMARY_IP_RANGE`.
        """
        return pulumi.get(self, "source_ip_ranges_to_nats")

    @source_ip_ranges_to_nats.setter
    def source_ip_ranges_to_nats(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "source_ip_ranges_to_nats", value)

    @property
    @pulumi.getter(name="secondaryIpRangeNames")
    def secondary_ip_range_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of the secondary ranges of the subnetwork that are allowed
        to use NAT. This can be populated only if
        `LIST_OF_SECONDARY_IP_RANGES` is one of the values in
        sourceIpRangesToNat
        """
        return pulumi.get(self, "secondary_ip_range_names")

    @secondary_ip_range_names.setter
    def secondary_ip_range_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "secondary_ip_range_names", value)


@pulumi.input_type
class RouterPeerAdvertisedIpRangeArgs:
    def __init__(__self__, *,
                 range: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] range: The IP range to advertise. The value must be a
               CIDR-formatted string.
        :param pulumi.Input[str] description: User-specified description for the IP range.
        """
        pulumi.set(__self__, "range", range)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def range(self) -> pulumi.Input[str]:
        """
        The IP range to advertise. The value must be a
        CIDR-formatted string.
        """
        return pulumi.get(self, "range")

    @range.setter
    def range(self, value: pulumi.Input[str]):
        pulumi.set(self, "range", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        User-specified description for the IP range.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class RouterPeerBfdArgs:
    def __init__(__self__, *,
                 session_initialization_mode: pulumi.Input[str],
                 min_receive_interval: Optional[pulumi.Input[int]] = None,
                 min_transmit_interval: Optional[pulumi.Input[int]] = None,
                 multiplier: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] session_initialization_mode: The BFD session initialization mode for this BGP peer.
               If set to `ACTIVE`, the Cloud Router will initiate the BFD session
               for this BGP peer. If set to `PASSIVE`, the Cloud Router will wait
               for the peer router to initiate the BFD session for this BGP peer.
               If set to `DISABLED`, BFD is disabled for this BGP peer.
               Possible values are `ACTIVE`, `DISABLED`, and `PASSIVE`.
        :param pulumi.Input[int] min_receive_interval: The minimum interval, in milliseconds, between BFD control packets
               received from the peer router. The actual value is negotiated
               between the two routers and is equal to the greater of this value
               and the transmit interval of the other router. If set, this value
               must be between 1000 and 30000.
        :param pulumi.Input[int] min_transmit_interval: The minimum interval, in milliseconds, between BFD control packets
               transmitted to the peer router. The actual value is negotiated
               between the two routers and is equal to the greater of this value
               and the corresponding receive interval of the other router. If set,
               this value must be between 1000 and 30000.
        :param pulumi.Input[int] multiplier: The number of consecutive BFD packets that must be missed before
               BFD declares that a peer is unavailable. If set, the value must
               be a value between 5 and 16.
        """
        pulumi.set(__self__, "session_initialization_mode", session_initialization_mode)
        if min_receive_interval is not None:
            pulumi.set(__self__, "min_receive_interval", min_receive_interval)
        if min_transmit_interval is not None:
            pulumi.set(__self__, "min_transmit_interval", min_transmit_interval)
        if multiplier is not None:
            pulumi.set(__self__, "multiplier", multiplier)

    @property
    @pulumi.getter(name="sessionInitializationMode")
    def session_initialization_mode(self) -> pulumi.Input[str]:
        """
        The BFD session initialization mode for this BGP peer.
        If set to `ACTIVE`, the Cloud Router will initiate the BFD session
        for this BGP peer. If set to `PASSIVE`, the Cloud Router will wait
        for the peer router to initiate the BFD session for this BGP peer.
        If set to `DISABLED`, BFD is disabled for this BGP peer.
        Possible values are `ACTIVE`, `DISABLED`, and `PASSIVE`.
        """
        return pulumi.get(self, "session_initialization_mode")

    @session_initialization_mode.setter
    def session_initialization_mode(self, value: pulumi.Input[str]):
        pulumi.set(self, "session_initialization_mode", value)

    @property
    @pulumi.getter(name="minReceiveInterval")
    def min_receive_interval(self) -> Optional[pulumi.Input[int]]:
        """
        The minimum interval, in milliseconds, between BFD control packets
        received from the peer router. The actual value is negotiated
        between the two routers and is equal to the greater of this value
        and the transmit interval of the other router. If set, this value
        must be between 1000 and 30000.
        """
        return pulumi.get(self, "min_receive_interval")

    @min_receive_interval.setter
    def min_receive_interval(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_receive_interval", value)

    @property
    @pulumi.getter(name="minTransmitInterval")
    def min_transmit_interval(self) -> Optional[pulumi.Input[int]]:
        """
        The minimum interval, in milliseconds, between BFD control packets
        transmitted to the peer router. The actual value is negotiated
        between the two routers and is equal to the greater of this value
        and the corresponding receive interval of the other router. If set,
        this value must be between 1000 and 30000.
        """
        return pulumi.get(self, "min_transmit_interval")

    @min_transmit_interval.setter
    def min_transmit_interval(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_transmit_interval", value)

    @property
    @pulumi.getter
    def multiplier(self) -> Optional[pulumi.Input[int]]:
        """
        The number of consecutive BFD packets that must be missed before
        BFD declares that a peer is unavailable. If set, the value must
        be a value between 5 and 16.
        """
        return pulumi.get(self, "multiplier")

    @multiplier.setter
    def multiplier(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "multiplier", value)


@pulumi.input_type
class SecurityPolicyAdaptiveProtectionConfigArgs:
    def __init__(__self__, *,
                 layer7_ddos_defense_config: Optional[pulumi.Input['SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigArgs']] = None):
        """
        :param pulumi.Input['SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigArgs'] layer7_ddos_defense_config: Configuration for [Google Cloud Armor Adaptive Protection Layer 7 DDoS Defense](https://cloud.google.com/armor/docs/adaptive-protection-overview?hl=en). Structure is documented below.
        """
        if layer7_ddos_defense_config is not None:
            pulumi.set(__self__, "layer7_ddos_defense_config", layer7_ddos_defense_config)

    @property
    @pulumi.getter(name="layer7DdosDefenseConfig")
    def layer7_ddos_defense_config(self) -> Optional[pulumi.Input['SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigArgs']]:
        """
        Configuration for [Google Cloud Armor Adaptive Protection Layer 7 DDoS Defense](https://cloud.google.com/armor/docs/adaptive-protection-overview?hl=en). Structure is documented below.
        """
        return pulumi.get(self, "layer7_ddos_defense_config")

    @layer7_ddos_defense_config.setter
    def layer7_ddos_defense_config(self, value: Optional[pulumi.Input['SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigArgs']]):
        pulumi.set(self, "layer7_ddos_defense_config", value)


@pulumi.input_type
class SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigArgs:
    def __init__(__self__, *,
                 enable: Optional[pulumi.Input[bool]] = None,
                 rule_visibility: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] enable: If set to true, enables CAAP for L7 DDoS detection.
        :param pulumi.Input[str] rule_visibility: Rule visibility can be one of the following: STANDARD - opaque rules. (default) PREMIUM - transparent rules.
        """
        if enable is not None:
            pulumi.set(__self__, "enable", enable)
        if rule_visibility is not None:
            pulumi.set(__self__, "rule_visibility", rule_visibility)

    @property
    @pulumi.getter
    def enable(self) -> Optional[pulumi.Input[bool]]:
        """
        If set to true, enables CAAP for L7 DDoS detection.
        """
        return pulumi.get(self, "enable")

    @enable.setter
    def enable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable", value)

    @property
    @pulumi.getter(name="ruleVisibility")
    def rule_visibility(self) -> Optional[pulumi.Input[str]]:
        """
        Rule visibility can be one of the following: STANDARD - opaque rules. (default) PREMIUM - transparent rules.
        """
        return pulumi.get(self, "rule_visibility")

    @rule_visibility.setter
    def rule_visibility(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "rule_visibility", value)


@pulumi.input_type
class SecurityPolicyAdvancedOptionsConfigArgs:
    def __init__(__self__, *,
                 json_parsing: Optional[pulumi.Input[str]] = None,
                 log_level: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] json_parsing: Whether or not to JSON parse the payload body. Defaults to `DISABLED`.
               * DISABLED - Don't parse JSON payloads in POST bodies.
               * STANDARD - Parse JSON payloads in POST bodies.
        :param pulumi.Input[str] log_level: Log level to use. Defaults to `NORMAL`.
               * NORMAL - Normal log level.
               * VERBOSE - Verbose log level.
        """
        if json_parsing is not None:
            pulumi.set(__self__, "json_parsing", json_parsing)
        if log_level is not None:
            pulumi.set(__self__, "log_level", log_level)

    @property
    @pulumi.getter(name="jsonParsing")
    def json_parsing(self) -> Optional[pulumi.Input[str]]:
        """
        Whether or not to JSON parse the payload body. Defaults to `DISABLED`.
        * DISABLED - Don't parse JSON payloads in POST bodies.
        * STANDARD - Parse JSON payloads in POST bodies.
        """
        return pulumi.get(self, "json_parsing")

    @json_parsing.setter
    def json_parsing(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "json_parsing", value)

    @property
    @pulumi.getter(name="logLevel")
    def log_level(self) -> Optional[pulumi.Input[str]]:
        """
        Log level to use. Defaults to `NORMAL`.
        * NORMAL - Normal log level.
        * VERBOSE - Verbose log level.
        """
        return pulumi.get(self, "log_level")

    @log_level.setter
    def log_level(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "log_level", value)


@pulumi.input_type
class SecurityPolicyRuleArgs:
    def __init__(__self__, *,
                 action: pulumi.Input[str],
                 match: pulumi.Input['SecurityPolicyRuleMatchArgs'],
                 priority: pulumi.Input[int],
                 description: Optional[pulumi.Input[str]] = None,
                 preview: Optional[pulumi.Input[bool]] = None,
                 rate_limit_options: Optional[pulumi.Input['SecurityPolicyRuleRateLimitOptionsArgs']] = None,
                 redirect_options: Optional[pulumi.Input['SecurityPolicyRuleRedirectOptionsArgs']] = None):
        """
        :param pulumi.Input[str] action: Action to take when `match` matches the request. Valid values:
               * allow: allow access to target.
               * deny(): deny access to target, returns the HTTP response code specified (valid values are 403, 404, and 502).
               * rate_based_ban: limit client traffic to the configured threshold and ban the client if the traffic exceeds the threshold. Configure parameters for this action in RateLimitOptions. Requires rateLimitOptions to be set.
               * redirect: redirect to a different target. This can either be an internal reCAPTCHA redirect, or an external URL-based redirect via a 302 response. Parameters for this action can be configured via redirectOptions.
               * throttle: limit client traffic to the configured threshold. Configure parameters for this action in rateLimitOptions. Requires rateLimitOptions to be set for this.
        :param pulumi.Input['SecurityPolicyRuleMatchArgs'] match: A match condition that incoming traffic is evaluated against.
               If it evaluates to true, the corresponding `action` is enforced. Structure is documented below.
        :param pulumi.Input[int] priority: An unique positive integer indicating the priority of evaluation for a rule.
               Rules are evaluated from highest priority (lowest numerically) to lowest priority (highest numerically) in order.
        :param pulumi.Input[str] description: An optional description of this rule. Max size is 64.
        :param pulumi.Input[bool] preview: When set to true, the `action` specified above is not enforced.
               Stackdriver logs for requests that trigger a preview action are annotated as such.
        :param pulumi.Input['SecurityPolicyRuleRateLimitOptionsArgs'] rate_limit_options: Must be specified if the `action` is "rate_based_bad" or "throttle". Cannot be specified for other actions. Structure is documented below.
        :param pulumi.Input['SecurityPolicyRuleRedirectOptionsArgs'] redirect_options: Can be specified if the `action` is "redirect". Cannot be specified for other actions. Structure is documented below.
        """
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "match", match)
        pulumi.set(__self__, "priority", priority)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if preview is not None:
            pulumi.set(__self__, "preview", preview)
        if rate_limit_options is not None:
            pulumi.set(__self__, "rate_limit_options", rate_limit_options)
        if redirect_options is not None:
            pulumi.set(__self__, "redirect_options", redirect_options)

    @property
    @pulumi.getter
    def action(self) -> pulumi.Input[str]:
        """
        Action to take when `match` matches the request. Valid values:
        * allow: allow access to target.
        * deny(): deny access to target, returns the HTTP response code specified (valid values are 403, 404, and 502).
        * rate_based_ban: limit client traffic to the configured threshold and ban the client if the traffic exceeds the threshold. Configure parameters for this action in RateLimitOptions. Requires rateLimitOptions to be set.
        * redirect: redirect to a different target. This can either be an internal reCAPTCHA redirect, or an external URL-based redirect via a 302 response. Parameters for this action can be configured via redirectOptions.
        * throttle: limit client traffic to the configured threshold. Configure parameters for this action in rateLimitOptions. Requires rateLimitOptions to be set for this.
        """
        return pulumi.get(self, "action")

    @action.setter
    def action(self, value: pulumi.Input[str]):
        pulumi.set(self, "action", value)

    @property
    @pulumi.getter
    def match(self) -> pulumi.Input['SecurityPolicyRuleMatchArgs']:
        """
        A match condition that incoming traffic is evaluated against.
        If it evaluates to true, the corresponding `action` is enforced. Structure is documented below.
        """
        return pulumi.get(self, "match")

    @match.setter
    def match(self, value: pulumi.Input['SecurityPolicyRuleMatchArgs']):
        pulumi.set(self, "match", value)

    @property
    @pulumi.getter
    def priority(self) -> pulumi.Input[int]:
        """
        An unique positive integer indicating the priority of evaluation for a rule.
        Rules are evaluated from highest priority (lowest numerically) to lowest priority (highest numerically) in order.
        """
        return pulumi.get(self, "priority")

    @priority.setter
    def priority(self, value: pulumi.Input[int]):
        pulumi.set(self, "priority", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        An optional description of this rule. Max size is 64.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)

    @property
    @pulumi.getter
    def preview(self) -> Optional[pulumi.Input[bool]]:
        """
        When set to true, the `action` specified above is not enforced.
        Stackdriver logs for requests that trigger a preview action are annotated as such.
        """
        return pulumi.get(self, "preview")

    @preview.setter
    def preview(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "preview", value)

    @property
    @pulumi.getter(name="rateLimitOptions")
    def rate_limit_options(self) -> Optional[pulumi.Input['SecurityPolicyRuleRateLimitOptionsArgs']]:
        """
        Must be specified if the `action` is "rate_based_bad" or "throttle". Cannot be specified for other actions. Structure is documented below.
        """
        return pulumi.get(self, "rate_limit_options")

    @rate_limit_options.setter
    def rate_limit_options(self, value: Optional[pulumi.Input['SecurityPolicyRuleRateLimitOptionsArgs']]):
        pulumi.set(self, "rate_limit_options", value)

    @property
    @pulumi.getter(name="redirectOptions")
    def redirect_options(self) -> Optional[pulumi.Input['SecurityPolicyRuleRedirectOptionsArgs']]:
        """
        Can be specified if the `action` is "redirect". Cannot be specified for other actions. Structure is documented below.
        """
        return pulumi.get(self, "redirect_options")

    @redirect_options.setter
    def redirect_options(self, value: Optional[pulumi.Input['SecurityPolicyRuleRedirectOptionsArgs']]):
        pulumi.set(self, "redirect_options", value)


@pulumi.input_type
class SecurityPolicyRuleMatchArgs:
    def __init__(__self__, *,
                 config: Optional[pulumi.Input['SecurityPolicyRuleMatchConfigArgs']] = None,
                 expr: Optional[pulumi.Input['SecurityPolicyRuleMatchExprArgs']] = None,
                 versioned_expr: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['SecurityPolicyRuleMatchConfigArgs'] config: The configuration options available when specifying `versioned_expr`.
               This field must be specified if `versioned_expr` is specified and cannot be specified if `versioned_expr` is not specified.
               Structure is documented below.
        :param pulumi.Input['SecurityPolicyRuleMatchExprArgs'] expr: User defined CEVAL expression. A CEVAL expression is used to specify match criteria
               such as origin.ip, source.region_code and contents in the request header.
               Structure is documented below.
        :param pulumi.Input[str] versioned_expr: Predefined rule expression. If this field is specified, `config` must also be specified.
               Available options:
               * SRC_IPS_V1: Must specify the corresponding `src_ip_ranges` field in `config`.
        """
        if config is not None:
            pulumi.set(__self__, "config", config)
        if expr is not None:
            pulumi.set(__self__, "expr", expr)
        if versioned_expr is not None:
            pulumi.set(__self__, "versioned_expr", versioned_expr)

    @property
    @pulumi.getter
    def config(self) -> Optional[pulumi.Input['SecurityPolicyRuleMatchConfigArgs']]:
        """
        The configuration options available when specifying `versioned_expr`.
        This field must be specified if `versioned_expr` is specified and cannot be specified if `versioned_expr` is not specified.
        Structure is documented below.
        """
        return pulumi.get(self, "config")

    @config.setter
    def config(self, value: Optional[pulumi.Input['SecurityPolicyRuleMatchConfigArgs']]):
        pulumi.set(self, "config", value)

    @property
    @pulumi.getter
    def expr(self) -> Optional[pulumi.Input['SecurityPolicyRuleMatchExprArgs']]:
        """
        User defined CEVAL expression. A CEVAL expression is used to specify match criteria
        such as origin.ip, source.region_code and contents in the request header.
        Structure is documented below.
        """
        return pulumi.get(self, "expr")

    @expr.setter
    def expr(self, value: Optional[pulumi.Input['SecurityPolicyRuleMatchExprArgs']]):
        pulumi.set(self, "expr", value)

    @property
    @pulumi.getter(name="versionedExpr")
    def versioned_expr(self) -> Optional[pulumi.Input[str]]:
        """
        Predefined rule expression. If this field is specified, `config` must also be specified.
        Available options:
        * SRC_IPS_V1: Must specify the corresponding `src_ip_ranges` field in `config`.
        """
        return pulumi.get(self, "versioned_expr")

    @versioned_expr.setter
    def versioned_expr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "versioned_expr", value)


@pulumi.input_type
class SecurityPolicyRuleMatchConfigArgs:
    def __init__(__self__, *,
                 src_ip_ranges: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] src_ip_ranges: Set of IP addresses or ranges (IPV4 or IPV6) in CIDR notation
               to match against inbound traffic. There is a limit of 10 IP ranges per rule. A value of '\\*' matches all IPs
               (can be used to override the default behavior).
        """
        pulumi.set(__self__, "src_ip_ranges", src_ip_ranges)

    @property
    @pulumi.getter(name="srcIpRanges")
    def src_ip_ranges(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        Set of IP addresses or ranges (IPV4 or IPV6) in CIDR notation
        to match against inbound traffic. There is a limit of 10 IP ranges per rule. A value of '\\*' matches all IPs
        (can be used to override the default behavior).
        """
        return pulumi.get(self, "src_ip_ranges")

    @src_ip_ranges.setter
    def src_ip_ranges(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "src_ip_ranges", value)


@pulumi.input_type
class SecurityPolicyRuleMatchExprArgs:
    def __init__(__self__, *,
                 expression: pulumi.Input[str]):
        """
        :param pulumi.Input[str] expression: Textual representation of an expression in Common Expression Language syntax.
               The application context of the containing message determines which well-known feature set of CEL is supported.
        """
        pulumi.set(__self__, "expression", expression)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        """
        Textual representation of an expression in Common Expression Language syntax.
        The application context of the containing message determines which well-known feature set of CEL is supported.
        """
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)


@pulumi.input_type
class SecurityPolicyRuleRateLimitOptionsArgs:
    def __init__(__self__, *,
                 conform_action: pulumi.Input[str],
                 exceed_action: pulumi.Input[str],
                 rate_limit_threshold: pulumi.Input['SecurityPolicyRuleRateLimitOptionsRateLimitThresholdArgs'],
                 ban_duration_sec: Optional[pulumi.Input[int]] = None,
                 ban_threshold: Optional[pulumi.Input['SecurityPolicyRuleRateLimitOptionsBanThresholdArgs']] = None,
                 enforce_on_key: Optional[pulumi.Input[str]] = None,
                 enforce_on_key_name: Optional[pulumi.Input[str]] = None,
                 exceed_redirect_options: Optional[pulumi.Input['SecurityPolicyRuleRateLimitOptionsExceedRedirectOptionsArgs']] = None):
        """
        :param pulumi.Input[str] conform_action: Action to take for requests that are under the configured rate limit threshold. Valid option is "allow" only.
        :param pulumi.Input[str] exceed_action: When a request is denied, returns the HTTP response code specified.
               Valid options are "deny()" where valid values for status are 403, 404, 429, and 502.
        :param pulumi.Input['SecurityPolicyRuleRateLimitOptionsRateLimitThresholdArgs'] rate_limit_threshold: Threshold at which to begin ratelimiting. Structure is documented below.
        :param pulumi.Input[int] ban_duration_sec: Can only be specified if the `action` for the rule is "rate_based_ban".
               If specified, determines the time (in seconds) the traffic will continue to be banned by the rate limit after the rate falls below the threshold.
        :param pulumi.Input['SecurityPolicyRuleRateLimitOptionsBanThresholdArgs'] ban_threshold: Can only be specified if the `action` for the rule is "rate_based_ban".
               If specified, the key will be banned for the configured 'ban_duration_sec' when the number of requests that exceed the 'rate_limit_threshold' also
               exceed this 'ban_threshold'. Structure is documented below.
        :param pulumi.Input[str] enforce_on_key: Determines the key to enforce the rate_limit_threshold on. If not specified, defaults to "ALL".
        :param pulumi.Input[str] enforce_on_key_name: Rate limit key name applicable only for the following key types: HTTP_HEADER -- Name of the HTTP header whose value is taken as the key value. HTTP_COOKIE -- Name of the HTTP cookie whose value is taken as the key value.
        """
        pulumi.set(__self__, "conform_action", conform_action)
        pulumi.set(__self__, "exceed_action", exceed_action)
        pulumi.set(__self__, "rate_limit_threshold", rate_limit_threshold)
        if ban_duration_sec is not None:
            pulumi.set(__self__, "ban_duration_sec", ban_duration_sec)
        if ban_threshold is not None:
            pulumi.set(__self__, "ban_threshold", ban_threshold)
        if enforce_on_key is not None:
            pulumi.set(__self__, "enforce_on_key", enforce_on_key)
        if enforce_on_key_name is not None:
            pulumi.set(__self__, "enforce_on_key_name", enforce_on_key_name)
        if exceed_redirect_options is not None:
            pulumi.set(__self__, "exceed_redirect_options", exceed_redirect_options)

    @property
    @pulumi.getter(name="conformAction")
    def conform_action(self) -> pulumi.Input[str]:
        """
        Action to take for requests that are under the configured rate limit threshold. Valid option is "allow" only.
        """
        return pulumi.get(self, "conform_action")

    @conform_action.setter
    def conform_action(self, value: pulumi.Input[str]):
        pulumi.set(self, "conform_action", value)

    @property
    @pulumi.getter(name="exceedAction")
    def exceed_action(self) -> pulumi.Input[str]:
        """
        When a request is denied, returns the HTTP response code specified.
        Valid options are "deny()" where valid values for status are 403, 404, 429, and 502.
        """
        return pulumi.get(self, "exceed_action")

    @exceed_action.setter
    def exceed_action(self, value: pulumi.Input[str]):
        pulumi.set(self, "exceed_action", value)

    @property
    @pulumi.getter(name="rateLimitThreshold")
    def rate_limit_threshold(self) -> pulumi.Input['SecurityPolicyRuleRateLimitOptionsRateLimitThresholdArgs']:
        """
        Threshold at which to begin ratelimiting. Structure is documented below.
        """
        return pulumi.get(self, "rate_limit_threshold")

    @rate_limit_threshold.setter
    def rate_limit_threshold(self, value: pulumi.Input['SecurityPolicyRuleRateLimitOptionsRateLimitThresholdArgs']):
        pulumi.set(self, "rate_limit_threshold", value)

    @property
    @pulumi.getter(name="banDurationSec")
    def ban_duration_sec(self) -> Optional[pulumi.Input[int]]:
        """
        Can only be specified if the `action` for the rule is "rate_based_ban".
        If specified, determines the time (in seconds) the traffic will continue to be banned by the rate limit after the rate falls below the threshold.
        """
        return pulumi.get(self, "ban_duration_sec")

    @ban_duration_sec.setter
    def ban_duration_sec(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "ban_duration_sec", value)

    @property
    @pulumi.getter(name="banThreshold")
    def ban_threshold(self) -> Optional[pulumi.Input['SecurityPolicyRuleRateLimitOptionsBanThresholdArgs']]:
        """
        Can only be specified if the `action` for the rule is "rate_based_ban".
        If specified, the key will be banned for the configured 'ban_duration_sec' when the number of requests that exceed the 'rate_limit_threshold' also
        exceed this 'ban_threshold'. Structure is documented below.
        """
        return pulumi.get(self, "ban_threshold")

    @ban_threshold.setter
    def ban_threshold(self, value: Optional[pulumi.Input['SecurityPolicyRuleRateLimitOptionsBanThresholdArgs']]):
        pulumi.set(self, "ban_threshold", value)

    @property
    @pulumi.getter(name="enforceOnKey")
    def enforce_on_key(self) -> Optional[pulumi.Input[str]]:
        """
        Determines the key to enforce the rate_limit_threshold on. If not specified, defaults to "ALL".
        """
        return pulumi.get(self, "enforce_on_key")

    @enforce_on_key.setter
    def enforce_on_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "enforce_on_key", value)

    @property
    @pulumi.getter(name="enforceOnKeyName")
    def enforce_on_key_name(self) -> Optional[pulumi.Input[str]]:
        """
        Rate limit key name applicable only for the following key types: HTTP_HEADER -- Name of the HTTP header whose value is taken as the key value. HTTP_COOKIE -- Name of the HTTP cookie whose value is taken as the key value.
        """
        return pulumi.get(self, "enforce_on_key_name")

    @enforce_on_key_name.setter
    def enforce_on_key_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "enforce_on_key_name", value)

    @property
    @pulumi.getter(name="exceedRedirectOptions")
    def exceed_redirect_options(self) -> Optional[pulumi.Input['SecurityPolicyRuleRateLimitOptionsExceedRedirectOptionsArgs']]:
        return pulumi.get(self, "exceed_redirect_options")

    @exceed_redirect_options.setter
    def exceed_redirect_options(self, value: Optional[pulumi.Input['SecurityPolicyRuleRateLimitOptionsExceedRedirectOptionsArgs']]):
        pulumi.set(self, "exceed_redirect_options", value)


@pulumi.input_type
class SecurityPolicyRuleRateLimitOptionsBanThresholdArgs:
    def __init__(__self__, *,
                 count: pulumi.Input[int],
                 interval_sec: pulumi.Input[int]):
        """
        :param pulumi.Input[int] count: Number of HTTP(S) requests for calculating the threshold.
        :param pulumi.Input[int] interval_sec: Interval over which the threshold is computed.
        """
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "interval_sec", interval_sec)

    @property
    @pulumi.getter
    def count(self) -> pulumi.Input[int]:
        """
        Number of HTTP(S) requests for calculating the threshold.
        """
        return pulumi.get(self, "count")

    @count.setter
    def count(self, value: pulumi.Input[int]):
        pulumi.set(self, "count", value)

    @property
    @pulumi.getter(name="intervalSec")
    def interval_sec(self) -> pulumi.Input[int]:
        """
        Interval over which the threshold is computed.
        """
        return pulumi.get(self, "interval_sec")

    @interval_sec.setter
    def interval_sec(self, value: pulumi.Input[int]):
        pulumi.set(self, "interval_sec", value)


@pulumi.input_type
class SecurityPolicyRuleRateLimitOptionsExceedRedirectOptionsArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str],
                 target: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] type: Type of redirect action.
        :param pulumi.Input[str] target: External redirection target when "EXTERNAL_302" is set in 'type'.
        """
        pulumi.set(__self__, "type", type)
        if target is not None:
            pulumi.set(__self__, "target", target)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        Type of redirect action.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter
    def target(self) -> Optional[pulumi.Input[str]]:
        """
        External redirection target when "EXTERNAL_302" is set in 'type'.
        """
        return pulumi.get(self, "target")

    @target.setter
    def target(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "target", value)


@pulumi.input_type
class SecurityPolicyRuleRateLimitOptionsRateLimitThresholdArgs:
    def __init__(__self__, *,
                 count: pulumi.Input[int],
                 interval_sec: pulumi.Input[int]):
        """
        :param pulumi.Input[int] count: Number of HTTP(S) requests for calculating the threshold.
        :param pulumi.Input[int] interval_sec: Interval over which the threshold is computed.
        """
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "interval_sec", interval_sec)

    @property
    @pulumi.getter
    def count(self) -> pulumi.Input[int]:
        """
        Number of HTTP(S) requests for calculating the threshold.
        """
        return pulumi.get(self, "count")

    @count.setter
    def count(self, value: pulumi.Input[int]):
        pulumi.set(self, "count", value)

    @property
    @pulumi.getter(name="intervalSec")
    def interval_sec(self) -> pulumi.Input[int]:
        """
        Interval over which the threshold is computed.
        """
        return pulumi.get(self, "interval_sec")

    @interval_sec.setter
    def interval_sec(self, value: pulumi.Input[int]):
        pulumi.set(self, "interval_sec", value)


@pulumi.input_type
class SecurityPolicyRuleRedirectOptionsArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str],
                 target: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] type: Type of redirect action.
        :param pulumi.Input[str] target: External redirection target when "EXTERNAL_302" is set in 'type'.
        """
        pulumi.set(__self__, "type", type)
        if target is not None:
            pulumi.set(__self__, "target", target)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        Type of redirect action.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter
    def target(self) -> Optional[pulumi.Input[str]]:
        """
        External redirection target when "EXTERNAL_302" is set in 'type'.
        """
        return pulumi.get(self, "target")

    @target.setter
    def target(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "target", value)


@pulumi.input_type
class SecurityScanConfigAuthenticationArgs:
    def __init__(__self__, *,
                 custom_account: Optional[pulumi.Input['SecurityScanConfigAuthenticationCustomAccountArgs']] = None,
                 google_account: Optional[pulumi.Input['SecurityScanConfigAuthenticationGoogleAccountArgs']] = None):
        """
        :param pulumi.Input['SecurityScanConfigAuthenticationCustomAccountArgs'] custom_account: Describes authentication configuration that uses a custom account.
               Structure is documented below.
        :param pulumi.Input['SecurityScanConfigAuthenticationGoogleAccountArgs'] google_account: Describes authentication configuration that uses a Google account.
               Structure is documented below.
        """
        if custom_account is not None:
            pulumi.set(__self__, "custom_account", custom_account)
        if google_account is not None:
            pulumi.set(__self__, "google_account", google_account)

    @property
    @pulumi.getter(name="customAccount")
    def custom_account(self) -> Optional[pulumi.Input['SecurityScanConfigAuthenticationCustomAccountArgs']]:
        """
        Describes authentication configuration that uses a custom account.
        Structure is documented below.
        """
        return pulumi.get(self, "custom_account")

    @custom_account.setter
    def custom_account(self, value: Optional[pulumi.Input['SecurityScanConfigAuthenticationCustomAccountArgs']]):
        pulumi.set(self, "custom_account", value)

    @property
    @pulumi.getter(name="googleAccount")
    def google_account(self) -> Optional[pulumi.Input['SecurityScanConfigAuthenticationGoogleAccountArgs']]:
        """
        Describes authentication configuration that uses a Google account.
        Structure is documented below.
        """
        return pulumi.get(self, "google_account")

    @google_account.setter
    def google_account(self, value: Optional[pulumi.Input['SecurityScanConfigAuthenticationGoogleAccountArgs']]):
        pulumi.set(self, "google_account", value)


@pulumi.input_type
class SecurityScanConfigAuthenticationCustomAccountArgs:
    def __init__(__self__, *,
                 login_url: pulumi.Input[str],
                 password: pulumi.Input[str],
                 username: pulumi.Input[str]):
        """
        :param pulumi.Input[str] login_url: The login form URL of the website.
        :param pulumi.Input[str] password: The password of the custom account. The credential is stored encrypted
               in GCP.
               **Note**: This property is sensitive and will not be displayed in the plan.
        :param pulumi.Input[str] username: The user name of the custom account.
        """
        pulumi.set(__self__, "login_url", login_url)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="loginUrl")
    def login_url(self) -> pulumi.Input[str]:
        """
        The login form URL of the website.
        """
        return pulumi.get(self, "login_url")

    @login_url.setter
    def login_url(self, value: pulumi.Input[str]):
        pulumi.set(self, "login_url", value)

    @property
    @pulumi.getter
    def password(self) -> pulumi.Input[str]:
        """
        The password of the custom account. The credential is stored encrypted
        in GCP.
        **Note**: This property is sensitive and will not be displayed in the plan.
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: pulumi.Input[str]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter
    def username(self) -> pulumi.Input[str]:
        """
        The user name of the custom account.
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: pulumi.Input[str]):
        pulumi.set(self, "username", value)


@pulumi.input_type
class SecurityScanConfigAuthenticationGoogleAccountArgs:
    def __init__(__self__, *,
                 password: pulumi.Input[str],
                 username: pulumi.Input[str]):
        """
        :param pulumi.Input[str] password: The password of the custom account. The credential is stored encrypted
               in GCP.
               **Note**: This property is sensitive and will not be displayed in the plan.
        :param pulumi.Input[str] username: The user name of the custom account.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def password(self) -> pulumi.Input[str]:
        """
        The password of the custom account. The credential is stored encrypted
        in GCP.
        **Note**: This property is sensitive and will not be displayed in the plan.
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: pulumi.Input[str]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter
    def username(self) -> pulumi.Input[str]:
        """
        The user name of the custom account.
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: pulumi.Input[str]):
        pulumi.set(self, "username", value)


@pulumi.input_type
class SecurityScanConfigScheduleArgs:
    def __init__(__self__, *,
                 interval_duration_days: pulumi.Input[int],
                 schedule_time: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] interval_duration_days: The duration of time between executions in days
        :param pulumi.Input[str] schedule_time: A timestamp indicates when the next run will be scheduled. The value is refreshed
               by the server after each run. If unspecified, it will default to current server time,
               which means the scan will be scheduled to start immediately.
        """
        pulumi.set(__self__, "interval_duration_days", interval_duration_days)
        if schedule_time is not None:
            pulumi.set(__self__, "schedule_time", schedule_time)

    @property
    @pulumi.getter(name="intervalDurationDays")
    def interval_duration_days(self) -> pulumi.Input[int]:
        """
        The duration of time between executions in days
        """
        return pulumi.get(self, "interval_duration_days")

    @interval_duration_days.setter
    def interval_duration_days(self, value: pulumi.Input[int]):
        pulumi.set(self, "interval_duration_days", value)

    @property
    @pulumi.getter(name="scheduleTime")
    def schedule_time(self) -> Optional[pulumi.Input[str]]:
        """
        A timestamp indicates when the next run will be scheduled. The value is refreshed
        by the server after each run. If unspecified, it will default to current server time,
        which means the scan will be scheduled to start immediately.
        """
        return pulumi.get(self, "schedule_time")

    @schedule_time.setter
    def schedule_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "schedule_time", value)


@pulumi.input_type
class ServiceAttachmentConnectedEndpointArgs:
    def __init__(__self__, *,
                 endpoint: Optional[pulumi.Input[str]] = None,
                 status: Optional[pulumi.Input[str]] = None):
        if endpoint is not None:
            pulumi.set(__self__, "endpoint", endpoint)
        if status is not None:
            pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter
    def endpoint(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "endpoint", value)

    @property
    @pulumi.getter
    def status(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "status")

    @status.setter
    def status(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "status", value)


@pulumi.input_type
class ServiceAttachmentConsumerAcceptListArgs:
    def __init__(__self__, *,
                 connection_limit: pulumi.Input[int],
                 project_id_or_num: pulumi.Input[str]):
        """
        :param pulumi.Input[int] connection_limit: The number of consumer forwarding rules the consumer project can
               create.
        :param pulumi.Input[str] project_id_or_num: A project that is allowed to connect to this service attachment.
        """
        pulumi.set(__self__, "connection_limit", connection_limit)
        pulumi.set(__self__, "project_id_or_num", project_id_or_num)

    @property
    @pulumi.getter(name="connectionLimit")
    def connection_limit(self) -> pulumi.Input[int]:
        """
        The number of consumer forwarding rules the consumer project can
        create.
        """
        return pulumi.get(self, "connection_limit")

    @connection_limit.setter
    def connection_limit(self, value: pulumi.Input[int]):
        pulumi.set(self, "connection_limit", value)

    @property
    @pulumi.getter(name="projectIdOrNum")
    def project_id_or_num(self) -> pulumi.Input[str]:
        """
        A project that is allowed to connect to this service attachment.
        """
        return pulumi.get(self, "project_id_or_num")

    @project_id_or_num.setter
    def project_id_or_num(self, value: pulumi.Input[str]):
        pulumi.set(self, "project_id_or_num", value)


@pulumi.input_type
class SnapshotIamBindingConditionArgs:
    def __init__(__self__, *,
                 expression: pulumi.Input[str],
                 title: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "title", title)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter
    def title(self) -> pulumi.Input[str]:
        return pulumi.get(self, "title")

    @title.setter
    def title(self, value: pulumi.Input[str]):
        pulumi.set(self, "title", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class SnapshotIamMemberConditionArgs:
    def __init__(__self__, *,
                 expression: pulumi.Input[str],
                 title: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "title", title)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter
    def title(self) -> pulumi.Input[str]:
        return pulumi.get(self, "title")

    @title.setter
    def title(self, value: pulumi.Input[str]):
        pulumi.set(self, "title", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class SnapshotSnapshotEncryptionKeyArgs:
    def __init__(__self__, *,
                 kms_key_self_link: Optional[pulumi.Input[str]] = None,
                 kms_key_service_account: Optional[pulumi.Input[str]] = None,
                 raw_key: Optional[pulumi.Input[str]] = None,
                 sha256: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] kms_key_self_link: The name of the encryption key that is stored in Google Cloud KMS.
        :param pulumi.Input[str] kms_key_service_account: The service account used for the encryption request for the given KMS key.
               If absent, the Compute Engine Service Agent service account is used.
        :param pulumi.Input[str] raw_key: Specifies a 256-bit customer-supplied encryption key, encoded in
               RFC 4648 base64 to either encrypt or decrypt this resource.
               **Note**: This property is sensitive and will not be displayed in the plan.
        :param pulumi.Input[str] sha256: -
               The RFC 4648 base64 encoded SHA-256 hash of the customer-supplied
               encryption key that protects this resource.
        """
        if kms_key_self_link is not None:
            pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
        if kms_key_service_account is not None:
            pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
        if raw_key is not None:
            pulumi.set(__self__, "raw_key", raw_key)
        if sha256 is not None:
            pulumi.set(__self__, "sha256", sha256)

    @property
    @pulumi.getter(name="kmsKeySelfLink")
    def kms_key_self_link(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the encryption key that is stored in Google Cloud KMS.
        """
        return pulumi.get(self, "kms_key_self_link")

    @kms_key_self_link.setter
    def kms_key_self_link(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_self_link", value)

    @property
    @pulumi.getter(name="kmsKeyServiceAccount")
    def kms_key_service_account(self) -> Optional[pulumi.Input[str]]:
        """
        The service account used for the encryption request for the given KMS key.
        If absent, the Compute Engine Service Agent service account is used.
        """
        return pulumi.get(self, "kms_key_service_account")

    @kms_key_service_account.setter
    def kms_key_service_account(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_service_account", value)

    @property
    @pulumi.getter(name="rawKey")
    def raw_key(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies a 256-bit customer-supplied encryption key, encoded in
        RFC 4648 base64 to either encrypt or decrypt this resource.
        **Note**: This property is sensitive and will not be displayed in the plan.
        """
        return pulumi.get(self, "raw_key")

    @raw_key.setter
    def raw_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "raw_key", value)

    @property
    @pulumi.getter
    def sha256(self) -> Optional[pulumi.Input[str]]:
        """
        -
        The RFC 4648 base64 encoded SHA-256 hash of the customer-supplied
        encryption key that protects this resource.
        """
        return pulumi.get(self, "sha256")

    @sha256.setter
    def sha256(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sha256", value)


@pulumi.input_type
class SnapshotSourceDiskEncryptionKeyArgs:
    def __init__(__self__, *,
                 kms_key_service_account: Optional[pulumi.Input[str]] = None,
                 raw_key: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] kms_key_service_account: The service account used for the encryption request for the given KMS key.
               If absent, the Compute Engine Service Agent service account is used.
        :param pulumi.Input[str] raw_key: Specifies a 256-bit customer-supplied encryption key, encoded in
               RFC 4648 base64 to either encrypt or decrypt this resource.
               **Note**: This property is sensitive and will not be displayed in the plan.
        """
        if kms_key_service_account is not None:
            pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
        if raw_key is not None:
            pulumi.set(__self__, "raw_key", raw_key)

    @property
    @pulumi.getter(name="kmsKeyServiceAccount")
    def kms_key_service_account(self) -> Optional[pulumi.Input[str]]:
        """
        The service account used for the encryption request for the given KMS key.
        If absent, the Compute Engine Service Agent service account is used.
        """
        return pulumi.get(self, "kms_key_service_account")

    @kms_key_service_account.setter
    def kms_key_service_account(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_service_account", value)

    @property
    @pulumi.getter(name="rawKey")
    def raw_key(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies a 256-bit customer-supplied encryption key, encoded in
        RFC 4648 base64 to either encrypt or decrypt this resource.
        **Note**: This property is sensitive and will not be displayed in the plan.
        """
        return pulumi.get(self, "raw_key")

    @raw_key.setter
    def raw_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "raw_key", value)


@pulumi.input_type
class SubnetworkIAMBindingConditionArgs:
    def __init__(__self__, *,
                 expression: pulumi.Input[str],
                 title: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] expression: Textual representation of an expression in Common Expression Language syntax.
        :param pulumi.Input[str] title: A title for the expression, i.e. a short string describing its purpose.
        :param pulumi.Input[str] description: An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "title", title)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter
    def title(self) -> pulumi.Input[str]:
        """
        A title for the expression, i.e. a short string describing its purpose.
        """
        return pulumi.get(self, "title")

    @title.setter
    def title(self, value: pulumi.Input[str]):
        pulumi.set(self, "title", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class SubnetworkIAMMemberConditionArgs:
    def __init__(__self__, *,
                 expression: pulumi.Input[str],
                 title: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] expression: Textual representation of an expression in Common Expression Language syntax.
        :param pulumi.Input[str] title: A title for the expression, i.e. a short string describing its purpose.
        :param pulumi.Input[str] description: An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "title", title)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter
    def title(self) -> pulumi.Input[str]:
        """
        A title for the expression, i.e. a short string describing its purpose.
        """
        return pulumi.get(self, "title")

    @title.setter
    def title(self, value: pulumi.Input[str]):
        pulumi.set(self, "title", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class SubnetworkLogConfigArgs:
    def __init__(__self__, *,
                 aggregation_interval: Optional[pulumi.Input[str]] = None,
                 filter_expr: Optional[pulumi.Input[str]] = None,
                 flow_sampling: Optional[pulumi.Input[float]] = None,
                 metadata: Optional[pulumi.Input[str]] = None,
                 metadata_fields: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] aggregation_interval: Can only be specified if VPC flow logging for this subnetwork is enabled.
               Toggles the aggregation interval for collecting flow logs. Increasing the
               interval time will reduce the amount of generated flow logs for long
               lasting connections. Default is an interval of 5 seconds per connection.
               Default value is `INTERVAL_5_SEC`.
               Possible values are `INTERVAL_5_SEC`, `INTERVAL_30_SEC`, `INTERVAL_1_MIN`, `INTERVAL_5_MIN`, `INTERVAL_10_MIN`, and `INTERVAL_15_MIN`.
        :param pulumi.Input[str] filter_expr: Export filter used to define which VPC flow logs should be logged, as as CEL expression. See
               https://cloud.google.com/vpc/docs/flow-logs#filtering for details on how to format this field.
               The default value is 'true', which evaluates to include everything.
        :param pulumi.Input[float] flow_sampling: Can only be specified if VPC flow logging for this subnetwork is enabled.
               The value of the field must be in [0, 1]. Set the sampling rate of VPC
               flow logs within the subnetwork where 1.0 means all collected logs are
               reported and 0.0 means no logs are reported. Default is 0.5 which means
               half of all collected logs are reported.
        :param pulumi.Input[str] metadata: Can only be specified if VPC flow logging for this subnetwork is enabled.
               Configures whether metadata fields should be added to the reported VPC
               flow logs.
               Default value is `INCLUDE_ALL_METADATA`.
               Possible values are `EXCLUDE_ALL_METADATA`, `INCLUDE_ALL_METADATA`, and `CUSTOM_METADATA`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] metadata_fields: List of metadata fields that should be added to reported logs.
               Can only be specified if VPC flow logs for this subnetwork is enabled and "metadata" is set to CUSTOM_METADATA.
        """
        if aggregation_interval is not None:
            pulumi.set(__self__, "aggregation_interval", aggregation_interval)
        if filter_expr is not None:
            pulumi.set(__self__, "filter_expr", filter_expr)
        if flow_sampling is not None:
            pulumi.set(__self__, "flow_sampling", flow_sampling)
        if metadata is not None:
            pulumi.set(__self__, "metadata", metadata)
        if metadata_fields is not None:
            pulumi.set(__self__, "metadata_fields", metadata_fields)

    @property
    @pulumi.getter(name="aggregationInterval")
    def aggregation_interval(self) -> Optional[pulumi.Input[str]]:
        """
        Can only be specified if VPC flow logging for this subnetwork is enabled.
        Toggles the aggregation interval for collecting flow logs. Increasing the
        interval time will reduce the amount of generated flow logs for long
        lasting connections. Default is an interval of 5 seconds per connection.
        Default value is `INTERVAL_5_SEC`.
        Possible values are `INTERVAL_5_SEC`, `INTERVAL_30_SEC`, `INTERVAL_1_MIN`, `INTERVAL_5_MIN`, `INTERVAL_10_MIN`, and `INTERVAL_15_MIN`.
        """
        return pulumi.get(self, "aggregation_interval")

    @aggregation_interval.setter
    def aggregation_interval(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "aggregation_interval", value)

    @property
    @pulumi.getter(name="filterExpr")
    def filter_expr(self) -> Optional[pulumi.Input[str]]:
        """
        Export filter used to define which VPC flow logs should be logged, as as CEL expression. See
        https://cloud.google.com/vpc/docs/flow-logs#filtering for details on how to format this field.
        The default value is 'true', which evaluates to include everything.
        """
        return pulumi.get(self, "filter_expr")

    @filter_expr.setter
    def filter_expr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "filter_expr", value)

    @property
    @pulumi.getter(name="flowSampling")
    def flow_sampling(self) -> Optional[pulumi.Input[float]]:
        """
        Can only be specified if VPC flow logging for this subnetwork is enabled.
        The value of the field must be in [0, 1]. Set the sampling rate of VPC
        flow logs within the subnetwork where 1.0 means all collected logs are
        reported and 0.0 means no logs are reported. Default is 0.5 which means
        half of all collected logs are reported.
        """
        return pulumi.get(self, "flow_sampling")

    @flow_sampling.setter
    def flow_sampling(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "flow_sampling", value)

    @property
    @pulumi.getter
    def metadata(self) -> Optional[pulumi.Input[str]]:
        """
        Can only be specified if VPC flow logging for this subnetwork is enabled.
        Configures whether metadata fields should be added to the reported VPC
        flow logs.
        Default value is `INCLUDE_ALL_METADATA`.
        Possible values are `EXCLUDE_ALL_METADATA`, `INCLUDE_ALL_METADATA`, and `CUSTOM_METADATA`.
        """
        return pulumi.get(self, "metadata")

    @metadata.setter
    def metadata(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "metadata", value)

    @property
    @pulumi.getter(name="metadataFields")
    def metadata_fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of metadata fields that should be added to reported logs.
        Can only be specified if VPC flow logs for this subnetwork is enabled and "metadata" is set to CUSTOM_METADATA.
        """
        return pulumi.get(self, "metadata_fields")

    @metadata_fields.setter
    def metadata_fields(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "metadata_fields", value)


@pulumi.input_type
class SubnetworkSecondaryIpRangeArgs:
    def __init__(__self__, *,
                 ip_cidr_range: pulumi.Input[str],
                 range_name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] ip_cidr_range: The range of IP addresses belonging to this subnetwork secondary
               range. Provide this property when you create the subnetwork.
               Ranges must be unique and non-overlapping with all primary and
               secondary IP ranges within a network. Only IPv4 is supported.
        :param pulumi.Input[str] range_name: The name associated with this subnetwork secondary range, used
               when adding an alias IP range to a VM instance. The name must
               be 1-63 characters long, and comply with RFC1035. The name
               must be unique within the subnetwork.
        """
        pulumi.set(__self__, "ip_cidr_range", ip_cidr_range)
        pulumi.set(__self__, "range_name", range_name)

    @property
    @pulumi.getter(name="ipCidrRange")
    def ip_cidr_range(self) -> pulumi.Input[str]:
        """
        The range of IP addresses belonging to this subnetwork secondary
        range. Provide this property when you create the subnetwork.
        Ranges must be unique and non-overlapping with all primary and
        secondary IP ranges within a network. Only IPv4 is supported.
        """
        return pulumi.get(self, "ip_cidr_range")

    @ip_cidr_range.setter
    def ip_cidr_range(self, value: pulumi.Input[str]):
        pulumi.set(self, "ip_cidr_range", value)

    @property
    @pulumi.getter(name="rangeName")
    def range_name(self) -> pulumi.Input[str]:
        """
        The name associated with this subnetwork secondary range, used
        when adding an alias IP range to a VM instance. The name must
        be 1-63 characters long, and comply with RFC1035. The name
        must be unique within the subnetwork.
        """
        return pulumi.get(self, "range_name")

    @range_name.setter
    def range_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "range_name", value)


@pulumi.input_type
class URLMapDefaultRouteActionArgs:
    def __init__(__self__, *,
                 cors_policy: Optional[pulumi.Input['URLMapDefaultRouteActionCorsPolicyArgs']] = None,
                 fault_injection_policy: Optional[pulumi.Input['URLMapDefaultRouteActionFaultInjectionPolicyArgs']] = None,
                 request_mirror_policy: Optional[pulumi.Input['URLMapDefaultRouteActionRequestMirrorPolicyArgs']] = None,
                 retry_policy: Optional[pulumi.Input['URLMapDefaultRouteActionRetryPolicyArgs']] = None,
                 timeout: Optional[pulumi.Input['URLMapDefaultRouteActionTimeoutArgs']] = None,
                 url_rewrite: Optional[pulumi.Input['URLMapDefaultRouteActionUrlRewriteArgs']] = None,
                 weighted_backend_services: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapDefaultRouteActionWeightedBackendServiceArgs']]]] = None):
        """
        :param pulumi.Input['URLMapDefaultRouteActionCorsPolicyArgs'] cors_policy: The specification for allowing client side cross-origin requests. Please see
               [W3C Recommendation for Cross Origin Resource Sharing](https://www.w3.org/TR/cors/)
               Structure is documented below.
        :param pulumi.Input['URLMapDefaultRouteActionFaultInjectionPolicyArgs'] fault_injection_policy: The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure.
               As part of fault injection, when clients send requests to a backend service, delays can be introduced by Loadbalancer on a
               percentage of requests before sending those request to the backend service. Similarly requests from clients can be aborted
               by the Loadbalancer for a percentage of requests.
               timeout and retryPolicy will be ignored by clients that are configured with a faultInjectionPolicy.
               Structure is documented below.
        :param pulumi.Input['URLMapDefaultRouteActionRequestMirrorPolicyArgs'] request_mirror_policy: Specifies the policy on how requests intended for the route's backends are shadowed to a separate mirrored backend service.
               Loadbalancer does not wait for responses from the shadow service. Prior to sending traffic to the shadow service,
               the host / authority header is suffixed with -shadow.
               Structure is documented below.
        :param pulumi.Input['URLMapDefaultRouteActionRetryPolicyArgs'] retry_policy: Specifies the retry policy associated with this route.
               Structure is documented below.
        :param pulumi.Input['URLMapDefaultRouteActionTimeoutArgs'] timeout: Specifies the timeout for the selected route. Timeout is computed from the time the request has been
               fully processed (i.e. end-of-stream) up until the response has been completely processed. Timeout includes all retries.
               If not specified, will use the largest timeout among all backend services associated with the route.
               Structure is documented below.
        :param pulumi.Input['URLMapDefaultRouteActionUrlRewriteArgs'] url_rewrite: The spec to modify the URL of the request, prior to forwarding the request to the matched service.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['URLMapDefaultRouteActionWeightedBackendServiceArgs']]] weighted_backend_services: A list of weighted backend services to send traffic to when a route match occurs.
               The weights determine the fraction of traffic that flows to their corresponding backend service.
               If all traffic needs to go to a single backend service, there must be one weightedBackendService
               with weight set to a non 0 number.
               Once a backendService is identified and before forwarding the request to the backend service,
               advanced routing actions like Url rewrites and header transformations are applied depending on
               additional settings specified in this HttpRouteAction.
               Structure is documented below.
        """
        if cors_policy is not None:
            pulumi.set(__self__, "cors_policy", cors_policy)
        if fault_injection_policy is not None:
            pulumi.set(__self__, "fault_injection_policy", fault_injection_policy)
        if request_mirror_policy is not None:
            pulumi.set(__self__, "request_mirror_policy", request_mirror_policy)
        if retry_policy is not None:
            pulumi.set(__self__, "retry_policy", retry_policy)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)
        if url_rewrite is not None:
            pulumi.set(__self__, "url_rewrite", url_rewrite)
        if weighted_backend_services is not None:
            pulumi.set(__self__, "weighted_backend_services", weighted_backend_services)

    @property
    @pulumi.getter(name="corsPolicy")
    def cors_policy(self) -> Optional[pulumi.Input['URLMapDefaultRouteActionCorsPolicyArgs']]:
        """
        The specification for allowing client side cross-origin requests. Please see
        [W3C Recommendation for Cross Origin Resource Sharing](https://www.w3.org/TR/cors/)
        Structure is documented below.
        """
        return pulumi.get(self, "cors_policy")

    @cors_policy.setter
    def cors_policy(self, value: Optional[pulumi.Input['URLMapDefaultRouteActionCorsPolicyArgs']]):
        pulumi.set(self, "cors_policy", value)

    @property
    @pulumi.getter(name="faultInjectionPolicy")
    def fault_injection_policy(self) -> Optional[pulumi.Input['URLMapDefaultRouteActionFaultInjectionPolicyArgs']]:
        """
        The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure.
        As part of fault injection, when clients send requests to a backend service, delays can be introduced by Loadbalancer on a
        percentage of requests before sending those request to the backend service. Similarly requests from clients can be aborted
        by the Loadbalancer for a percentage of requests.
        timeout and retryPolicy will be ignored by clients that are configured with a faultInjectionPolicy.
        Structure is documented below.
        """
        return pulumi.get(self, "fault_injection_policy")

    @fault_injection_policy.setter
    def fault_injection_policy(self, value: Optional[pulumi.Input['URLMapDefaultRouteActionFaultInjectionPolicyArgs']]):
        pulumi.set(self, "fault_injection_policy", value)

    @property
    @pulumi.getter(name="requestMirrorPolicy")
    def request_mirror_policy(self) -> Optional[pulumi.Input['URLMapDefaultRouteActionRequestMirrorPolicyArgs']]:
        """
        Specifies the policy on how requests intended for the route's backends are shadowed to a separate mirrored backend service.
        Loadbalancer does not wait for responses from the shadow service. Prior to sending traffic to the shadow service,
        the host / authority header is suffixed with -shadow.
        Structure is documented below.
        """
        return pulumi.get(self, "request_mirror_policy")

    @request_mirror_policy.setter
    def request_mirror_policy(self, value: Optional[pulumi.Input['URLMapDefaultRouteActionRequestMirrorPolicyArgs']]):
        pulumi.set(self, "request_mirror_policy", value)

    @property
    @pulumi.getter(name="retryPolicy")
    def retry_policy(self) -> Optional[pulumi.Input['URLMapDefaultRouteActionRetryPolicyArgs']]:
        """
        Specifies the retry policy associated with this route.
        Structure is documented below.
        """
        return pulumi.get(self, "retry_policy")

    @retry_policy.setter
    def retry_policy(self, value: Optional[pulumi.Input['URLMapDefaultRouteActionRetryPolicyArgs']]):
        pulumi.set(self, "retry_policy", value)

    @property
    @pulumi.getter
    def timeout(self) -> Optional[pulumi.Input['URLMapDefaultRouteActionTimeoutArgs']]:
        """
        Specifies the timeout for the selected route. Timeout is computed from the time the request has been
        fully processed (i.e. end-of-stream) up until the response has been completely processed. Timeout includes all retries.
        If not specified, will use the largest timeout among all backend services associated with the route.
        Structure is documented below.
        """
        return pulumi.get(self, "timeout")

    @timeout.setter
    def timeout(self, value: Optional[pulumi.Input['URLMapDefaultRouteActionTimeoutArgs']]):
        pulumi.set(self, "timeout", value)

    @property
    @pulumi.getter(name="urlRewrite")
    def url_rewrite(self) -> Optional[pulumi.Input['URLMapDefaultRouteActionUrlRewriteArgs']]:
        """
        The spec to modify the URL of the request, prior to forwarding the request to the matched service.
        Structure is documented below.
        """
        return pulumi.get(self, "url_rewrite")

    @url_rewrite.setter
    def url_rewrite(self, value: Optional[pulumi.Input['URLMapDefaultRouteActionUrlRewriteArgs']]):
        pulumi.set(self, "url_rewrite", value)

    @property
    @pulumi.getter(name="weightedBackendServices")
    def weighted_backend_services(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapDefaultRouteActionWeightedBackendServiceArgs']]]]:
        """
        A list of weighted backend services to send traffic to when a route match occurs.
        The weights determine the fraction of traffic that flows to their corresponding backend service.
        If all traffic needs to go to a single backend service, there must be one weightedBackendService
        with weight set to a non 0 number.
        Once a backendService is identified and before forwarding the request to the backend service,
        advanced routing actions like Url rewrites and header transformations are applied depending on
        additional settings specified in this HttpRouteAction.
        Structure is documented below.
        """
        return pulumi.get(self, "weighted_backend_services")

    @weighted_backend_services.setter
    def weighted_backend_services(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapDefaultRouteActionWeightedBackendServiceArgs']]]]):
        pulumi.set(self, "weighted_backend_services", value)


@pulumi.input_type
class URLMapDefaultRouteActionCorsPolicyArgs:
    def __init__(__self__, *,
                 allow_credentials: Optional[pulumi.Input[bool]] = None,
                 allow_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_methods: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_origin_regexes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_origins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 disabled: Optional[pulumi.Input[bool]] = None,
                 expose_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 max_age: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[bool] allow_credentials: In response to a preflight request, setting this to true indicates that the actual request can include user credentials.
               This translates to the Access-Control-Allow-Credentials header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_headers: Specifies the content for the Access-Control-Allow-Headers header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_methods: Specifies the content for the Access-Control-Allow-Methods header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_origin_regexes: Specifies the regular expression patterns that match allowed origins. For regular expression grammar
               please see en.cppreference.com/w/cpp/regex/ecmascript
               An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_origins: Specifies the list of origins that will be allowed to do CORS requests.
               An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.
        :param pulumi.Input[bool] disabled: If true, specifies the CORS policy is disabled. The default value is false, which indicates that the CORS policy is in effect.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] expose_headers: Specifies the content for the Access-Control-Expose-Headers header.
        :param pulumi.Input[int] max_age: Specifies how long results of a preflight request can be cached in seconds.
               This translates to the Access-Control-Max-Age header.
        """
        if allow_credentials is not None:
            pulumi.set(__self__, "allow_credentials", allow_credentials)
        if allow_headers is not None:
            pulumi.set(__self__, "allow_headers", allow_headers)
        if allow_methods is not None:
            pulumi.set(__self__, "allow_methods", allow_methods)
        if allow_origin_regexes is not None:
            pulumi.set(__self__, "allow_origin_regexes", allow_origin_regexes)
        if allow_origins is not None:
            pulumi.set(__self__, "allow_origins", allow_origins)
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)
        if expose_headers is not None:
            pulumi.set(__self__, "expose_headers", expose_headers)
        if max_age is not None:
            pulumi.set(__self__, "max_age", max_age)

    @property
    @pulumi.getter(name="allowCredentials")
    def allow_credentials(self) -> Optional[pulumi.Input[bool]]:
        """
        In response to a preflight request, setting this to true indicates that the actual request can include user credentials.
        This translates to the Access-Control-Allow-Credentials header.
        """
        return pulumi.get(self, "allow_credentials")

    @allow_credentials.setter
    def allow_credentials(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_credentials", value)

    @property
    @pulumi.getter(name="allowHeaders")
    def allow_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for the Access-Control-Allow-Headers header.
        """
        return pulumi.get(self, "allow_headers")

    @allow_headers.setter
    def allow_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_headers", value)

    @property
    @pulumi.getter(name="allowMethods")
    def allow_methods(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for the Access-Control-Allow-Methods header.
        """
        return pulumi.get(self, "allow_methods")

    @allow_methods.setter
    def allow_methods(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_methods", value)

    @property
    @pulumi.getter(name="allowOriginRegexes")
    def allow_origin_regexes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the regular expression patterns that match allowed origins. For regular expression grammar
        please see en.cppreference.com/w/cpp/regex/ecmascript
        An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.
        """
        return pulumi.get(self, "allow_origin_regexes")

    @allow_origin_regexes.setter
    def allow_origin_regexes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_origin_regexes", value)

    @property
    @pulumi.getter(name="allowOrigins")
    def allow_origins(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the list of origins that will be allowed to do CORS requests.
        An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.
        """
        return pulumi.get(self, "allow_origins")

    @allow_origins.setter
    def allow_origins(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_origins", value)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        If true, specifies the CORS policy is disabled. The default value is false, which indicates that the CORS policy is in effect.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)

    @property
    @pulumi.getter(name="exposeHeaders")
    def expose_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for the Access-Control-Expose-Headers header.
        """
        return pulumi.get(self, "expose_headers")

    @expose_headers.setter
    def expose_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "expose_headers", value)

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies how long results of a preflight request can be cached in seconds.
        This translates to the Access-Control-Max-Age header.
        """
        return pulumi.get(self, "max_age")

    @max_age.setter
    def max_age(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_age", value)


@pulumi.input_type
class URLMapDefaultRouteActionFaultInjectionPolicyArgs:
    def __init__(__self__, *,
                 abort: Optional[pulumi.Input['URLMapDefaultRouteActionFaultInjectionPolicyAbortArgs']] = None,
                 delay: Optional[pulumi.Input['URLMapDefaultRouteActionFaultInjectionPolicyDelayArgs']] = None):
        """
        :param pulumi.Input['URLMapDefaultRouteActionFaultInjectionPolicyAbortArgs'] abort: The specification for how client requests are aborted as part of fault injection.
               Structure is documented below.
        :param pulumi.Input['URLMapDefaultRouteActionFaultInjectionPolicyDelayArgs'] delay: The specification for how client requests are delayed as part of fault injection, before being sent to a backend service.
               Structure is documented below.
        """
        if abort is not None:
            pulumi.set(__self__, "abort", abort)
        if delay is not None:
            pulumi.set(__self__, "delay", delay)

    @property
    @pulumi.getter
    def abort(self) -> Optional[pulumi.Input['URLMapDefaultRouteActionFaultInjectionPolicyAbortArgs']]:
        """
        The specification for how client requests are aborted as part of fault injection.
        Structure is documented below.
        """
        return pulumi.get(self, "abort")

    @abort.setter
    def abort(self, value: Optional[pulumi.Input['URLMapDefaultRouteActionFaultInjectionPolicyAbortArgs']]):
        pulumi.set(self, "abort", value)

    @property
    @pulumi.getter
    def delay(self) -> Optional[pulumi.Input['URLMapDefaultRouteActionFaultInjectionPolicyDelayArgs']]:
        """
        The specification for how client requests are delayed as part of fault injection, before being sent to a backend service.
        Structure is documented below.
        """
        return pulumi.get(self, "delay")

    @delay.setter
    def delay(self, value: Optional[pulumi.Input['URLMapDefaultRouteActionFaultInjectionPolicyDelayArgs']]):
        pulumi.set(self, "delay", value)


@pulumi.input_type
class URLMapDefaultRouteActionFaultInjectionPolicyAbortArgs:
    def __init__(__self__, *,
                 http_status: Optional[pulumi.Input[int]] = None,
                 percentage: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[int] http_status: The HTTP status code used to abort the request.
               The value must be between 200 and 599 inclusive.
        :param pulumi.Input[float] percentage: The percentage of traffic (connections/operations/requests) which will be aborted as part of fault injection.
               The value must be between 0.0 and 100.0 inclusive.
        """
        if http_status is not None:
            pulumi.set(__self__, "http_status", http_status)
        if percentage is not None:
            pulumi.set(__self__, "percentage", percentage)

    @property
    @pulumi.getter(name="httpStatus")
    def http_status(self) -> Optional[pulumi.Input[int]]:
        """
        The HTTP status code used to abort the request.
        The value must be between 200 and 599 inclusive.
        """
        return pulumi.get(self, "http_status")

    @http_status.setter
    def http_status(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "http_status", value)

    @property
    @pulumi.getter
    def percentage(self) -> Optional[pulumi.Input[float]]:
        """
        The percentage of traffic (connections/operations/requests) which will be aborted as part of fault injection.
        The value must be between 0.0 and 100.0 inclusive.
        """
        return pulumi.get(self, "percentage")

    @percentage.setter
    def percentage(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "percentage", value)


@pulumi.input_type
class URLMapDefaultRouteActionFaultInjectionPolicyDelayArgs:
    def __init__(__self__, *,
                 fixed_delay: Optional[pulumi.Input['URLMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs']] = None,
                 percentage: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input['URLMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs'] fixed_delay: Specifies the value of the fixed delay interval.
               Structure is documented below.
        :param pulumi.Input[float] percentage: The percentage of traffic (connections/operations/requests) which will be aborted as part of fault injection.
               The value must be between 0.0 and 100.0 inclusive.
        """
        if fixed_delay is not None:
            pulumi.set(__self__, "fixed_delay", fixed_delay)
        if percentage is not None:
            pulumi.set(__self__, "percentage", percentage)

    @property
    @pulumi.getter(name="fixedDelay")
    def fixed_delay(self) -> Optional[pulumi.Input['URLMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs']]:
        """
        Specifies the value of the fixed delay interval.
        Structure is documented below.
        """
        return pulumi.get(self, "fixed_delay")

    @fixed_delay.setter
    def fixed_delay(self, value: Optional[pulumi.Input['URLMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs']]):
        pulumi.set(self, "fixed_delay", value)

    @property
    @pulumi.getter
    def percentage(self) -> Optional[pulumi.Input[float]]:
        """
        The percentage of traffic (connections/operations/requests) which will be aborted as part of fault injection.
        The value must be between 0.0 and 100.0 inclusive.
        """
        return pulumi.get(self, "percentage")

    @percentage.setter
    def percentage(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "percentage", value)


@pulumi.input_type
class URLMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs:
    def __init__(__self__, *,
                 nanos: Optional[pulumi.Input[int]] = None,
                 seconds: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
               represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        :param pulumi.Input[str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
               Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        """
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
        represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)

    @property
    @pulumi.getter
    def seconds(self) -> Optional[pulumi.Input[str]]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
        Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "seconds", value)


@pulumi.input_type
class URLMapDefaultRouteActionRequestMirrorPolicyArgs:
    def __init__(__self__, *,
                 backend_service: pulumi.Input[str]):
        """
        :param pulumi.Input[str] backend_service: The full or partial URL to the BackendService resource being mirrored to.
        """
        pulumi.set(__self__, "backend_service", backend_service)

    @property
    @pulumi.getter(name="backendService")
    def backend_service(self) -> pulumi.Input[str]:
        """
        The full or partial URL to the BackendService resource being mirrored to.
        """
        return pulumi.get(self, "backend_service")

    @backend_service.setter
    def backend_service(self, value: pulumi.Input[str]):
        pulumi.set(self, "backend_service", value)


@pulumi.input_type
class URLMapDefaultRouteActionRetryPolicyArgs:
    def __init__(__self__, *,
                 num_retries: Optional[pulumi.Input[int]] = None,
                 per_try_timeout: Optional[pulumi.Input['URLMapDefaultRouteActionRetryPolicyPerTryTimeoutArgs']] = None,
                 retry_conditions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[int] num_retries: Specifies the allowed number retries. This number must be > 0. If not specified, defaults to 1.
        :param pulumi.Input['URLMapDefaultRouteActionRetryPolicyPerTryTimeoutArgs'] per_try_timeout: Specifies a non-zero timeout per retry attempt.
               If not specified, will use the timeout set in HttpRouteAction. If timeout in HttpRouteAction is not set,
               will use the largest timeout among all backend services associated with the route.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] retry_conditions: Specfies one or more conditions when this retry rule applies. Valid values are:
               * 5xx: Loadbalancer will attempt a retry if the backend service responds with any 5xx response code,
               or if the backend service does not respond at all, example: disconnects, reset, read timeout,
               * connection failure, and refused streams.
               * gateway-error: Similar to 5xx, but only applies to response codes 502, 503 or 504.
               * connect-failure: Loadbalancer will retry on failures connecting to backend services,
               for example due to connection timeouts.
               * retriable-4xx: Loadbalancer will retry for retriable 4xx response codes.
               Currently the only retriable error supported is 409.
               * refused-stream:Loadbalancer will retry if the backend service resets the stream with a REFUSED_STREAM error code.
               This reset type indicates that it is safe to retry.
               * cancelled: Loadbalancer will retry if the gRPC status code in the response header is set to cancelled
               * deadline-exceeded: Loadbalancer will retry if the gRPC status code in the response header is set to deadline-exceeded
               * resource-exhausted: Loadbalancer will retry if the gRPC status code in the response header is set to resource-exhausted
               * unavailable: Loadbalancer will retry if the gRPC status code in the response header is set to unavailable
        """
        if num_retries is not None:
            pulumi.set(__self__, "num_retries", num_retries)
        if per_try_timeout is not None:
            pulumi.set(__self__, "per_try_timeout", per_try_timeout)
        if retry_conditions is not None:
            pulumi.set(__self__, "retry_conditions", retry_conditions)

    @property
    @pulumi.getter(name="numRetries")
    def num_retries(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the allowed number retries. This number must be > 0. If not specified, defaults to 1.
        """
        return pulumi.get(self, "num_retries")

    @num_retries.setter
    def num_retries(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "num_retries", value)

    @property
    @pulumi.getter(name="perTryTimeout")
    def per_try_timeout(self) -> Optional[pulumi.Input['URLMapDefaultRouteActionRetryPolicyPerTryTimeoutArgs']]:
        """
        Specifies a non-zero timeout per retry attempt.
        If not specified, will use the timeout set in HttpRouteAction. If timeout in HttpRouteAction is not set,
        will use the largest timeout among all backend services associated with the route.
        Structure is documented below.
        """
        return pulumi.get(self, "per_try_timeout")

    @per_try_timeout.setter
    def per_try_timeout(self, value: Optional[pulumi.Input['URLMapDefaultRouteActionRetryPolicyPerTryTimeoutArgs']]):
        pulumi.set(self, "per_try_timeout", value)

    @property
    @pulumi.getter(name="retryConditions")
    def retry_conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specfies one or more conditions when this retry rule applies. Valid values are:
        * 5xx: Loadbalancer will attempt a retry if the backend service responds with any 5xx response code,
        or if the backend service does not respond at all, example: disconnects, reset, read timeout,
        * connection failure, and refused streams.
        * gateway-error: Similar to 5xx, but only applies to response codes 502, 503 or 504.
        * connect-failure: Loadbalancer will retry on failures connecting to backend services,
        for example due to connection timeouts.
        * retriable-4xx: Loadbalancer will retry for retriable 4xx response codes.
        Currently the only retriable error supported is 409.
        * refused-stream:Loadbalancer will retry if the backend service resets the stream with a REFUSED_STREAM error code.
        This reset type indicates that it is safe to retry.
        * cancelled: Loadbalancer will retry if the gRPC status code in the response header is set to cancelled
        * deadline-exceeded: Loadbalancer will retry if the gRPC status code in the response header is set to deadline-exceeded
        * resource-exhausted: Loadbalancer will retry if the gRPC status code in the response header is set to resource-exhausted
        * unavailable: Loadbalancer will retry if the gRPC status code in the response header is set to unavailable
        """
        return pulumi.get(self, "retry_conditions")

    @retry_conditions.setter
    def retry_conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "retry_conditions", value)


@pulumi.input_type
class URLMapDefaultRouteActionRetryPolicyPerTryTimeoutArgs:
    def __init__(__self__, *,
                 nanos: Optional[pulumi.Input[int]] = None,
                 seconds: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
               represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        :param pulumi.Input[str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
               Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        """
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
        represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)

    @property
    @pulumi.getter
    def seconds(self) -> Optional[pulumi.Input[str]]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
        Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "seconds", value)


@pulumi.input_type
class URLMapDefaultRouteActionTimeoutArgs:
    def __init__(__self__, *,
                 nanos: Optional[pulumi.Input[int]] = None,
                 seconds: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
               represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        :param pulumi.Input[str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
               Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        """
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
        represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)

    @property
    @pulumi.getter
    def seconds(self) -> Optional[pulumi.Input[str]]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
        Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "seconds", value)


@pulumi.input_type
class URLMapDefaultRouteActionUrlRewriteArgs:
    def __init__(__self__, *,
                 host_rewrite: Optional[pulumi.Input[str]] = None,
                 path_prefix_rewrite: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host_rewrite: Prior to forwarding the request to the selected service, the request's host header is replaced
               with contents of hostRewrite.
               The value must be between 1 and 255 characters.
        :param pulumi.Input[str] path_prefix_rewrite: Prior to forwarding the request to the selected backend service, the matching portion of the
               request's path is replaced by pathPrefixRewrite.
               The value must be between 1 and 1024 characters.
        """
        if host_rewrite is not None:
            pulumi.set(__self__, "host_rewrite", host_rewrite)
        if path_prefix_rewrite is not None:
            pulumi.set(__self__, "path_prefix_rewrite", path_prefix_rewrite)

    @property
    @pulumi.getter(name="hostRewrite")
    def host_rewrite(self) -> Optional[pulumi.Input[str]]:
        """
        Prior to forwarding the request to the selected service, the request's host header is replaced
        with contents of hostRewrite.
        The value must be between 1 and 255 characters.
        """
        return pulumi.get(self, "host_rewrite")

    @host_rewrite.setter
    def host_rewrite(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_rewrite", value)

    @property
    @pulumi.getter(name="pathPrefixRewrite")
    def path_prefix_rewrite(self) -> Optional[pulumi.Input[str]]:
        """
        Prior to forwarding the request to the selected backend service, the matching portion of the
        request's path is replaced by pathPrefixRewrite.
        The value must be between 1 and 1024 characters.
        """
        return pulumi.get(self, "path_prefix_rewrite")

    @path_prefix_rewrite.setter
    def path_prefix_rewrite(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path_prefix_rewrite", value)


@pulumi.input_type
class URLMapDefaultRouteActionWeightedBackendServiceArgs:
    def __init__(__self__, *,
                 backend_service: Optional[pulumi.Input[str]] = None,
                 header_action: Optional[pulumi.Input['URLMapDefaultRouteActionWeightedBackendServiceHeaderActionArgs']] = None,
                 weight: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] backend_service: The full or partial URL to the BackendService resource being mirrored to.
        :param pulumi.Input['URLMapDefaultRouteActionWeightedBackendServiceHeaderActionArgs'] header_action: Specifies changes to request and response headers that need to take effect for
               the selected backendService.
               headerAction specified here take effect before headerAction in the enclosing
               HttpRouteRule, PathMatcher and UrlMap.
               Structure is documented below.
        :param pulumi.Input[int] weight: Specifies the fraction of traffic sent to backendService, computed as
               weight / (sum of all weightedBackendService weights in routeAction) .
               The selection of a backend service is determined only for new traffic. Once a user's request
               has been directed to a backendService, subsequent requests will be sent to the same backendService
               as determined by the BackendService's session affinity policy.
               The value must be between 0 and 1000
        """
        if backend_service is not None:
            pulumi.set(__self__, "backend_service", backend_service)
        if header_action is not None:
            pulumi.set(__self__, "header_action", header_action)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter(name="backendService")
    def backend_service(self) -> Optional[pulumi.Input[str]]:
        """
        The full or partial URL to the BackendService resource being mirrored to.
        """
        return pulumi.get(self, "backend_service")

    @backend_service.setter
    def backend_service(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "backend_service", value)

    @property
    @pulumi.getter(name="headerAction")
    def header_action(self) -> Optional[pulumi.Input['URLMapDefaultRouteActionWeightedBackendServiceHeaderActionArgs']]:
        """
        Specifies changes to request and response headers that need to take effect for
        the selected backendService.
        headerAction specified here take effect before headerAction in the enclosing
        HttpRouteRule, PathMatcher and UrlMap.
        Structure is documented below.
        """
        return pulumi.get(self, "header_action")

    @header_action.setter
    def header_action(self, value: Optional[pulumi.Input['URLMapDefaultRouteActionWeightedBackendServiceHeaderActionArgs']]):
        pulumi.set(self, "header_action", value)

    @property
    @pulumi.getter
    def weight(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the fraction of traffic sent to backendService, computed as
        weight / (sum of all weightedBackendService weights in routeAction) .
        The selection of a backend service is determined only for new traffic. Once a user's request
        has been directed to a backendService, subsequent requests will be sent to the same backendService
        as determined by the BackendService's session affinity policy.
        The value must be between 0 and 1000
        """
        return pulumi.get(self, "weight")

    @weight.setter
    def weight(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "weight", value)


@pulumi.input_type
class URLMapDefaultRouteActionWeightedBackendServiceHeaderActionArgs:
    def __init__(__self__, *,
                 request_headers_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]]] = None,
                 request_headers_to_removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 response_headers_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]]] = None,
                 response_headers_to_removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['URLMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]] request_headers_to_adds: Headers to add to a matching request prior to forwarding the request to the backendService.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] request_headers_to_removes: A list of header names for headers that need to be removed from the request prior to
               forwarding the request to the backendService.
        :param pulumi.Input[Sequence[pulumi.Input['URLMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]] response_headers_to_adds: Headers to add the response prior to sending the response back to the client.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] response_headers_to_removes: A list of header names for headers that need to be removed from the response prior to sending the
               response back to the client.
        """
        if request_headers_to_adds is not None:
            pulumi.set(__self__, "request_headers_to_adds", request_headers_to_adds)
        if request_headers_to_removes is not None:
            pulumi.set(__self__, "request_headers_to_removes", request_headers_to_removes)
        if response_headers_to_adds is not None:
            pulumi.set(__self__, "response_headers_to_adds", response_headers_to_adds)
        if response_headers_to_removes is not None:
            pulumi.set(__self__, "response_headers_to_removes", response_headers_to_removes)

    @property
    @pulumi.getter(name="requestHeadersToAdds")
    def request_headers_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]]]:
        """
        Headers to add to a matching request prior to forwarding the request to the backendService.
        Structure is documented below.
        """
        return pulumi.get(self, "request_headers_to_adds")

    @request_headers_to_adds.setter
    def request_headers_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]]]):
        pulumi.set(self, "request_headers_to_adds", value)

    @property
    @pulumi.getter(name="requestHeadersToRemoves")
    def request_headers_to_removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of header names for headers that need to be removed from the request prior to
        forwarding the request to the backendService.
        """
        return pulumi.get(self, "request_headers_to_removes")

    @request_headers_to_removes.setter
    def request_headers_to_removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "request_headers_to_removes", value)

    @property
    @pulumi.getter(name="responseHeadersToAdds")
    def response_headers_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]]]:
        """
        Headers to add the response prior to sending the response back to the client.
        Structure is documented below.
        """
        return pulumi.get(self, "response_headers_to_adds")

    @response_headers_to_adds.setter
    def response_headers_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]]]):
        pulumi.set(self, "response_headers_to_adds", value)

    @property
    @pulumi.getter(name="responseHeadersToRemoves")
    def response_headers_to_removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of header names for headers that need to be removed from the response prior to sending the
        response back to the client.
        """
        return pulumi.get(self, "response_headers_to_removes")

    @response_headers_to_removes.setter
    def response_headers_to_removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "response_headers_to_removes", value)


@pulumi.input_type
class URLMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs:
    def __init__(__self__, *,
                 header_name: Optional[pulumi.Input[str]] = None,
                 header_value: Optional[pulumi.Input[str]] = None,
                 replace: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] header_name: The name of the header to add.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: If false, headerValue is appended to any values that already exist for the header.
               If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        if header_name is not None:
            pulumi.set(__self__, "header_name", header_name)
        if header_value is not None:
            pulumi.set(__self__, "header_value", header_value)
        if replace is not None:
            pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> Optional[pulumi.Input[bool]]:
        """
        If false, headerValue is appended to any values that already exist for the header.
        If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class URLMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs:
    def __init__(__self__, *,
                 header_name: Optional[pulumi.Input[str]] = None,
                 header_value: Optional[pulumi.Input[str]] = None,
                 replace: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] header_name: The name of the header to add.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: If false, headerValue is appended to any values that already exist for the header.
               If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        if header_name is not None:
            pulumi.set(__self__, "header_name", header_name)
        if header_value is not None:
            pulumi.set(__self__, "header_value", header_value)
        if replace is not None:
            pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> Optional[pulumi.Input[bool]]:
        """
        If false, headerValue is appended to any values that already exist for the header.
        If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class URLMapDefaultUrlRedirectArgs:
    def __init__(__self__, *,
                 strip_query: pulumi.Input[bool],
                 host_redirect: Optional[pulumi.Input[str]] = None,
                 https_redirect: Optional[pulumi.Input[bool]] = None,
                 path_redirect: Optional[pulumi.Input[str]] = None,
                 prefix_redirect: Optional[pulumi.Input[str]] = None,
                 redirect_response_code: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] strip_query: If set to true, any accompanying query portion of the original URL is removed prior
               to redirecting the request. If set to false, the query portion of the original URL is
               retained. The default is set to false.
               This field is required to ensure an empty block is not set. The normal default value is false.
        :param pulumi.Input[str] host_redirect: The host that will be used in the redirect response instead of the one that was
               supplied in the request. The value must be between 1 and 255 characters.
        :param pulumi.Input[bool] https_redirect: If set to true, the URL scheme in the redirected request is set to https. If set to
               false, the URL scheme of the redirected request will remain the same as that of the
               request. This must only be set for UrlMaps used in TargetHttpProxys. Setting this
               true for TargetHttpsProxy is not permitted. The default is set to false.
        :param pulumi.Input[str] path_redirect: The path that will be used in the redirect response instead of the one that was
               supplied in the request. pathRedirect cannot be supplied together with
               prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the
               original request will be used for the redirect. The value must be between 1 and 1024
               characters.
        :param pulumi.Input[str] prefix_redirect: The prefix that replaces the prefixMatch specified in the HttpRouteRuleMatch,
               retaining the remaining portion of the URL before redirecting the request.
               prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or
               neither. If neither is supplied, the path of the original request will be used for
               the redirect. The value must be between 1 and 1024 characters.
        :param pulumi.Input[str] redirect_response_code: The HTTP Status code to use for this RedirectAction. Supported values are:
               * MOVED_PERMANENTLY_DEFAULT, which is the default value and corresponds to 301.
               * FOUND, which corresponds to 302.
               * SEE_OTHER which corresponds to 303.
               * TEMPORARY_REDIRECT, which corresponds to 307. In this case, the request method
               will be retained.
               * PERMANENT_REDIRECT, which corresponds to 308. In this case,
               the request method will be retained.
        """
        pulumi.set(__self__, "strip_query", strip_query)
        if host_redirect is not None:
            pulumi.set(__self__, "host_redirect", host_redirect)
        if https_redirect is not None:
            pulumi.set(__self__, "https_redirect", https_redirect)
        if path_redirect is not None:
            pulumi.set(__self__, "path_redirect", path_redirect)
        if prefix_redirect is not None:
            pulumi.set(__self__, "prefix_redirect", prefix_redirect)
        if redirect_response_code is not None:
            pulumi.set(__self__, "redirect_response_code", redirect_response_code)

    @property
    @pulumi.getter(name="stripQuery")
    def strip_query(self) -> pulumi.Input[bool]:
        """
        If set to true, any accompanying query portion of the original URL is removed prior
        to redirecting the request. If set to false, the query portion of the original URL is
        retained. The default is set to false.
        This field is required to ensure an empty block is not set. The normal default value is false.
        """
        return pulumi.get(self, "strip_query")

    @strip_query.setter
    def strip_query(self, value: pulumi.Input[bool]):
        pulumi.set(self, "strip_query", value)

    @property
    @pulumi.getter(name="hostRedirect")
    def host_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The host that will be used in the redirect response instead of the one that was
        supplied in the request. The value must be between 1 and 255 characters.
        """
        return pulumi.get(self, "host_redirect")

    @host_redirect.setter
    def host_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_redirect", value)

    @property
    @pulumi.getter(name="httpsRedirect")
    def https_redirect(self) -> Optional[pulumi.Input[bool]]:
        """
        If set to true, the URL scheme in the redirected request is set to https. If set to
        false, the URL scheme of the redirected request will remain the same as that of the
        request. This must only be set for UrlMaps used in TargetHttpProxys. Setting this
        true for TargetHttpsProxy is not permitted. The default is set to false.
        """
        return pulumi.get(self, "https_redirect")

    @https_redirect.setter
    def https_redirect(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "https_redirect", value)

    @property
    @pulumi.getter(name="pathRedirect")
    def path_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The path that will be used in the redirect response instead of the one that was
        supplied in the request. pathRedirect cannot be supplied together with
        prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the
        original request will be used for the redirect. The value must be between 1 and 1024
        characters.
        """
        return pulumi.get(self, "path_redirect")

    @path_redirect.setter
    def path_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path_redirect", value)

    @property
    @pulumi.getter(name="prefixRedirect")
    def prefix_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The prefix that replaces the prefixMatch specified in the HttpRouteRuleMatch,
        retaining the remaining portion of the URL before redirecting the request.
        prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or
        neither. If neither is supplied, the path of the original request will be used for
        the redirect. The value must be between 1 and 1024 characters.
        """
        return pulumi.get(self, "prefix_redirect")

    @prefix_redirect.setter
    def prefix_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "prefix_redirect", value)

    @property
    @pulumi.getter(name="redirectResponseCode")
    def redirect_response_code(self) -> Optional[pulumi.Input[str]]:
        """
        The HTTP Status code to use for this RedirectAction. Supported values are:
        * MOVED_PERMANENTLY_DEFAULT, which is the default value and corresponds to 301.
        * FOUND, which corresponds to 302.
        * SEE_OTHER which corresponds to 303.
        * TEMPORARY_REDIRECT, which corresponds to 307. In this case, the request method
        will be retained.
        * PERMANENT_REDIRECT, which corresponds to 308. In this case,
        the request method will be retained.
        """
        return pulumi.get(self, "redirect_response_code")

    @redirect_response_code.setter
    def redirect_response_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "redirect_response_code", value)


@pulumi.input_type
class URLMapHeaderActionArgs:
    def __init__(__self__, *,
                 request_headers_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapHeaderActionRequestHeadersToAddArgs']]]] = None,
                 request_headers_to_removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 response_headers_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapHeaderActionResponseHeadersToAddArgs']]]] = None,
                 response_headers_to_removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['URLMapHeaderActionRequestHeadersToAddArgs']]] request_headers_to_adds: Headers to add to a matching request prior to forwarding the request to the backendService.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] request_headers_to_removes: A list of header names for headers that need to be removed from the request prior to
               forwarding the request to the backendService.
        :param pulumi.Input[Sequence[pulumi.Input['URLMapHeaderActionResponseHeadersToAddArgs']]] response_headers_to_adds: Headers to add the response prior to sending the response back to the client.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] response_headers_to_removes: A list of header names for headers that need to be removed from the response prior to sending the
               response back to the client.
        """
        if request_headers_to_adds is not None:
            pulumi.set(__self__, "request_headers_to_adds", request_headers_to_adds)
        if request_headers_to_removes is not None:
            pulumi.set(__self__, "request_headers_to_removes", request_headers_to_removes)
        if response_headers_to_adds is not None:
            pulumi.set(__self__, "response_headers_to_adds", response_headers_to_adds)
        if response_headers_to_removes is not None:
            pulumi.set(__self__, "response_headers_to_removes", response_headers_to_removes)

    @property
    @pulumi.getter(name="requestHeadersToAdds")
    def request_headers_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapHeaderActionRequestHeadersToAddArgs']]]]:
        """
        Headers to add to a matching request prior to forwarding the request to the backendService.
        Structure is documented below.
        """
        return pulumi.get(self, "request_headers_to_adds")

    @request_headers_to_adds.setter
    def request_headers_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapHeaderActionRequestHeadersToAddArgs']]]]):
        pulumi.set(self, "request_headers_to_adds", value)

    @property
    @pulumi.getter(name="requestHeadersToRemoves")
    def request_headers_to_removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of header names for headers that need to be removed from the request prior to
        forwarding the request to the backendService.
        """
        return pulumi.get(self, "request_headers_to_removes")

    @request_headers_to_removes.setter
    def request_headers_to_removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "request_headers_to_removes", value)

    @property
    @pulumi.getter(name="responseHeadersToAdds")
    def response_headers_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapHeaderActionResponseHeadersToAddArgs']]]]:
        """
        Headers to add the response prior to sending the response back to the client.
        Structure is documented below.
        """
        return pulumi.get(self, "response_headers_to_adds")

    @response_headers_to_adds.setter
    def response_headers_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapHeaderActionResponseHeadersToAddArgs']]]]):
        pulumi.set(self, "response_headers_to_adds", value)

    @property
    @pulumi.getter(name="responseHeadersToRemoves")
    def response_headers_to_removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of header names for headers that need to be removed from the response prior to sending the
        response back to the client.
        """
        return pulumi.get(self, "response_headers_to_removes")

    @response_headers_to_removes.setter
    def response_headers_to_removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "response_headers_to_removes", value)


@pulumi.input_type
class URLMapHeaderActionRequestHeadersToAddArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 header_value: pulumi.Input[str],
                 replace: pulumi.Input[bool]):
        """
        :param pulumi.Input[str] header_name: The name of the header to add.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: If false, headerValue is appended to any values that already exist for the header.
               If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)
        pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> pulumi.Input[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> pulumi.Input[bool]:
        """
        If false, headerValue is appended to any values that already exist for the header.
        If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: pulumi.Input[bool]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class URLMapHeaderActionResponseHeadersToAddArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 header_value: pulumi.Input[str],
                 replace: pulumi.Input[bool]):
        """
        :param pulumi.Input[str] header_name: The name of the header to add.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: If false, headerValue is appended to any values that already exist for the header.
               If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)
        pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> pulumi.Input[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> pulumi.Input[bool]:
        """
        If false, headerValue is appended to any values that already exist for the header.
        If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: pulumi.Input[bool]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class URLMapHostRuleArgs:
    def __init__(__self__, *,
                 hosts: pulumi.Input[Sequence[pulumi.Input[str]]],
                 path_matcher: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] hosts: The list of host patterns to match. They must be valid hostnames, except * will
               match any string of ([a-z0-9-.]*). In that case, * must be the first character
               and must be followed in the pattern by either - or ..
        :param pulumi.Input[str] path_matcher: The name of the PathMatcher to use to match the path portion of the URL if the
               hostRule matches the URL's host portion.
        :param pulumi.Input[str] description: Description of this test case.
        """
        pulumi.set(__self__, "hosts", hosts)
        pulumi.set(__self__, "path_matcher", path_matcher)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def hosts(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        The list of host patterns to match. They must be valid hostnames, except * will
        match any string of ([a-z0-9-.]*). In that case, * must be the first character
        and must be followed in the pattern by either - or ..
        """
        return pulumi.get(self, "hosts")

    @hosts.setter
    def hosts(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "hosts", value)

    @property
    @pulumi.getter(name="pathMatcher")
    def path_matcher(self) -> pulumi.Input[str]:
        """
        The name of the PathMatcher to use to match the path portion of the URL if the
        hostRule matches the URL's host portion.
        """
        return pulumi.get(self, "path_matcher")

    @path_matcher.setter
    def path_matcher(self, value: pulumi.Input[str]):
        pulumi.set(self, "path_matcher", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        Description of this test case.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class URLMapPathMatcherArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 default_route_action: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionArgs']] = None,
                 default_service: Optional[pulumi.Input[str]] = None,
                 default_url_redirect: Optional[pulumi.Input['URLMapPathMatcherDefaultUrlRedirectArgs']] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 header_action: Optional[pulumi.Input['URLMapPathMatcherHeaderActionArgs']] = None,
                 path_rules: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherPathRuleArgs']]]] = None,
                 route_rules: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleArgs']]]] = None):
        """
        :param pulumi.Input[str] name: The name of the query parameter to match. The query parameter must exist in the
               request, in the absence of which the request match fails.
        :param pulumi.Input['URLMapPathMatcherDefaultRouteActionArgs'] default_route_action: defaultRouteAction takes effect when none of the pathRules or routeRules match. The load balancer performs
               advanced routing actions like URL rewrites, header transformations, etc. prior to forwarding the request
               to the selected backend. If defaultRouteAction specifies any weightedBackendServices, defaultService must not be set.
               Conversely if defaultService is set, defaultRouteAction cannot contain any weightedBackendServices.
               Only one of defaultRouteAction or defaultUrlRedirect must be set.
               Structure is documented below.
        :param pulumi.Input[str] default_service: The backend service or backend bucket to use when none of the given paths match.
        :param pulumi.Input['URLMapPathMatcherDefaultUrlRedirectArgs'] default_url_redirect: When none of the specified hostRules match, the request is redirected to a URL specified
               by defaultUrlRedirect. If defaultUrlRedirect is specified, defaultService or
               defaultRouteAction must not be set.
               Structure is documented below.
        :param pulumi.Input[str] description: Description of this test case.
        :param pulumi.Input['URLMapPathMatcherHeaderActionArgs'] header_action: Specifies changes to request and response headers that need to take effect for
               the selected backendService.
               headerAction specified here take effect before headerAction in the enclosing
               HttpRouteRule, PathMatcher and UrlMap.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherPathRuleArgs']]] path_rules: The list of path rules. Use this list instead of routeRules when routing based
               on simple path matching is all that's required. The order by which path rules
               are specified does not matter. Matches are always done on the longest-path-first
               basis. For example: a pathRule with a path /a/b/c/* will match before /a/b/*
               irrespective of the order in which those paths appear in this list. Within a
               given pathMatcher, only one of pathRules or routeRules must be set.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleArgs']]] route_rules: The list of ordered HTTP route rules. Use this list instead of pathRules when
               advanced route matching and routing actions are desired. The order of specifying
               routeRules matters: the first rule that matches will cause its specified routing
               action to take effect. Within a given pathMatcher, only one of pathRules or
               routeRules must be set. routeRules are not supported in UrlMaps intended for
               External load balancers.
               Structure is documented below.
        """
        pulumi.set(__self__, "name", name)
        if default_route_action is not None:
            pulumi.set(__self__, "default_route_action", default_route_action)
        if default_service is not None:
            pulumi.set(__self__, "default_service", default_service)
        if default_url_redirect is not None:
            pulumi.set(__self__, "default_url_redirect", default_url_redirect)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if header_action is not None:
            pulumi.set(__self__, "header_action", header_action)
        if path_rules is not None:
            pulumi.set(__self__, "path_rules", path_rules)
        if route_rules is not None:
            pulumi.set(__self__, "route_rules", route_rules)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the query parameter to match. The query parameter must exist in the
        request, in the absence of which the request match fails.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="defaultRouteAction")
    def default_route_action(self) -> Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionArgs']]:
        """
        defaultRouteAction takes effect when none of the pathRules or routeRules match. The load balancer performs
        advanced routing actions like URL rewrites, header transformations, etc. prior to forwarding the request
        to the selected backend. If defaultRouteAction specifies any weightedBackendServices, defaultService must not be set.
        Conversely if defaultService is set, defaultRouteAction cannot contain any weightedBackendServices.
        Only one of defaultRouteAction or defaultUrlRedirect must be set.
        Structure is documented below.
        """
        return pulumi.get(self, "default_route_action")

    @default_route_action.setter
    def default_route_action(self, value: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionArgs']]):
        pulumi.set(self, "default_route_action", value)

    @property
    @pulumi.getter(name="defaultService")
    def default_service(self) -> Optional[pulumi.Input[str]]:
        """
        The backend service or backend bucket to use when none of the given paths match.
        """
        return pulumi.get(self, "default_service")

    @default_service.setter
    def default_service(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "default_service", value)

    @property
    @pulumi.getter(name="defaultUrlRedirect")
    def default_url_redirect(self) -> Optional[pulumi.Input['URLMapPathMatcherDefaultUrlRedirectArgs']]:
        """
        When none of the specified hostRules match, the request is redirected to a URL specified
        by defaultUrlRedirect. If defaultUrlRedirect is specified, defaultService or
        defaultRouteAction must not be set.
        Structure is documented below.
        """
        return pulumi.get(self, "default_url_redirect")

    @default_url_redirect.setter
    def default_url_redirect(self, value: Optional[pulumi.Input['URLMapPathMatcherDefaultUrlRedirectArgs']]):
        pulumi.set(self, "default_url_redirect", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        Description of this test case.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)

    @property
    @pulumi.getter(name="headerAction")
    def header_action(self) -> Optional[pulumi.Input['URLMapPathMatcherHeaderActionArgs']]:
        """
        Specifies changes to request and response headers that need to take effect for
        the selected backendService.
        headerAction specified here take effect before headerAction in the enclosing
        HttpRouteRule, PathMatcher and UrlMap.
        Structure is documented below.
        """
        return pulumi.get(self, "header_action")

    @header_action.setter
    def header_action(self, value: Optional[pulumi.Input['URLMapPathMatcherHeaderActionArgs']]):
        pulumi.set(self, "header_action", value)

    @property
    @pulumi.getter(name="pathRules")
    def path_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherPathRuleArgs']]]]:
        """
        The list of path rules. Use this list instead of routeRules when routing based
        on simple path matching is all that's required. The order by which path rules
        are specified does not matter. Matches are always done on the longest-path-first
        basis. For example: a pathRule with a path /a/b/c/* will match before /a/b/*
        irrespective of the order in which those paths appear in this list. Within a
        given pathMatcher, only one of pathRules or routeRules must be set.
        Structure is documented below.
        """
        return pulumi.get(self, "path_rules")

    @path_rules.setter
    def path_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherPathRuleArgs']]]]):
        pulumi.set(self, "path_rules", value)

    @property
    @pulumi.getter(name="routeRules")
    def route_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleArgs']]]]:
        """
        The list of ordered HTTP route rules. Use this list instead of pathRules when
        advanced route matching and routing actions are desired. The order of specifying
        routeRules matters: the first rule that matches will cause its specified routing
        action to take effect. Within a given pathMatcher, only one of pathRules or
        routeRules must be set. routeRules are not supported in UrlMaps intended for
        External load balancers.
        Structure is documented below.
        """
        return pulumi.get(self, "route_rules")

    @route_rules.setter
    def route_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleArgs']]]]):
        pulumi.set(self, "route_rules", value)


@pulumi.input_type
class URLMapPathMatcherDefaultRouteActionArgs:
    def __init__(__self__, *,
                 cors_policy: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionCorsPolicyArgs']] = None,
                 fault_injection_policy: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyArgs']] = None,
                 request_mirror_policy: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionRequestMirrorPolicyArgs']] = None,
                 retry_policy: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionRetryPolicyArgs']] = None,
                 timeout: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionTimeoutArgs']] = None,
                 url_rewrite: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionUrlRewriteArgs']] = None,
                 weighted_backend_services: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherDefaultRouteActionWeightedBackendServiceArgs']]]] = None):
        """
        :param pulumi.Input['URLMapPathMatcherDefaultRouteActionCorsPolicyArgs'] cors_policy: The specification for allowing client side cross-origin requests. Please see
               [W3C Recommendation for Cross Origin Resource Sharing](https://www.w3.org/TR/cors/)
               Structure is documented below.
        :param pulumi.Input['URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyArgs'] fault_injection_policy: The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure.
               As part of fault injection, when clients send requests to a backend service, delays can be introduced by Loadbalancer on a
               percentage of requests before sending those request to the backend service. Similarly requests from clients can be aborted
               by the Loadbalancer for a percentage of requests.
               timeout and retryPolicy will be ignored by clients that are configured with a faultInjectionPolicy.
               Structure is documented below.
        :param pulumi.Input['URLMapPathMatcherDefaultRouteActionRequestMirrorPolicyArgs'] request_mirror_policy: Specifies the policy on how requests intended for the route's backends are shadowed to a separate mirrored backend service.
               Loadbalancer does not wait for responses from the shadow service. Prior to sending traffic to the shadow service,
               the host / authority header is suffixed with -shadow.
               Structure is documented below.
        :param pulumi.Input['URLMapPathMatcherDefaultRouteActionRetryPolicyArgs'] retry_policy: Specifies the retry policy associated with this route.
               Structure is documented below.
        :param pulumi.Input['URLMapPathMatcherDefaultRouteActionTimeoutArgs'] timeout: Specifies the timeout for the selected route. Timeout is computed from the time the request has been
               fully processed (i.e. end-of-stream) up until the response has been completely processed. Timeout includes all retries.
               If not specified, will use the largest timeout among all backend services associated with the route.
               Structure is documented below.
        :param pulumi.Input['URLMapPathMatcherDefaultRouteActionUrlRewriteArgs'] url_rewrite: The spec to modify the URL of the request, prior to forwarding the request to the matched service.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherDefaultRouteActionWeightedBackendServiceArgs']]] weighted_backend_services: A list of weighted backend services to send traffic to when a route match occurs.
               The weights determine the fraction of traffic that flows to their corresponding backend service.
               If all traffic needs to go to a single backend service, there must be one weightedBackendService
               with weight set to a non 0 number.
               Once a backendService is identified and before forwarding the request to the backend service,
               advanced routing actions like Url rewrites and header transformations are applied depending on
               additional settings specified in this HttpRouteAction.
               Structure is documented below.
        """
        if cors_policy is not None:
            pulumi.set(__self__, "cors_policy", cors_policy)
        if fault_injection_policy is not None:
            pulumi.set(__self__, "fault_injection_policy", fault_injection_policy)
        if request_mirror_policy is not None:
            pulumi.set(__self__, "request_mirror_policy", request_mirror_policy)
        if retry_policy is not None:
            pulumi.set(__self__, "retry_policy", retry_policy)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)
        if url_rewrite is not None:
            pulumi.set(__self__, "url_rewrite", url_rewrite)
        if weighted_backend_services is not None:
            pulumi.set(__self__, "weighted_backend_services", weighted_backend_services)

    @property
    @pulumi.getter(name="corsPolicy")
    def cors_policy(self) -> Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionCorsPolicyArgs']]:
        """
        The specification for allowing client side cross-origin requests. Please see
        [W3C Recommendation for Cross Origin Resource Sharing](https://www.w3.org/TR/cors/)
        Structure is documented below.
        """
        return pulumi.get(self, "cors_policy")

    @cors_policy.setter
    def cors_policy(self, value: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionCorsPolicyArgs']]):
        pulumi.set(self, "cors_policy", value)

    @property
    @pulumi.getter(name="faultInjectionPolicy")
    def fault_injection_policy(self) -> Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyArgs']]:
        """
        The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure.
        As part of fault injection, when clients send requests to a backend service, delays can be introduced by Loadbalancer on a
        percentage of requests before sending those request to the backend service. Similarly requests from clients can be aborted
        by the Loadbalancer for a percentage of requests.
        timeout and retryPolicy will be ignored by clients that are configured with a faultInjectionPolicy.
        Structure is documented below.
        """
        return pulumi.get(self, "fault_injection_policy")

    @fault_injection_policy.setter
    def fault_injection_policy(self, value: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyArgs']]):
        pulumi.set(self, "fault_injection_policy", value)

    @property
    @pulumi.getter(name="requestMirrorPolicy")
    def request_mirror_policy(self) -> Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionRequestMirrorPolicyArgs']]:
        """
        Specifies the policy on how requests intended for the route's backends are shadowed to a separate mirrored backend service.
        Loadbalancer does not wait for responses from the shadow service. Prior to sending traffic to the shadow service,
        the host / authority header is suffixed with -shadow.
        Structure is documented below.
        """
        return pulumi.get(self, "request_mirror_policy")

    @request_mirror_policy.setter
    def request_mirror_policy(self, value: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionRequestMirrorPolicyArgs']]):
        pulumi.set(self, "request_mirror_policy", value)

    @property
    @pulumi.getter(name="retryPolicy")
    def retry_policy(self) -> Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionRetryPolicyArgs']]:
        """
        Specifies the retry policy associated with this route.
        Structure is documented below.
        """
        return pulumi.get(self, "retry_policy")

    @retry_policy.setter
    def retry_policy(self, value: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionRetryPolicyArgs']]):
        pulumi.set(self, "retry_policy", value)

    @property
    @pulumi.getter
    def timeout(self) -> Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionTimeoutArgs']]:
        """
        Specifies the timeout for the selected route. Timeout is computed from the time the request has been
        fully processed (i.e. end-of-stream) up until the response has been completely processed. Timeout includes all retries.
        If not specified, will use the largest timeout among all backend services associated with the route.
        Structure is documented below.
        """
        return pulumi.get(self, "timeout")

    @timeout.setter
    def timeout(self, value: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionTimeoutArgs']]):
        pulumi.set(self, "timeout", value)

    @property
    @pulumi.getter(name="urlRewrite")
    def url_rewrite(self) -> Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionUrlRewriteArgs']]:
        """
        The spec to modify the URL of the request, prior to forwarding the request to the matched service.
        Structure is documented below.
        """
        return pulumi.get(self, "url_rewrite")

    @url_rewrite.setter
    def url_rewrite(self, value: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionUrlRewriteArgs']]):
        pulumi.set(self, "url_rewrite", value)

    @property
    @pulumi.getter(name="weightedBackendServices")
    def weighted_backend_services(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherDefaultRouteActionWeightedBackendServiceArgs']]]]:
        """
        A list of weighted backend services to send traffic to when a route match occurs.
        The weights determine the fraction of traffic that flows to their corresponding backend service.
        If all traffic needs to go to a single backend service, there must be one weightedBackendService
        with weight set to a non 0 number.
        Once a backendService is identified and before forwarding the request to the backend service,
        advanced routing actions like Url rewrites and header transformations are applied depending on
        additional settings specified in this HttpRouteAction.
        Structure is documented below.
        """
        return pulumi.get(self, "weighted_backend_services")

    @weighted_backend_services.setter
    def weighted_backend_services(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherDefaultRouteActionWeightedBackendServiceArgs']]]]):
        pulumi.set(self, "weighted_backend_services", value)


@pulumi.input_type
class URLMapPathMatcherDefaultRouteActionCorsPolicyArgs:
    def __init__(__self__, *,
                 allow_credentials: Optional[pulumi.Input[bool]] = None,
                 allow_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_methods: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_origin_regexes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_origins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 disabled: Optional[pulumi.Input[bool]] = None,
                 expose_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 max_age: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[bool] allow_credentials: In response to a preflight request, setting this to true indicates that the actual request can include user credentials.
               This translates to the Access-Control-Allow-Credentials header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_headers: Specifies the content for the Access-Control-Allow-Headers header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_methods: Specifies the content for the Access-Control-Allow-Methods header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_origin_regexes: Specifies the regular expression patterns that match allowed origins. For regular expression grammar
               please see en.cppreference.com/w/cpp/regex/ecmascript
               An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_origins: Specifies the list of origins that will be allowed to do CORS requests.
               An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.
        :param pulumi.Input[bool] disabled: If true, specifies the CORS policy is disabled. The default value is false, which indicates that the CORS policy is in effect.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] expose_headers: Specifies the content for the Access-Control-Expose-Headers header.
        :param pulumi.Input[int] max_age: Specifies how long results of a preflight request can be cached in seconds.
               This translates to the Access-Control-Max-Age header.
        """
        if allow_credentials is not None:
            pulumi.set(__self__, "allow_credentials", allow_credentials)
        if allow_headers is not None:
            pulumi.set(__self__, "allow_headers", allow_headers)
        if allow_methods is not None:
            pulumi.set(__self__, "allow_methods", allow_methods)
        if allow_origin_regexes is not None:
            pulumi.set(__self__, "allow_origin_regexes", allow_origin_regexes)
        if allow_origins is not None:
            pulumi.set(__self__, "allow_origins", allow_origins)
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)
        if expose_headers is not None:
            pulumi.set(__self__, "expose_headers", expose_headers)
        if max_age is not None:
            pulumi.set(__self__, "max_age", max_age)

    @property
    @pulumi.getter(name="allowCredentials")
    def allow_credentials(self) -> Optional[pulumi.Input[bool]]:
        """
        In response to a preflight request, setting this to true indicates that the actual request can include user credentials.
        This translates to the Access-Control-Allow-Credentials header.
        """
        return pulumi.get(self, "allow_credentials")

    @allow_credentials.setter
    def allow_credentials(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_credentials", value)

    @property
    @pulumi.getter(name="allowHeaders")
    def allow_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for the Access-Control-Allow-Headers header.
        """
        return pulumi.get(self, "allow_headers")

    @allow_headers.setter
    def allow_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_headers", value)

    @property
    @pulumi.getter(name="allowMethods")
    def allow_methods(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for the Access-Control-Allow-Methods header.
        """
        return pulumi.get(self, "allow_methods")

    @allow_methods.setter
    def allow_methods(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_methods", value)

    @property
    @pulumi.getter(name="allowOriginRegexes")
    def allow_origin_regexes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the regular expression patterns that match allowed origins. For regular expression grammar
        please see en.cppreference.com/w/cpp/regex/ecmascript
        An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.
        """
        return pulumi.get(self, "allow_origin_regexes")

    @allow_origin_regexes.setter
    def allow_origin_regexes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_origin_regexes", value)

    @property
    @pulumi.getter(name="allowOrigins")
    def allow_origins(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the list of origins that will be allowed to do CORS requests.
        An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.
        """
        return pulumi.get(self, "allow_origins")

    @allow_origins.setter
    def allow_origins(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_origins", value)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        If true, specifies the CORS policy is disabled. The default value is false, which indicates that the CORS policy is in effect.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)

    @property
    @pulumi.getter(name="exposeHeaders")
    def expose_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for the Access-Control-Expose-Headers header.
        """
        return pulumi.get(self, "expose_headers")

    @expose_headers.setter
    def expose_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "expose_headers", value)

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies how long results of a preflight request can be cached in seconds.
        This translates to the Access-Control-Max-Age header.
        """
        return pulumi.get(self, "max_age")

    @max_age.setter
    def max_age(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_age", value)


@pulumi.input_type
class URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyArgs:
    def __init__(__self__, *,
                 abort: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyAbortArgs']] = None,
                 delay: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayArgs']] = None):
        """
        :param pulumi.Input['URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyAbortArgs'] abort: The specification for how client requests are aborted as part of fault injection.
               Structure is documented below.
        :param pulumi.Input['URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayArgs'] delay: The specification for how client requests are delayed as part of fault injection, before being sent to a backend service.
               Structure is documented below.
        """
        if abort is not None:
            pulumi.set(__self__, "abort", abort)
        if delay is not None:
            pulumi.set(__self__, "delay", delay)

    @property
    @pulumi.getter
    def abort(self) -> Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyAbortArgs']]:
        """
        The specification for how client requests are aborted as part of fault injection.
        Structure is documented below.
        """
        return pulumi.get(self, "abort")

    @abort.setter
    def abort(self, value: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyAbortArgs']]):
        pulumi.set(self, "abort", value)

    @property
    @pulumi.getter
    def delay(self) -> Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayArgs']]:
        """
        The specification for how client requests are delayed as part of fault injection, before being sent to a backend service.
        Structure is documented below.
        """
        return pulumi.get(self, "delay")

    @delay.setter
    def delay(self, value: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayArgs']]):
        pulumi.set(self, "delay", value)


@pulumi.input_type
class URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyAbortArgs:
    def __init__(__self__, *,
                 http_status: Optional[pulumi.Input[int]] = None,
                 percentage: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[int] http_status: The HTTP status code used to abort the request.
               The value must be between 200 and 599 inclusive.
        :param pulumi.Input[float] percentage: The percentage of traffic (connections/operations/requests) which will be aborted as part of fault injection.
               The value must be between 0.0 and 100.0 inclusive.
        """
        if http_status is not None:
            pulumi.set(__self__, "http_status", http_status)
        if percentage is not None:
            pulumi.set(__self__, "percentage", percentage)

    @property
    @pulumi.getter(name="httpStatus")
    def http_status(self) -> Optional[pulumi.Input[int]]:
        """
        The HTTP status code used to abort the request.
        The value must be between 200 and 599 inclusive.
        """
        return pulumi.get(self, "http_status")

    @http_status.setter
    def http_status(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "http_status", value)

    @property
    @pulumi.getter
    def percentage(self) -> Optional[pulumi.Input[float]]:
        """
        The percentage of traffic (connections/operations/requests) which will be aborted as part of fault injection.
        The value must be between 0.0 and 100.0 inclusive.
        """
        return pulumi.get(self, "percentage")

    @percentage.setter
    def percentage(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "percentage", value)


@pulumi.input_type
class URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayArgs:
    def __init__(__self__, *,
                 fixed_delay: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs']] = None,
                 percentage: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input['URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs'] fixed_delay: Specifies the value of the fixed delay interval.
               Structure is documented below.
        :param pulumi.Input[float] percentage: The percentage of traffic (connections/operations/requests) which will be aborted as part of fault injection.
               The value must be between 0.0 and 100.0 inclusive.
        """
        if fixed_delay is not None:
            pulumi.set(__self__, "fixed_delay", fixed_delay)
        if percentage is not None:
            pulumi.set(__self__, "percentage", percentage)

    @property
    @pulumi.getter(name="fixedDelay")
    def fixed_delay(self) -> Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs']]:
        """
        Specifies the value of the fixed delay interval.
        Structure is documented below.
        """
        return pulumi.get(self, "fixed_delay")

    @fixed_delay.setter
    def fixed_delay(self, value: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs']]):
        pulumi.set(self, "fixed_delay", value)

    @property
    @pulumi.getter
    def percentage(self) -> Optional[pulumi.Input[float]]:
        """
        The percentage of traffic (connections/operations/requests) which will be aborted as part of fault injection.
        The value must be between 0.0 and 100.0 inclusive.
        """
        return pulumi.get(self, "percentage")

    @percentage.setter
    def percentage(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "percentage", value)


@pulumi.input_type
class URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs:
    def __init__(__self__, *,
                 nanos: Optional[pulumi.Input[int]] = None,
                 seconds: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
               represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        :param pulumi.Input[str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
               Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        """
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
        represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)

    @property
    @pulumi.getter
    def seconds(self) -> Optional[pulumi.Input[str]]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
        Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "seconds", value)


@pulumi.input_type
class URLMapPathMatcherDefaultRouteActionRequestMirrorPolicyArgs:
    def __init__(__self__, *,
                 backend_service: pulumi.Input[str]):
        """
        :param pulumi.Input[str] backend_service: The full or partial URL to the BackendService resource being mirrored to.
        """
        pulumi.set(__self__, "backend_service", backend_service)

    @property
    @pulumi.getter(name="backendService")
    def backend_service(self) -> pulumi.Input[str]:
        """
        The full or partial URL to the BackendService resource being mirrored to.
        """
        return pulumi.get(self, "backend_service")

    @backend_service.setter
    def backend_service(self, value: pulumi.Input[str]):
        pulumi.set(self, "backend_service", value)


@pulumi.input_type
class URLMapPathMatcherDefaultRouteActionRetryPolicyArgs:
    def __init__(__self__, *,
                 num_retries: Optional[pulumi.Input[int]] = None,
                 per_try_timeout: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionRetryPolicyPerTryTimeoutArgs']] = None,
                 retry_conditions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[int] num_retries: Specifies the allowed number retries. This number must be > 0. If not specified, defaults to 1.
        :param pulumi.Input['URLMapPathMatcherDefaultRouteActionRetryPolicyPerTryTimeoutArgs'] per_try_timeout: Specifies a non-zero timeout per retry attempt.
               If not specified, will use the timeout set in HttpRouteAction. If timeout in HttpRouteAction is not set,
               will use the largest timeout among all backend services associated with the route.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] retry_conditions: Specfies one or more conditions when this retry rule applies. Valid values are:
               * 5xx: Loadbalancer will attempt a retry if the backend service responds with any 5xx response code,
               or if the backend service does not respond at all, example: disconnects, reset, read timeout,
               * connection failure, and refused streams.
               * gateway-error: Similar to 5xx, but only applies to response codes 502, 503 or 504.
               * connect-failure: Loadbalancer will retry on failures connecting to backend services,
               for example due to connection timeouts.
               * retriable-4xx: Loadbalancer will retry for retriable 4xx response codes.
               Currently the only retriable error supported is 409.
               * refused-stream:Loadbalancer will retry if the backend service resets the stream with a REFUSED_STREAM error code.
               This reset type indicates that it is safe to retry.
               * cancelled: Loadbalancer will retry if the gRPC status code in the response header is set to cancelled
               * deadline-exceeded: Loadbalancer will retry if the gRPC status code in the response header is set to deadline-exceeded
               * resource-exhausted: Loadbalancer will retry if the gRPC status code in the response header is set to resource-exhausted
               * unavailable: Loadbalancer will retry if the gRPC status code in the response header is set to unavailable
        """
        if num_retries is not None:
            pulumi.set(__self__, "num_retries", num_retries)
        if per_try_timeout is not None:
            pulumi.set(__self__, "per_try_timeout", per_try_timeout)
        if retry_conditions is not None:
            pulumi.set(__self__, "retry_conditions", retry_conditions)

    @property
    @pulumi.getter(name="numRetries")
    def num_retries(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the allowed number retries. This number must be > 0. If not specified, defaults to 1.
        """
        return pulumi.get(self, "num_retries")

    @num_retries.setter
    def num_retries(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "num_retries", value)

    @property
    @pulumi.getter(name="perTryTimeout")
    def per_try_timeout(self) -> Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionRetryPolicyPerTryTimeoutArgs']]:
        """
        Specifies a non-zero timeout per retry attempt.
        If not specified, will use the timeout set in HttpRouteAction. If timeout in HttpRouteAction is not set,
        will use the largest timeout among all backend services associated with the route.
        Structure is documented below.
        """
        return pulumi.get(self, "per_try_timeout")

    @per_try_timeout.setter
    def per_try_timeout(self, value: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionRetryPolicyPerTryTimeoutArgs']]):
        pulumi.set(self, "per_try_timeout", value)

    @property
    @pulumi.getter(name="retryConditions")
    def retry_conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specfies one or more conditions when this retry rule applies. Valid values are:
        * 5xx: Loadbalancer will attempt a retry if the backend service responds with any 5xx response code,
        or if the backend service does not respond at all, example: disconnects, reset, read timeout,
        * connection failure, and refused streams.
        * gateway-error: Similar to 5xx, but only applies to response codes 502, 503 or 504.
        * connect-failure: Loadbalancer will retry on failures connecting to backend services,
        for example due to connection timeouts.
        * retriable-4xx: Loadbalancer will retry for retriable 4xx response codes.
        Currently the only retriable error supported is 409.
        * refused-stream:Loadbalancer will retry if the backend service resets the stream with a REFUSED_STREAM error code.
        This reset type indicates that it is safe to retry.
        * cancelled: Loadbalancer will retry if the gRPC status code in the response header is set to cancelled
        * deadline-exceeded: Loadbalancer will retry if the gRPC status code in the response header is set to deadline-exceeded
        * resource-exhausted: Loadbalancer will retry if the gRPC status code in the response header is set to resource-exhausted
        * unavailable: Loadbalancer will retry if the gRPC status code in the response header is set to unavailable
        """
        return pulumi.get(self, "retry_conditions")

    @retry_conditions.setter
    def retry_conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "retry_conditions", value)


@pulumi.input_type
class URLMapPathMatcherDefaultRouteActionRetryPolicyPerTryTimeoutArgs:
    def __init__(__self__, *,
                 nanos: Optional[pulumi.Input[int]] = None,
                 seconds: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
               represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        :param pulumi.Input[str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
               Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        """
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
        represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)

    @property
    @pulumi.getter
    def seconds(self) -> Optional[pulumi.Input[str]]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
        Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "seconds", value)


@pulumi.input_type
class URLMapPathMatcherDefaultRouteActionTimeoutArgs:
    def __init__(__self__, *,
                 nanos: Optional[pulumi.Input[int]] = None,
                 seconds: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
               represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        :param pulumi.Input[str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
               Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        """
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
        represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)

    @property
    @pulumi.getter
    def seconds(self) -> Optional[pulumi.Input[str]]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
        Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "seconds", value)


@pulumi.input_type
class URLMapPathMatcherDefaultRouteActionUrlRewriteArgs:
    def __init__(__self__, *,
                 host_rewrite: Optional[pulumi.Input[str]] = None,
                 path_prefix_rewrite: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host_rewrite: Prior to forwarding the request to the selected service, the request's host header is replaced
               with contents of hostRewrite.
               The value must be between 1 and 255 characters.
        :param pulumi.Input[str] path_prefix_rewrite: Prior to forwarding the request to the selected backend service, the matching portion of the
               request's path is replaced by pathPrefixRewrite.
               The value must be between 1 and 1024 characters.
        """
        if host_rewrite is not None:
            pulumi.set(__self__, "host_rewrite", host_rewrite)
        if path_prefix_rewrite is not None:
            pulumi.set(__self__, "path_prefix_rewrite", path_prefix_rewrite)

    @property
    @pulumi.getter(name="hostRewrite")
    def host_rewrite(self) -> Optional[pulumi.Input[str]]:
        """
        Prior to forwarding the request to the selected service, the request's host header is replaced
        with contents of hostRewrite.
        The value must be between 1 and 255 characters.
        """
        return pulumi.get(self, "host_rewrite")

    @host_rewrite.setter
    def host_rewrite(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_rewrite", value)

    @property
    @pulumi.getter(name="pathPrefixRewrite")
    def path_prefix_rewrite(self) -> Optional[pulumi.Input[str]]:
        """
        Prior to forwarding the request to the selected backend service, the matching portion of the
        request's path is replaced by pathPrefixRewrite.
        The value must be between 1 and 1024 characters.
        """
        return pulumi.get(self, "path_prefix_rewrite")

    @path_prefix_rewrite.setter
    def path_prefix_rewrite(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path_prefix_rewrite", value)


@pulumi.input_type
class URLMapPathMatcherDefaultRouteActionWeightedBackendServiceArgs:
    def __init__(__self__, *,
                 backend_service: Optional[pulumi.Input[str]] = None,
                 header_action: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionArgs']] = None,
                 weight: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] backend_service: The full or partial URL to the BackendService resource being mirrored to.
        :param pulumi.Input['URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionArgs'] header_action: Specifies changes to request and response headers that need to take effect for
               the selected backendService.
               headerAction specified here take effect before headerAction in the enclosing
               HttpRouteRule, PathMatcher and UrlMap.
               Structure is documented below.
        :param pulumi.Input[int] weight: Specifies the fraction of traffic sent to backendService, computed as
               weight / (sum of all weightedBackendService weights in routeAction) .
               The selection of a backend service is determined only for new traffic. Once a user's request
               has been directed to a backendService, subsequent requests will be sent to the same backendService
               as determined by the BackendService's session affinity policy.
               The value must be between 0 and 1000
        """
        if backend_service is not None:
            pulumi.set(__self__, "backend_service", backend_service)
        if header_action is not None:
            pulumi.set(__self__, "header_action", header_action)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter(name="backendService")
    def backend_service(self) -> Optional[pulumi.Input[str]]:
        """
        The full or partial URL to the BackendService resource being mirrored to.
        """
        return pulumi.get(self, "backend_service")

    @backend_service.setter
    def backend_service(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "backend_service", value)

    @property
    @pulumi.getter(name="headerAction")
    def header_action(self) -> Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionArgs']]:
        """
        Specifies changes to request and response headers that need to take effect for
        the selected backendService.
        headerAction specified here take effect before headerAction in the enclosing
        HttpRouteRule, PathMatcher and UrlMap.
        Structure is documented below.
        """
        return pulumi.get(self, "header_action")

    @header_action.setter
    def header_action(self, value: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionArgs']]):
        pulumi.set(self, "header_action", value)

    @property
    @pulumi.getter
    def weight(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the fraction of traffic sent to backendService, computed as
        weight / (sum of all weightedBackendService weights in routeAction) .
        The selection of a backend service is determined only for new traffic. Once a user's request
        has been directed to a backendService, subsequent requests will be sent to the same backendService
        as determined by the BackendService's session affinity policy.
        The value must be between 0 and 1000
        """
        return pulumi.get(self, "weight")

    @weight.setter
    def weight(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "weight", value)


@pulumi.input_type
class URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionArgs:
    def __init__(__self__, *,
                 request_headers_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]]] = None,
                 request_headers_to_removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 response_headers_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]]] = None,
                 response_headers_to_removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]] request_headers_to_adds: Headers to add to a matching request prior to forwarding the request to the backendService.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] request_headers_to_removes: A list of header names for headers that need to be removed from the request prior to
               forwarding the request to the backendService.
        :param pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]] response_headers_to_adds: Headers to add the response prior to sending the response back to the client.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] response_headers_to_removes: A list of header names for headers that need to be removed from the response prior to sending the
               response back to the client.
        """
        if request_headers_to_adds is not None:
            pulumi.set(__self__, "request_headers_to_adds", request_headers_to_adds)
        if request_headers_to_removes is not None:
            pulumi.set(__self__, "request_headers_to_removes", request_headers_to_removes)
        if response_headers_to_adds is not None:
            pulumi.set(__self__, "response_headers_to_adds", response_headers_to_adds)
        if response_headers_to_removes is not None:
            pulumi.set(__self__, "response_headers_to_removes", response_headers_to_removes)

    @property
    @pulumi.getter(name="requestHeadersToAdds")
    def request_headers_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]]]:
        """
        Headers to add to a matching request prior to forwarding the request to the backendService.
        Structure is documented below.
        """
        return pulumi.get(self, "request_headers_to_adds")

    @request_headers_to_adds.setter
    def request_headers_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]]]):
        pulumi.set(self, "request_headers_to_adds", value)

    @property
    @pulumi.getter(name="requestHeadersToRemoves")
    def request_headers_to_removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of header names for headers that need to be removed from the request prior to
        forwarding the request to the backendService.
        """
        return pulumi.get(self, "request_headers_to_removes")

    @request_headers_to_removes.setter
    def request_headers_to_removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "request_headers_to_removes", value)

    @property
    @pulumi.getter(name="responseHeadersToAdds")
    def response_headers_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]]]:
        """
        Headers to add the response prior to sending the response back to the client.
        Structure is documented below.
        """
        return pulumi.get(self, "response_headers_to_adds")

    @response_headers_to_adds.setter
    def response_headers_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]]]):
        pulumi.set(self, "response_headers_to_adds", value)

    @property
    @pulumi.getter(name="responseHeadersToRemoves")
    def response_headers_to_removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of header names for headers that need to be removed from the response prior to sending the
        response back to the client.
        """
        return pulumi.get(self, "response_headers_to_removes")

    @response_headers_to_removes.setter
    def response_headers_to_removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "response_headers_to_removes", value)


@pulumi.input_type
class URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs:
    def __init__(__self__, *,
                 header_name: Optional[pulumi.Input[str]] = None,
                 header_value: Optional[pulumi.Input[str]] = None,
                 replace: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] header_name: The name of the header to add.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: If false, headerValue is appended to any values that already exist for the header.
               If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        if header_name is not None:
            pulumi.set(__self__, "header_name", header_name)
        if header_value is not None:
            pulumi.set(__self__, "header_value", header_value)
        if replace is not None:
            pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> Optional[pulumi.Input[bool]]:
        """
        If false, headerValue is appended to any values that already exist for the header.
        If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs:
    def __init__(__self__, *,
                 header_name: Optional[pulumi.Input[str]] = None,
                 header_value: Optional[pulumi.Input[str]] = None,
                 replace: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] header_name: The name of the header to add.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: If false, headerValue is appended to any values that already exist for the header.
               If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        if header_name is not None:
            pulumi.set(__self__, "header_name", header_name)
        if header_value is not None:
            pulumi.set(__self__, "header_value", header_value)
        if replace is not None:
            pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> Optional[pulumi.Input[bool]]:
        """
        If false, headerValue is appended to any values that already exist for the header.
        If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class URLMapPathMatcherDefaultUrlRedirectArgs:
    def __init__(__self__, *,
                 strip_query: pulumi.Input[bool],
                 host_redirect: Optional[pulumi.Input[str]] = None,
                 https_redirect: Optional[pulumi.Input[bool]] = None,
                 path_redirect: Optional[pulumi.Input[str]] = None,
                 prefix_redirect: Optional[pulumi.Input[str]] = None,
                 redirect_response_code: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] strip_query: If set to true, any accompanying query portion of the original URL is removed prior
               to redirecting the request. If set to false, the query portion of the original URL is
               retained. The default is set to false.
               This field is required to ensure an empty block is not set. The normal default value is false.
        :param pulumi.Input[str] host_redirect: The host that will be used in the redirect response instead of the one that was
               supplied in the request. The value must be between 1 and 255 characters.
        :param pulumi.Input[bool] https_redirect: If set to true, the URL scheme in the redirected request is set to https. If set to
               false, the URL scheme of the redirected request will remain the same as that of the
               request. This must only be set for UrlMaps used in TargetHttpProxys. Setting this
               true for TargetHttpsProxy is not permitted. The default is set to false.
        :param pulumi.Input[str] path_redirect: The path that will be used in the redirect response instead of the one that was
               supplied in the request. pathRedirect cannot be supplied together with
               prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the
               original request will be used for the redirect. The value must be between 1 and 1024
               characters.
        :param pulumi.Input[str] prefix_redirect: The prefix that replaces the prefixMatch specified in the HttpRouteRuleMatch,
               retaining the remaining portion of the URL before redirecting the request.
               prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or
               neither. If neither is supplied, the path of the original request will be used for
               the redirect. The value must be between 1 and 1024 characters.
        :param pulumi.Input[str] redirect_response_code: The HTTP Status code to use for this RedirectAction. Supported values are:
               * MOVED_PERMANENTLY_DEFAULT, which is the default value and corresponds to 301.
               * FOUND, which corresponds to 302.
               * SEE_OTHER which corresponds to 303.
               * TEMPORARY_REDIRECT, which corresponds to 307. In this case, the request method
               will be retained.
               * PERMANENT_REDIRECT, which corresponds to 308. In this case,
               the request method will be retained.
        """
        pulumi.set(__self__, "strip_query", strip_query)
        if host_redirect is not None:
            pulumi.set(__self__, "host_redirect", host_redirect)
        if https_redirect is not None:
            pulumi.set(__self__, "https_redirect", https_redirect)
        if path_redirect is not None:
            pulumi.set(__self__, "path_redirect", path_redirect)
        if prefix_redirect is not None:
            pulumi.set(__self__, "prefix_redirect", prefix_redirect)
        if redirect_response_code is not None:
            pulumi.set(__self__, "redirect_response_code", redirect_response_code)

    @property
    @pulumi.getter(name="stripQuery")
    def strip_query(self) -> pulumi.Input[bool]:
        """
        If set to true, any accompanying query portion of the original URL is removed prior
        to redirecting the request. If set to false, the query portion of the original URL is
        retained. The default is set to false.
        This field is required to ensure an empty block is not set. The normal default value is false.
        """
        return pulumi.get(self, "strip_query")

    @strip_query.setter
    def strip_query(self, value: pulumi.Input[bool]):
        pulumi.set(self, "strip_query", value)

    @property
    @pulumi.getter(name="hostRedirect")
    def host_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The host that will be used in the redirect response instead of the one that was
        supplied in the request. The value must be between 1 and 255 characters.
        """
        return pulumi.get(self, "host_redirect")

    @host_redirect.setter
    def host_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_redirect", value)

    @property
    @pulumi.getter(name="httpsRedirect")
    def https_redirect(self) -> Optional[pulumi.Input[bool]]:
        """
        If set to true, the URL scheme in the redirected request is set to https. If set to
        false, the URL scheme of the redirected request will remain the same as that of the
        request. This must only be set for UrlMaps used in TargetHttpProxys. Setting this
        true for TargetHttpsProxy is not permitted. The default is set to false.
        """
        return pulumi.get(self, "https_redirect")

    @https_redirect.setter
    def https_redirect(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "https_redirect", value)

    @property
    @pulumi.getter(name="pathRedirect")
    def path_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The path that will be used in the redirect response instead of the one that was
        supplied in the request. pathRedirect cannot be supplied together with
        prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the
        original request will be used for the redirect. The value must be between 1 and 1024
        characters.
        """
        return pulumi.get(self, "path_redirect")

    @path_redirect.setter
    def path_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path_redirect", value)

    @property
    @pulumi.getter(name="prefixRedirect")
    def prefix_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The prefix that replaces the prefixMatch specified in the HttpRouteRuleMatch,
        retaining the remaining portion of the URL before redirecting the request.
        prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or
        neither. If neither is supplied, the path of the original request will be used for
        the redirect. The value must be between 1 and 1024 characters.
        """
        return pulumi.get(self, "prefix_redirect")

    @prefix_redirect.setter
    def prefix_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "prefix_redirect", value)

    @property
    @pulumi.getter(name="redirectResponseCode")
    def redirect_response_code(self) -> Optional[pulumi.Input[str]]:
        """
        The HTTP Status code to use for this RedirectAction. Supported values are:
        * MOVED_PERMANENTLY_DEFAULT, which is the default value and corresponds to 301.
        * FOUND, which corresponds to 302.
        * SEE_OTHER which corresponds to 303.
        * TEMPORARY_REDIRECT, which corresponds to 307. In this case, the request method
        will be retained.
        * PERMANENT_REDIRECT, which corresponds to 308. In this case,
        the request method will be retained.
        """
        return pulumi.get(self, "redirect_response_code")

    @redirect_response_code.setter
    def redirect_response_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "redirect_response_code", value)


@pulumi.input_type
class URLMapPathMatcherHeaderActionArgs:
    def __init__(__self__, *,
                 request_headers_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherHeaderActionRequestHeadersToAddArgs']]]] = None,
                 request_headers_to_removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 response_headers_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherHeaderActionResponseHeadersToAddArgs']]]] = None,
                 response_headers_to_removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherHeaderActionRequestHeadersToAddArgs']]] request_headers_to_adds: Headers to add to a matching request prior to forwarding the request to the backendService.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] request_headers_to_removes: A list of header names for headers that need to be removed from the request prior to
               forwarding the request to the backendService.
        :param pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherHeaderActionResponseHeadersToAddArgs']]] response_headers_to_adds: Headers to add the response prior to sending the response back to the client.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] response_headers_to_removes: A list of header names for headers that need to be removed from the response prior to sending the
               response back to the client.
        """
        if request_headers_to_adds is not None:
            pulumi.set(__self__, "request_headers_to_adds", request_headers_to_adds)
        if request_headers_to_removes is not None:
            pulumi.set(__self__, "request_headers_to_removes", request_headers_to_removes)
        if response_headers_to_adds is not None:
            pulumi.set(__self__, "response_headers_to_adds", response_headers_to_adds)
        if response_headers_to_removes is not None:
            pulumi.set(__self__, "response_headers_to_removes", response_headers_to_removes)

    @property
    @pulumi.getter(name="requestHeadersToAdds")
    def request_headers_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherHeaderActionRequestHeadersToAddArgs']]]]:
        """
        Headers to add to a matching request prior to forwarding the request to the backendService.
        Structure is documented below.
        """
        return pulumi.get(self, "request_headers_to_adds")

    @request_headers_to_adds.setter
    def request_headers_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherHeaderActionRequestHeadersToAddArgs']]]]):
        pulumi.set(self, "request_headers_to_adds", value)

    @property
    @pulumi.getter(name="requestHeadersToRemoves")
    def request_headers_to_removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of header names for headers that need to be removed from the request prior to
        forwarding the request to the backendService.
        """
        return pulumi.get(self, "request_headers_to_removes")

    @request_headers_to_removes.setter
    def request_headers_to_removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "request_headers_to_removes", value)

    @property
    @pulumi.getter(name="responseHeadersToAdds")
    def response_headers_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherHeaderActionResponseHeadersToAddArgs']]]]:
        """
        Headers to add the response prior to sending the response back to the client.
        Structure is documented below.
        """
        return pulumi.get(self, "response_headers_to_adds")

    @response_headers_to_adds.setter
    def response_headers_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherHeaderActionResponseHeadersToAddArgs']]]]):
        pulumi.set(self, "response_headers_to_adds", value)

    @property
    @pulumi.getter(name="responseHeadersToRemoves")
    def response_headers_to_removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of header names for headers that need to be removed from the response prior to sending the
        response back to the client.
        """
        return pulumi.get(self, "response_headers_to_removes")

    @response_headers_to_removes.setter
    def response_headers_to_removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "response_headers_to_removes", value)


@pulumi.input_type
class URLMapPathMatcherHeaderActionRequestHeadersToAddArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 header_value: pulumi.Input[str],
                 replace: pulumi.Input[bool]):
        """
        :param pulumi.Input[str] header_name: The name of the header to add.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: If false, headerValue is appended to any values that already exist for the header.
               If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)
        pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> pulumi.Input[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> pulumi.Input[bool]:
        """
        If false, headerValue is appended to any values that already exist for the header.
        If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: pulumi.Input[bool]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class URLMapPathMatcherHeaderActionResponseHeadersToAddArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 header_value: pulumi.Input[str],
                 replace: pulumi.Input[bool]):
        """
        :param pulumi.Input[str] header_name: The name of the header to add.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: If false, headerValue is appended to any values that already exist for the header.
               If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)
        pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> pulumi.Input[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> pulumi.Input[bool]:
        """
        If false, headerValue is appended to any values that already exist for the header.
        If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: pulumi.Input[bool]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class URLMapPathMatcherPathRuleArgs:
    def __init__(__self__, *,
                 paths: pulumi.Input[Sequence[pulumi.Input[str]]],
                 route_action: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionArgs']] = None,
                 service: Optional[pulumi.Input[str]] = None,
                 url_redirect: Optional[pulumi.Input['URLMapPathMatcherPathRuleUrlRedirectArgs']] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] paths: The list of path patterns to match. Each must start with / and the only place a
               \\* is allowed is at the end following a /. The string fed to the path matcher
               does not include any text after the first ? or #, and those chars are not
               allowed here.
        :param pulumi.Input['URLMapPathMatcherPathRuleRouteActionArgs'] route_action: In response to a matching matchRule, the load balancer performs advanced routing
               actions like URL rewrites, header transformations, etc. prior to forwarding the
               request to the selected backend. If  routeAction specifies any
               weightedBackendServices, service must not be set. Conversely if service is set,
               routeAction cannot contain any  weightedBackendServices. Only one of routeAction
               or urlRedirect must be set.
               Structure is documented below.
        :param pulumi.Input[str] service: The backend service or backend bucket link that should be matched by this test.
        :param pulumi.Input['URLMapPathMatcherPathRuleUrlRedirectArgs'] url_redirect: When this rule is matched, the request is redirected to a URL specified by
               urlRedirect. If urlRedirect is specified, service or routeAction must not be
               set.
               Structure is documented below.
        """
        pulumi.set(__self__, "paths", paths)
        if route_action is not None:
            pulumi.set(__self__, "route_action", route_action)
        if service is not None:
            pulumi.set(__self__, "service", service)
        if url_redirect is not None:
            pulumi.set(__self__, "url_redirect", url_redirect)

    @property
    @pulumi.getter
    def paths(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        The list of path patterns to match. Each must start with / and the only place a
        \\* is allowed is at the end following a /. The string fed to the path matcher
        does not include any text after the first ? or #, and those chars are not
        allowed here.
        """
        return pulumi.get(self, "paths")

    @paths.setter
    def paths(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "paths", value)

    @property
    @pulumi.getter(name="routeAction")
    def route_action(self) -> Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionArgs']]:
        """
        In response to a matching matchRule, the load balancer performs advanced routing
        actions like URL rewrites, header transformations, etc. prior to forwarding the
        request to the selected backend. If  routeAction specifies any
        weightedBackendServices, service must not be set. Conversely if service is set,
        routeAction cannot contain any  weightedBackendServices. Only one of routeAction
        or urlRedirect must be set.
        Structure is documented below.
        """
        return pulumi.get(self, "route_action")

    @route_action.setter
    def route_action(self, value: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionArgs']]):
        pulumi.set(self, "route_action", value)

    @property
    @pulumi.getter
    def service(self) -> Optional[pulumi.Input[str]]:
        """
        The backend service or backend bucket link that should be matched by this test.
        """
        return pulumi.get(self, "service")

    @service.setter
    def service(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service", value)

    @property
    @pulumi.getter(name="urlRedirect")
    def url_redirect(self) -> Optional[pulumi.Input['URLMapPathMatcherPathRuleUrlRedirectArgs']]:
        """
        When this rule is matched, the request is redirected to a URL specified by
        urlRedirect. If urlRedirect is specified, service or routeAction must not be
        set.
        Structure is documented below.
        """
        return pulumi.get(self, "url_redirect")

    @url_redirect.setter
    def url_redirect(self, value: Optional[pulumi.Input['URLMapPathMatcherPathRuleUrlRedirectArgs']]):
        pulumi.set(self, "url_redirect", value)


@pulumi.input_type
class URLMapPathMatcherPathRuleRouteActionArgs:
    def __init__(__self__, *,
                 cors_policy: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionCorsPolicyArgs']] = None,
                 fault_injection_policy: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs']] = None,
                 request_mirror_policy: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs']] = None,
                 retry_policy: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionRetryPolicyArgs']] = None,
                 timeout: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionTimeoutArgs']] = None,
                 url_rewrite: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionUrlRewriteArgs']] = None,
                 weighted_backend_services: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs']]]] = None):
        """
        :param pulumi.Input['URLMapPathMatcherPathRuleRouteActionCorsPolicyArgs'] cors_policy: The specification for allowing client side cross-origin requests. Please see
               [W3C Recommendation for Cross Origin Resource Sharing](https://www.w3.org/TR/cors/)
               Structure is documented below.
        :param pulumi.Input['URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs'] fault_injection_policy: The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure.
               As part of fault injection, when clients send requests to a backend service, delays can be introduced by Loadbalancer on a
               percentage of requests before sending those request to the backend service. Similarly requests from clients can be aborted
               by the Loadbalancer for a percentage of requests.
               timeout and retryPolicy will be ignored by clients that are configured with a faultInjectionPolicy.
               Structure is documented below.
        :param pulumi.Input['URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs'] request_mirror_policy: Specifies the policy on how requests intended for the route's backends are shadowed to a separate mirrored backend service.
               Loadbalancer does not wait for responses from the shadow service. Prior to sending traffic to the shadow service,
               the host / authority header is suffixed with -shadow.
               Structure is documented below.
        :param pulumi.Input['URLMapPathMatcherPathRuleRouteActionRetryPolicyArgs'] retry_policy: Specifies the retry policy associated with this route.
               Structure is documented below.
        :param pulumi.Input['URLMapPathMatcherPathRuleRouteActionTimeoutArgs'] timeout: Specifies the timeout for the selected route. Timeout is computed from the time the request has been
               fully processed (i.e. end-of-stream) up until the response has been completely processed. Timeout includes all retries.
               If not specified, will use the largest timeout among all backend services associated with the route.
               Structure is documented below.
        :param pulumi.Input['URLMapPathMatcherPathRuleRouteActionUrlRewriteArgs'] url_rewrite: The spec to modify the URL of the request, prior to forwarding the request to the matched service.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs']]] weighted_backend_services: A list of weighted backend services to send traffic to when a route match occurs.
               The weights determine the fraction of traffic that flows to their corresponding backend service.
               If all traffic needs to go to a single backend service, there must be one weightedBackendService
               with weight set to a non 0 number.
               Once a backendService is identified and before forwarding the request to the backend service,
               advanced routing actions like Url rewrites and header transformations are applied depending on
               additional settings specified in this HttpRouteAction.
               Structure is documented below.
        """
        if cors_policy is not None:
            pulumi.set(__self__, "cors_policy", cors_policy)
        if fault_injection_policy is not None:
            pulumi.set(__self__, "fault_injection_policy", fault_injection_policy)
        if request_mirror_policy is not None:
            pulumi.set(__self__, "request_mirror_policy", request_mirror_policy)
        if retry_policy is not None:
            pulumi.set(__self__, "retry_policy", retry_policy)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)
        if url_rewrite is not None:
            pulumi.set(__self__, "url_rewrite", url_rewrite)
        if weighted_backend_services is not None:
            pulumi.set(__self__, "weighted_backend_services", weighted_backend_services)

    @property
    @pulumi.getter(name="corsPolicy")
    def cors_policy(self) -> Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionCorsPolicyArgs']]:
        """
        The specification for allowing client side cross-origin requests. Please see
        [W3C Recommendation for Cross Origin Resource Sharing](https://www.w3.org/TR/cors/)
        Structure is documented below.
        """
        return pulumi.get(self, "cors_policy")

    @cors_policy.setter
    def cors_policy(self, value: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionCorsPolicyArgs']]):
        pulumi.set(self, "cors_policy", value)

    @property
    @pulumi.getter(name="faultInjectionPolicy")
    def fault_injection_policy(self) -> Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs']]:
        """
        The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure.
        As part of fault injection, when clients send requests to a backend service, delays can be introduced by Loadbalancer on a
        percentage of requests before sending those request to the backend service. Similarly requests from clients can be aborted
        by the Loadbalancer for a percentage of requests.
        timeout and retryPolicy will be ignored by clients that are configured with a faultInjectionPolicy.
        Structure is documented below.
        """
        return pulumi.get(self, "fault_injection_policy")

    @fault_injection_policy.setter
    def fault_injection_policy(self, value: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs']]):
        pulumi.set(self, "fault_injection_policy", value)

    @property
    @pulumi.getter(name="requestMirrorPolicy")
    def request_mirror_policy(self) -> Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs']]:
        """
        Specifies the policy on how requests intended for the route's backends are shadowed to a separate mirrored backend service.
        Loadbalancer does not wait for responses from the shadow service. Prior to sending traffic to the shadow service,
        the host / authority header is suffixed with -shadow.
        Structure is documented below.
        """
        return pulumi.get(self, "request_mirror_policy")

    @request_mirror_policy.setter
    def request_mirror_policy(self, value: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs']]):
        pulumi.set(self, "request_mirror_policy", value)

    @property
    @pulumi.getter(name="retryPolicy")
    def retry_policy(self) -> Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionRetryPolicyArgs']]:
        """
        Specifies the retry policy associated with this route.
        Structure is documented below.
        """
        return pulumi.get(self, "retry_policy")

    @retry_policy.setter
    def retry_policy(self, value: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionRetryPolicyArgs']]):
        pulumi.set(self, "retry_policy", value)

    @property
    @pulumi.getter
    def timeout(self) -> Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionTimeoutArgs']]:
        """
        Specifies the timeout for the selected route. Timeout is computed from the time the request has been
        fully processed (i.e. end-of-stream) up until the response has been completely processed. Timeout includes all retries.
        If not specified, will use the largest timeout among all backend services associated with the route.
        Structure is documented below.
        """
        return pulumi.get(self, "timeout")

    @timeout.setter
    def timeout(self, value: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionTimeoutArgs']]):
        pulumi.set(self, "timeout", value)

    @property
    @pulumi.getter(name="urlRewrite")
    def url_rewrite(self) -> Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionUrlRewriteArgs']]:
        """
        The spec to modify the URL of the request, prior to forwarding the request to the matched service.
        Structure is documented below.
        """
        return pulumi.get(self, "url_rewrite")

    @url_rewrite.setter
    def url_rewrite(self, value: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionUrlRewriteArgs']]):
        pulumi.set(self, "url_rewrite", value)

    @property
    @pulumi.getter(name="weightedBackendServices")
    def weighted_backend_services(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs']]]]:
        """
        A list of weighted backend services to send traffic to when a route match occurs.
        The weights determine the fraction of traffic that flows to their corresponding backend service.
        If all traffic needs to go to a single backend service, there must be one weightedBackendService
        with weight set to a non 0 number.
        Once a backendService is identified and before forwarding the request to the backend service,
        advanced routing actions like Url rewrites and header transformations are applied depending on
        additional settings specified in this HttpRouteAction.
        Structure is documented below.
        """
        return pulumi.get(self, "weighted_backend_services")

    @weighted_backend_services.setter
    def weighted_backend_services(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs']]]]):
        pulumi.set(self, "weighted_backend_services", value)


@pulumi.input_type
class URLMapPathMatcherPathRuleRouteActionCorsPolicyArgs:
    def __init__(__self__, *,
                 disabled: pulumi.Input[bool],
                 allow_credentials: Optional[pulumi.Input[bool]] = None,
                 allow_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_methods: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_origin_regexes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_origins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 expose_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 max_age: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[bool] disabled: If true, specifies the CORS policy is disabled. The default value is false, which indicates that the CORS policy is in effect.
        :param pulumi.Input[bool] allow_credentials: In response to a preflight request, setting this to true indicates that the actual request can include user credentials.
               This translates to the Access-Control-Allow-Credentials header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_headers: Specifies the content for the Access-Control-Allow-Headers header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_methods: Specifies the content for the Access-Control-Allow-Methods header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_origin_regexes: Specifies the regular expression patterns that match allowed origins. For regular expression grammar
               please see en.cppreference.com/w/cpp/regex/ecmascript
               An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_origins: Specifies the list of origins that will be allowed to do CORS requests.
               An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] expose_headers: Specifies the content for the Access-Control-Expose-Headers header.
        :param pulumi.Input[int] max_age: Specifies how long results of a preflight request can be cached in seconds.
               This translates to the Access-Control-Max-Age header.
        """
        pulumi.set(__self__, "disabled", disabled)
        if allow_credentials is not None:
            pulumi.set(__self__, "allow_credentials", allow_credentials)
        if allow_headers is not None:
            pulumi.set(__self__, "allow_headers", allow_headers)
        if allow_methods is not None:
            pulumi.set(__self__, "allow_methods", allow_methods)
        if allow_origin_regexes is not None:
            pulumi.set(__self__, "allow_origin_regexes", allow_origin_regexes)
        if allow_origins is not None:
            pulumi.set(__self__, "allow_origins", allow_origins)
        if expose_headers is not None:
            pulumi.set(__self__, "expose_headers", expose_headers)
        if max_age is not None:
            pulumi.set(__self__, "max_age", max_age)

    @property
    @pulumi.getter
    def disabled(self) -> pulumi.Input[bool]:
        """
        If true, specifies the CORS policy is disabled. The default value is false, which indicates that the CORS policy is in effect.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: pulumi.Input[bool]):
        pulumi.set(self, "disabled", value)

    @property
    @pulumi.getter(name="allowCredentials")
    def allow_credentials(self) -> Optional[pulumi.Input[bool]]:
        """
        In response to a preflight request, setting this to true indicates that the actual request can include user credentials.
        This translates to the Access-Control-Allow-Credentials header.
        """
        return pulumi.get(self, "allow_credentials")

    @allow_credentials.setter
    def allow_credentials(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_credentials", value)

    @property
    @pulumi.getter(name="allowHeaders")
    def allow_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for the Access-Control-Allow-Headers header.
        """
        return pulumi.get(self, "allow_headers")

    @allow_headers.setter
    def allow_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_headers", value)

    @property
    @pulumi.getter(name="allowMethods")
    def allow_methods(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for the Access-Control-Allow-Methods header.
        """
        return pulumi.get(self, "allow_methods")

    @allow_methods.setter
    def allow_methods(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_methods", value)

    @property
    @pulumi.getter(name="allowOriginRegexes")
    def allow_origin_regexes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the regular expression patterns that match allowed origins. For regular expression grammar
        please see en.cppreference.com/w/cpp/regex/ecmascript
        An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.
        """
        return pulumi.get(self, "allow_origin_regexes")

    @allow_origin_regexes.setter
    def allow_origin_regexes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_origin_regexes", value)

    @property
    @pulumi.getter(name="allowOrigins")
    def allow_origins(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the list of origins that will be allowed to do CORS requests.
        An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.
        """
        return pulumi.get(self, "allow_origins")

    @allow_origins.setter
    def allow_origins(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_origins", value)

    @property
    @pulumi.getter(name="exposeHeaders")
    def expose_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for the Access-Control-Expose-Headers header.
        """
        return pulumi.get(self, "expose_headers")

    @expose_headers.setter
    def expose_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "expose_headers", value)

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies how long results of a preflight request can be cached in seconds.
        This translates to the Access-Control-Max-Age header.
        """
        return pulumi.get(self, "max_age")

    @max_age.setter
    def max_age(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_age", value)


@pulumi.input_type
class URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs:
    def __init__(__self__, *,
                 abort: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs']] = None,
                 delay: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs']] = None):
        """
        :param pulumi.Input['URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs'] abort: The specification for how client requests are aborted as part of fault injection.
               Structure is documented below.
        :param pulumi.Input['URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs'] delay: The specification for how client requests are delayed as part of fault injection, before being sent to a backend service.
               Structure is documented below.
        """
        if abort is not None:
            pulumi.set(__self__, "abort", abort)
        if delay is not None:
            pulumi.set(__self__, "delay", delay)

    @property
    @pulumi.getter
    def abort(self) -> Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs']]:
        """
        The specification for how client requests are aborted as part of fault injection.
        Structure is documented below.
        """
        return pulumi.get(self, "abort")

    @abort.setter
    def abort(self, value: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs']]):
        pulumi.set(self, "abort", value)

    @property
    @pulumi.getter
    def delay(self) -> Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs']]:
        """
        The specification for how client requests are delayed as part of fault injection, before being sent to a backend service.
        Structure is documented below.
        """
        return pulumi.get(self, "delay")

    @delay.setter
    def delay(self, value: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs']]):
        pulumi.set(self, "delay", value)


@pulumi.input_type
class URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs:
    def __init__(__self__, *,
                 http_status: pulumi.Input[int],
                 percentage: pulumi.Input[float]):
        """
        :param pulumi.Input[int] http_status: The HTTP status code used to abort the request.
               The value must be between 200 and 599 inclusive.
        :param pulumi.Input[float] percentage: The percentage of traffic (connections/operations/requests) which will be aborted as part of fault injection.
               The value must be between 0.0 and 100.0 inclusive.
        """
        pulumi.set(__self__, "http_status", http_status)
        pulumi.set(__self__, "percentage", percentage)

    @property
    @pulumi.getter(name="httpStatus")
    def http_status(self) -> pulumi.Input[int]:
        """
        The HTTP status code used to abort the request.
        The value must be between 200 and 599 inclusive.
        """
        return pulumi.get(self, "http_status")

    @http_status.setter
    def http_status(self, value: pulumi.Input[int]):
        pulumi.set(self, "http_status", value)

    @property
    @pulumi.getter
    def percentage(self) -> pulumi.Input[float]:
        """
        The percentage of traffic (connections/operations/requests) which will be aborted as part of fault injection.
        The value must be between 0.0 and 100.0 inclusive.
        """
        return pulumi.get(self, "percentage")

    @percentage.setter
    def percentage(self, value: pulumi.Input[float]):
        pulumi.set(self, "percentage", value)


@pulumi.input_type
class URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs:
    def __init__(__self__, *,
                 fixed_delay: pulumi.Input['URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs'],
                 percentage: pulumi.Input[float]):
        """
        :param pulumi.Input['URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs'] fixed_delay: Specifies the value of the fixed delay interval.
               Structure is documented below.
        :param pulumi.Input[float] percentage: The percentage of traffic (connections/operations/requests) which will be aborted as part of fault injection.
               The value must be between 0.0 and 100.0 inclusive.
        """
        pulumi.set(__self__, "fixed_delay", fixed_delay)
        pulumi.set(__self__, "percentage", percentage)

    @property
    @pulumi.getter(name="fixedDelay")
    def fixed_delay(self) -> pulumi.Input['URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs']:
        """
        Specifies the value of the fixed delay interval.
        Structure is documented below.
        """
        return pulumi.get(self, "fixed_delay")

    @fixed_delay.setter
    def fixed_delay(self, value: pulumi.Input['URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs']):
        pulumi.set(self, "fixed_delay", value)

    @property
    @pulumi.getter
    def percentage(self) -> pulumi.Input[float]:
        """
        The percentage of traffic (connections/operations/requests) which will be aborted as part of fault injection.
        The value must be between 0.0 and 100.0 inclusive.
        """
        return pulumi.get(self, "percentage")

    @percentage.setter
    def percentage(self, value: pulumi.Input[float]):
        pulumi.set(self, "percentage", value)


@pulumi.input_type
class URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs:
    def __init__(__self__, *,
                 seconds: pulumi.Input[str],
                 nanos: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
               Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
               represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        """
        pulumi.set(__self__, "seconds", seconds)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)

    @property
    @pulumi.getter
    def seconds(self) -> pulumi.Input[str]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
        Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: pulumi.Input[str]):
        pulumi.set(self, "seconds", value)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
        represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)


@pulumi.input_type
class URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs:
    def __init__(__self__, *,
                 backend_service: pulumi.Input[str]):
        """
        :param pulumi.Input[str] backend_service: The full or partial URL to the BackendService resource being mirrored to.
        """
        pulumi.set(__self__, "backend_service", backend_service)

    @property
    @pulumi.getter(name="backendService")
    def backend_service(self) -> pulumi.Input[str]:
        """
        The full or partial URL to the BackendService resource being mirrored to.
        """
        return pulumi.get(self, "backend_service")

    @backend_service.setter
    def backend_service(self, value: pulumi.Input[str]):
        pulumi.set(self, "backend_service", value)


@pulumi.input_type
class URLMapPathMatcherPathRuleRouteActionRetryPolicyArgs:
    def __init__(__self__, *,
                 num_retries: Optional[pulumi.Input[int]] = None,
                 per_try_timeout: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs']] = None,
                 retry_conditions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[int] num_retries: Specifies the allowed number retries. This number must be > 0. If not specified, defaults to 1.
        :param pulumi.Input['URLMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs'] per_try_timeout: Specifies a non-zero timeout per retry attempt.
               If not specified, will use the timeout set in HttpRouteAction. If timeout in HttpRouteAction is not set,
               will use the largest timeout among all backend services associated with the route.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] retry_conditions: Specfies one or more conditions when this retry rule applies. Valid values are:
               * 5xx: Loadbalancer will attempt a retry if the backend service responds with any 5xx response code,
               or if the backend service does not respond at all, example: disconnects, reset, read timeout,
               * connection failure, and refused streams.
               * gateway-error: Similar to 5xx, but only applies to response codes 502, 503 or 504.
               * connect-failure: Loadbalancer will retry on failures connecting to backend services,
               for example due to connection timeouts.
               * retriable-4xx: Loadbalancer will retry for retriable 4xx response codes.
               Currently the only retriable error supported is 409.
               * refused-stream:Loadbalancer will retry if the backend service resets the stream with a REFUSED_STREAM error code.
               This reset type indicates that it is safe to retry.
               * cancelled: Loadbalancer will retry if the gRPC status code in the response header is set to cancelled
               * deadline-exceeded: Loadbalancer will retry if the gRPC status code in the response header is set to deadline-exceeded
               * resource-exhausted: Loadbalancer will retry if the gRPC status code in the response header is set to resource-exhausted
               * unavailable: Loadbalancer will retry if the gRPC status code in the response header is set to unavailable
        """
        if num_retries is not None:
            pulumi.set(__self__, "num_retries", num_retries)
        if per_try_timeout is not None:
            pulumi.set(__self__, "per_try_timeout", per_try_timeout)
        if retry_conditions is not None:
            pulumi.set(__self__, "retry_conditions", retry_conditions)

    @property
    @pulumi.getter(name="numRetries")
    def num_retries(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the allowed number retries. This number must be > 0. If not specified, defaults to 1.
        """
        return pulumi.get(self, "num_retries")

    @num_retries.setter
    def num_retries(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "num_retries", value)

    @property
    @pulumi.getter(name="perTryTimeout")
    def per_try_timeout(self) -> Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs']]:
        """
        Specifies a non-zero timeout per retry attempt.
        If not specified, will use the timeout set in HttpRouteAction. If timeout in HttpRouteAction is not set,
        will use the largest timeout among all backend services associated with the route.
        Structure is documented below.
        """
        return pulumi.get(self, "per_try_timeout")

    @per_try_timeout.setter
    def per_try_timeout(self, value: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs']]):
        pulumi.set(self, "per_try_timeout", value)

    @property
    @pulumi.getter(name="retryConditions")
    def retry_conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specfies one or more conditions when this retry rule applies. Valid values are:
        * 5xx: Loadbalancer will attempt a retry if the backend service responds with any 5xx response code,
        or if the backend service does not respond at all, example: disconnects, reset, read timeout,
        * connection failure, and refused streams.
        * gateway-error: Similar to 5xx, but only applies to response codes 502, 503 or 504.
        * connect-failure: Loadbalancer will retry on failures connecting to backend services,
        for example due to connection timeouts.
        * retriable-4xx: Loadbalancer will retry for retriable 4xx response codes.
        Currently the only retriable error supported is 409.
        * refused-stream:Loadbalancer will retry if the backend service resets the stream with a REFUSED_STREAM error code.
        This reset type indicates that it is safe to retry.
        * cancelled: Loadbalancer will retry if the gRPC status code in the response header is set to cancelled
        * deadline-exceeded: Loadbalancer will retry if the gRPC status code in the response header is set to deadline-exceeded
        * resource-exhausted: Loadbalancer will retry if the gRPC status code in the response header is set to resource-exhausted
        * unavailable: Loadbalancer will retry if the gRPC status code in the response header is set to unavailable
        """
        return pulumi.get(self, "retry_conditions")

    @retry_conditions.setter
    def retry_conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "retry_conditions", value)


@pulumi.input_type
class URLMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs:
    def __init__(__self__, *,
                 seconds: pulumi.Input[str],
                 nanos: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
               Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
               represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        """
        pulumi.set(__self__, "seconds", seconds)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)

    @property
    @pulumi.getter
    def seconds(self) -> pulumi.Input[str]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
        Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: pulumi.Input[str]):
        pulumi.set(self, "seconds", value)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
        represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)


@pulumi.input_type
class URLMapPathMatcherPathRuleRouteActionTimeoutArgs:
    def __init__(__self__, *,
                 seconds: pulumi.Input[str],
                 nanos: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
               Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
               represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        """
        pulumi.set(__self__, "seconds", seconds)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)

    @property
    @pulumi.getter
    def seconds(self) -> pulumi.Input[str]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
        Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: pulumi.Input[str]):
        pulumi.set(self, "seconds", value)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
        represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)


@pulumi.input_type
class URLMapPathMatcherPathRuleRouteActionUrlRewriteArgs:
    def __init__(__self__, *,
                 host_rewrite: Optional[pulumi.Input[str]] = None,
                 path_prefix_rewrite: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host_rewrite: Prior to forwarding the request to the selected service, the request's host header is replaced
               with contents of hostRewrite.
               The value must be between 1 and 255 characters.
        :param pulumi.Input[str] path_prefix_rewrite: Prior to forwarding the request to the selected backend service, the matching portion of the
               request's path is replaced by pathPrefixRewrite.
               The value must be between 1 and 1024 characters.
        """
        if host_rewrite is not None:
            pulumi.set(__self__, "host_rewrite", host_rewrite)
        if path_prefix_rewrite is not None:
            pulumi.set(__self__, "path_prefix_rewrite", path_prefix_rewrite)

    @property
    @pulumi.getter(name="hostRewrite")
    def host_rewrite(self) -> Optional[pulumi.Input[str]]:
        """
        Prior to forwarding the request to the selected service, the request's host header is replaced
        with contents of hostRewrite.
        The value must be between 1 and 255 characters.
        """
        return pulumi.get(self, "host_rewrite")

    @host_rewrite.setter
    def host_rewrite(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_rewrite", value)

    @property
    @pulumi.getter(name="pathPrefixRewrite")
    def path_prefix_rewrite(self) -> Optional[pulumi.Input[str]]:
        """
        Prior to forwarding the request to the selected backend service, the matching portion of the
        request's path is replaced by pathPrefixRewrite.
        The value must be between 1 and 1024 characters.
        """
        return pulumi.get(self, "path_prefix_rewrite")

    @path_prefix_rewrite.setter
    def path_prefix_rewrite(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path_prefix_rewrite", value)


@pulumi.input_type
class URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs:
    def __init__(__self__, *,
                 backend_service: pulumi.Input[str],
                 weight: pulumi.Input[int],
                 header_action: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs']] = None):
        """
        :param pulumi.Input[str] backend_service: The full or partial URL to the BackendService resource being mirrored to.
        :param pulumi.Input[int] weight: Specifies the fraction of traffic sent to backendService, computed as
               weight / (sum of all weightedBackendService weights in routeAction) .
               The selection of a backend service is determined only for new traffic. Once a user's request
               has been directed to a backendService, subsequent requests will be sent to the same backendService
               as determined by the BackendService's session affinity policy.
               The value must be between 0 and 1000
        :param pulumi.Input['URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs'] header_action: Specifies changes to request and response headers that need to take effect for
               the selected backendService.
               headerAction specified here take effect before headerAction in the enclosing
               HttpRouteRule, PathMatcher and UrlMap.
               Structure is documented below.
        """
        pulumi.set(__self__, "backend_service", backend_service)
        pulumi.set(__self__, "weight", weight)
        if header_action is not None:
            pulumi.set(__self__, "header_action", header_action)

    @property
    @pulumi.getter(name="backendService")
    def backend_service(self) -> pulumi.Input[str]:
        """
        The full or partial URL to the BackendService resource being mirrored to.
        """
        return pulumi.get(self, "backend_service")

    @backend_service.setter
    def backend_service(self, value: pulumi.Input[str]):
        pulumi.set(self, "backend_service", value)

    @property
    @pulumi.getter
    def weight(self) -> pulumi.Input[int]:
        """
        Specifies the fraction of traffic sent to backendService, computed as
        weight / (sum of all weightedBackendService weights in routeAction) .
        The selection of a backend service is determined only for new traffic. Once a user's request
        has been directed to a backendService, subsequent requests will be sent to the same backendService
        as determined by the BackendService's session affinity policy.
        The value must be between 0 and 1000
        """
        return pulumi.get(self, "weight")

    @weight.setter
    def weight(self, value: pulumi.Input[int]):
        pulumi.set(self, "weight", value)

    @property
    @pulumi.getter(name="headerAction")
    def header_action(self) -> Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs']]:
        """
        Specifies changes to request and response headers that need to take effect for
        the selected backendService.
        headerAction specified here take effect before headerAction in the enclosing
        HttpRouteRule, PathMatcher and UrlMap.
        Structure is documented below.
        """
        return pulumi.get(self, "header_action")

    @header_action.setter
    def header_action(self, value: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs']]):
        pulumi.set(self, "header_action", value)


@pulumi.input_type
class URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs:
    def __init__(__self__, *,
                 request_headers_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]]] = None,
                 request_headers_to_removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 response_headers_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]]] = None,
                 response_headers_to_removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]] request_headers_to_adds: Headers to add to a matching request prior to forwarding the request to the backendService.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] request_headers_to_removes: A list of header names for headers that need to be removed from the request prior to
               forwarding the request to the backendService.
        :param pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]] response_headers_to_adds: Headers to add the response prior to sending the response back to the client.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] response_headers_to_removes: A list of header names for headers that need to be removed from the response prior to sending the
               response back to the client.
        """
        if request_headers_to_adds is not None:
            pulumi.set(__self__, "request_headers_to_adds", request_headers_to_adds)
        if request_headers_to_removes is not None:
            pulumi.set(__self__, "request_headers_to_removes", request_headers_to_removes)
        if response_headers_to_adds is not None:
            pulumi.set(__self__, "response_headers_to_adds", response_headers_to_adds)
        if response_headers_to_removes is not None:
            pulumi.set(__self__, "response_headers_to_removes", response_headers_to_removes)

    @property
    @pulumi.getter(name="requestHeadersToAdds")
    def request_headers_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]]]:
        """
        Headers to add to a matching request prior to forwarding the request to the backendService.
        Structure is documented below.
        """
        return pulumi.get(self, "request_headers_to_adds")

    @request_headers_to_adds.setter
    def request_headers_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]]]):
        pulumi.set(self, "request_headers_to_adds", value)

    @property
    @pulumi.getter(name="requestHeadersToRemoves")
    def request_headers_to_removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of header names for headers that need to be removed from the request prior to
        forwarding the request to the backendService.
        """
        return pulumi.get(self, "request_headers_to_removes")

    @request_headers_to_removes.setter
    def request_headers_to_removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "request_headers_to_removes", value)

    @property
    @pulumi.getter(name="responseHeadersToAdds")
    def response_headers_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]]]:
        """
        Headers to add the response prior to sending the response back to the client.
        Structure is documented below.
        """
        return pulumi.get(self, "response_headers_to_adds")

    @response_headers_to_adds.setter
    def response_headers_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]]]):
        pulumi.set(self, "response_headers_to_adds", value)

    @property
    @pulumi.getter(name="responseHeadersToRemoves")
    def response_headers_to_removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of header names for headers that need to be removed from the response prior to sending the
        response back to the client.
        """
        return pulumi.get(self, "response_headers_to_removes")

    @response_headers_to_removes.setter
    def response_headers_to_removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "response_headers_to_removes", value)


@pulumi.input_type
class URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 header_value: pulumi.Input[str],
                 replace: pulumi.Input[bool]):
        """
        :param pulumi.Input[str] header_name: The name of the header to add.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: If false, headerValue is appended to any values that already exist for the header.
               If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)
        pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> pulumi.Input[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> pulumi.Input[bool]:
        """
        If false, headerValue is appended to any values that already exist for the header.
        If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: pulumi.Input[bool]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 header_value: pulumi.Input[str],
                 replace: pulumi.Input[bool]):
        """
        :param pulumi.Input[str] header_name: The name of the header to add.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: If false, headerValue is appended to any values that already exist for the header.
               If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)
        pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> pulumi.Input[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> pulumi.Input[bool]:
        """
        If false, headerValue is appended to any values that already exist for the header.
        If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: pulumi.Input[bool]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class URLMapPathMatcherPathRuleUrlRedirectArgs:
    def __init__(__self__, *,
                 strip_query: pulumi.Input[bool],
                 host_redirect: Optional[pulumi.Input[str]] = None,
                 https_redirect: Optional[pulumi.Input[bool]] = None,
                 path_redirect: Optional[pulumi.Input[str]] = None,
                 prefix_redirect: Optional[pulumi.Input[str]] = None,
                 redirect_response_code: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] strip_query: If set to true, any accompanying query portion of the original URL is removed prior
               to redirecting the request. If set to false, the query portion of the original URL is
               retained. The default is set to false.
               This field is required to ensure an empty block is not set. The normal default value is false.
        :param pulumi.Input[str] host_redirect: The host that will be used in the redirect response instead of the one that was
               supplied in the request. The value must be between 1 and 255 characters.
        :param pulumi.Input[bool] https_redirect: If set to true, the URL scheme in the redirected request is set to https. If set to
               false, the URL scheme of the redirected request will remain the same as that of the
               request. This must only be set for UrlMaps used in TargetHttpProxys. Setting this
               true for TargetHttpsProxy is not permitted. The default is set to false.
        :param pulumi.Input[str] path_redirect: The path that will be used in the redirect response instead of the one that was
               supplied in the request. pathRedirect cannot be supplied together with
               prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the
               original request will be used for the redirect. The value must be between 1 and 1024
               characters.
        :param pulumi.Input[str] prefix_redirect: The prefix that replaces the prefixMatch specified in the HttpRouteRuleMatch,
               retaining the remaining portion of the URL before redirecting the request.
               prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or
               neither. If neither is supplied, the path of the original request will be used for
               the redirect. The value must be between 1 and 1024 characters.
        :param pulumi.Input[str] redirect_response_code: The HTTP Status code to use for this RedirectAction. Supported values are:
               * MOVED_PERMANENTLY_DEFAULT, which is the default value and corresponds to 301.
               * FOUND, which corresponds to 302.
               * SEE_OTHER which corresponds to 303.
               * TEMPORARY_REDIRECT, which corresponds to 307. In this case, the request method
               will be retained.
               * PERMANENT_REDIRECT, which corresponds to 308. In this case,
               the request method will be retained.
        """
        pulumi.set(__self__, "strip_query", strip_query)
        if host_redirect is not None:
            pulumi.set(__self__, "host_redirect", host_redirect)
        if https_redirect is not None:
            pulumi.set(__self__, "https_redirect", https_redirect)
        if path_redirect is not None:
            pulumi.set(__self__, "path_redirect", path_redirect)
        if prefix_redirect is not None:
            pulumi.set(__self__, "prefix_redirect", prefix_redirect)
        if redirect_response_code is not None:
            pulumi.set(__self__, "redirect_response_code", redirect_response_code)

    @property
    @pulumi.getter(name="stripQuery")
    def strip_query(self) -> pulumi.Input[bool]:
        """
        If set to true, any accompanying query portion of the original URL is removed prior
        to redirecting the request. If set to false, the query portion of the original URL is
        retained. The default is set to false.
        This field is required to ensure an empty block is not set. The normal default value is false.
        """
        return pulumi.get(self, "strip_query")

    @strip_query.setter
    def strip_query(self, value: pulumi.Input[bool]):
        pulumi.set(self, "strip_query", value)

    @property
    @pulumi.getter(name="hostRedirect")
    def host_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The host that will be used in the redirect response instead of the one that was
        supplied in the request. The value must be between 1 and 255 characters.
        """
        return pulumi.get(self, "host_redirect")

    @host_redirect.setter
    def host_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_redirect", value)

    @property
    @pulumi.getter(name="httpsRedirect")
    def https_redirect(self) -> Optional[pulumi.Input[bool]]:
        """
        If set to true, the URL scheme in the redirected request is set to https. If set to
        false, the URL scheme of the redirected request will remain the same as that of the
        request. This must only be set for UrlMaps used in TargetHttpProxys. Setting this
        true for TargetHttpsProxy is not permitted. The default is set to false.
        """
        return pulumi.get(self, "https_redirect")

    @https_redirect.setter
    def https_redirect(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "https_redirect", value)

    @property
    @pulumi.getter(name="pathRedirect")
    def path_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The path that will be used in the redirect response instead of the one that was
        supplied in the request. pathRedirect cannot be supplied together with
        prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the
        original request will be used for the redirect. The value must be between 1 and 1024
        characters.
        """
        return pulumi.get(self, "path_redirect")

    @path_redirect.setter
    def path_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path_redirect", value)

    @property
    @pulumi.getter(name="prefixRedirect")
    def prefix_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The prefix that replaces the prefixMatch specified in the HttpRouteRuleMatch,
        retaining the remaining portion of the URL before redirecting the request.
        prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or
        neither. If neither is supplied, the path of the original request will be used for
        the redirect. The value must be between 1 and 1024 characters.
        """
        return pulumi.get(self, "prefix_redirect")

    @prefix_redirect.setter
    def prefix_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "prefix_redirect", value)

    @property
    @pulumi.getter(name="redirectResponseCode")
    def redirect_response_code(self) -> Optional[pulumi.Input[str]]:
        """
        The HTTP Status code to use for this RedirectAction. Supported values are:
        * MOVED_PERMANENTLY_DEFAULT, which is the default value and corresponds to 301.
        * FOUND, which corresponds to 302.
        * SEE_OTHER which corresponds to 303.
        * TEMPORARY_REDIRECT, which corresponds to 307. In this case, the request method
        will be retained.
        * PERMANENT_REDIRECT, which corresponds to 308. In this case,
        the request method will be retained.
        """
        return pulumi.get(self, "redirect_response_code")

    @redirect_response_code.setter
    def redirect_response_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "redirect_response_code", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleArgs:
    def __init__(__self__, *,
                 priority: pulumi.Input[int],
                 header_action: Optional[pulumi.Input['URLMapPathMatcherRouteRuleHeaderActionArgs']] = None,
                 match_rules: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleArgs']]]] = None,
                 route_action: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionArgs']] = None,
                 service: Optional[pulumi.Input[str]] = None,
                 url_redirect: Optional[pulumi.Input['URLMapPathMatcherRouteRuleUrlRedirectArgs']] = None):
        """
        :param pulumi.Input[int] priority: For routeRules within a given pathMatcher, priority determines the order
               in which load balancer will interpret routeRules. RouteRules are evaluated
               in order of priority, from the lowest to highest number. The priority of
               a rule decreases as its number increases (1, 2, 3, N+1). The first rule
               that matches the request is applied.
               You cannot configure two or more routeRules with the same priority.
               Priority for each rule must be set to a number between 0 and
               2147483647 inclusive.
               Priority numbers can have gaps, which enable you to add or remove rules
               in the future without affecting the rest of the rules. For example,
               1, 2, 3, 4, 5, 9, 12, 16 is a valid series of priority numbers to which
               you could add rules numbered from 6 to 8, 10 to 11, and 13 to 15 in the
               future without any impact on existing rules.
        :param pulumi.Input['URLMapPathMatcherRouteRuleHeaderActionArgs'] header_action: Specifies changes to request and response headers that need to take effect for
               the selected backendService.
               headerAction specified here take effect before headerAction in the enclosing
               HttpRouteRule, PathMatcher and UrlMap.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleArgs']]] match_rules: The rules for determining a match.
               Structure is documented below.
        :param pulumi.Input['URLMapPathMatcherRouteRuleRouteActionArgs'] route_action: In response to a matching matchRule, the load balancer performs advanced routing
               actions like URL rewrites, header transformations, etc. prior to forwarding the
               request to the selected backend. If  routeAction specifies any
               weightedBackendServices, service must not be set. Conversely if service is set,
               routeAction cannot contain any  weightedBackendServices. Only one of routeAction
               or urlRedirect must be set.
               Structure is documented below.
        :param pulumi.Input[str] service: The backend service or backend bucket link that should be matched by this test.
        :param pulumi.Input['URLMapPathMatcherRouteRuleUrlRedirectArgs'] url_redirect: When this rule is matched, the request is redirected to a URL specified by
               urlRedirect. If urlRedirect is specified, service or routeAction must not be
               set.
               Structure is documented below.
        """
        pulumi.set(__self__, "priority", priority)
        if header_action is not None:
            pulumi.set(__self__, "header_action", header_action)
        if match_rules is not None:
            pulumi.set(__self__, "match_rules", match_rules)
        if route_action is not None:
            pulumi.set(__self__, "route_action", route_action)
        if service is not None:
            pulumi.set(__self__, "service", service)
        if url_redirect is not None:
            pulumi.set(__self__, "url_redirect", url_redirect)

    @property
    @pulumi.getter
    def priority(self) -> pulumi.Input[int]:
        """
        For routeRules within a given pathMatcher, priority determines the order
        in which load balancer will interpret routeRules. RouteRules are evaluated
        in order of priority, from the lowest to highest number. The priority of
        a rule decreases as its number increases (1, 2, 3, N+1). The first rule
        that matches the request is applied.
        You cannot configure two or more routeRules with the same priority.
        Priority for each rule must be set to a number between 0 and
        2147483647 inclusive.
        Priority numbers can have gaps, which enable you to add or remove rules
        in the future without affecting the rest of the rules. For example,
        1, 2, 3, 4, 5, 9, 12, 16 is a valid series of priority numbers to which
        you could add rules numbered from 6 to 8, 10 to 11, and 13 to 15 in the
        future without any impact on existing rules.
        """
        return pulumi.get(self, "priority")

    @priority.setter
    def priority(self, value: pulumi.Input[int]):
        pulumi.set(self, "priority", value)

    @property
    @pulumi.getter(name="headerAction")
    def header_action(self) -> Optional[pulumi.Input['URLMapPathMatcherRouteRuleHeaderActionArgs']]:
        """
        Specifies changes to request and response headers that need to take effect for
        the selected backendService.
        headerAction specified here take effect before headerAction in the enclosing
        HttpRouteRule, PathMatcher and UrlMap.
        Structure is documented below.
        """
        return pulumi.get(self, "header_action")

    @header_action.setter
    def header_action(self, value: Optional[pulumi.Input['URLMapPathMatcherRouteRuleHeaderActionArgs']]):
        pulumi.set(self, "header_action", value)

    @property
    @pulumi.getter(name="matchRules")
    def match_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleArgs']]]]:
        """
        The rules for determining a match.
        Structure is documented below.
        """
        return pulumi.get(self, "match_rules")

    @match_rules.setter
    def match_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleArgs']]]]):
        pulumi.set(self, "match_rules", value)

    @property
    @pulumi.getter(name="routeAction")
    def route_action(self) -> Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionArgs']]:
        """
        In response to a matching matchRule, the load balancer performs advanced routing
        actions like URL rewrites, header transformations, etc. prior to forwarding the
        request to the selected backend. If  routeAction specifies any
        weightedBackendServices, service must not be set. Conversely if service is set,
        routeAction cannot contain any  weightedBackendServices. Only one of routeAction
        or urlRedirect must be set.
        Structure is documented below.
        """
        return pulumi.get(self, "route_action")

    @route_action.setter
    def route_action(self, value: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionArgs']]):
        pulumi.set(self, "route_action", value)

    @property
    @pulumi.getter
    def service(self) -> Optional[pulumi.Input[str]]:
        """
        The backend service or backend bucket link that should be matched by this test.
        """
        return pulumi.get(self, "service")

    @service.setter
    def service(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service", value)

    @property
    @pulumi.getter(name="urlRedirect")
    def url_redirect(self) -> Optional[pulumi.Input['URLMapPathMatcherRouteRuleUrlRedirectArgs']]:
        """
        When this rule is matched, the request is redirected to a URL specified by
        urlRedirect. If urlRedirect is specified, service or routeAction must not be
        set.
        Structure is documented below.
        """
        return pulumi.get(self, "url_redirect")

    @url_redirect.setter
    def url_redirect(self, value: Optional[pulumi.Input['URLMapPathMatcherRouteRuleUrlRedirectArgs']]):
        pulumi.set(self, "url_redirect", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleHeaderActionArgs:
    def __init__(__self__, *,
                 request_headers_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs']]]] = None,
                 request_headers_to_removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 response_headers_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs']]]] = None,
                 response_headers_to_removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs']]] request_headers_to_adds: Headers to add to a matching request prior to forwarding the request to the backendService.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] request_headers_to_removes: A list of header names for headers that need to be removed from the request prior to
               forwarding the request to the backendService.
        :param pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs']]] response_headers_to_adds: Headers to add the response prior to sending the response back to the client.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] response_headers_to_removes: A list of header names for headers that need to be removed from the response prior to sending the
               response back to the client.
        """
        if request_headers_to_adds is not None:
            pulumi.set(__self__, "request_headers_to_adds", request_headers_to_adds)
        if request_headers_to_removes is not None:
            pulumi.set(__self__, "request_headers_to_removes", request_headers_to_removes)
        if response_headers_to_adds is not None:
            pulumi.set(__self__, "response_headers_to_adds", response_headers_to_adds)
        if response_headers_to_removes is not None:
            pulumi.set(__self__, "response_headers_to_removes", response_headers_to_removes)

    @property
    @pulumi.getter(name="requestHeadersToAdds")
    def request_headers_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs']]]]:
        """
        Headers to add to a matching request prior to forwarding the request to the backendService.
        Structure is documented below.
        """
        return pulumi.get(self, "request_headers_to_adds")

    @request_headers_to_adds.setter
    def request_headers_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs']]]]):
        pulumi.set(self, "request_headers_to_adds", value)

    @property
    @pulumi.getter(name="requestHeadersToRemoves")
    def request_headers_to_removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of header names for headers that need to be removed from the request prior to
        forwarding the request to the backendService.
        """
        return pulumi.get(self, "request_headers_to_removes")

    @request_headers_to_removes.setter
    def request_headers_to_removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "request_headers_to_removes", value)

    @property
    @pulumi.getter(name="responseHeadersToAdds")
    def response_headers_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs']]]]:
        """
        Headers to add the response prior to sending the response back to the client.
        Structure is documented below.
        """
        return pulumi.get(self, "response_headers_to_adds")

    @response_headers_to_adds.setter
    def response_headers_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs']]]]):
        pulumi.set(self, "response_headers_to_adds", value)

    @property
    @pulumi.getter(name="responseHeadersToRemoves")
    def response_headers_to_removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of header names for headers that need to be removed from the response prior to sending the
        response back to the client.
        """
        return pulumi.get(self, "response_headers_to_removes")

    @response_headers_to_removes.setter
    def response_headers_to_removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "response_headers_to_removes", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 header_value: pulumi.Input[str],
                 replace: pulumi.Input[bool]):
        """
        :param pulumi.Input[str] header_name: The name of the header to add.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: If false, headerValue is appended to any values that already exist for the header.
               If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)
        pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> pulumi.Input[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> pulumi.Input[bool]:
        """
        If false, headerValue is appended to any values that already exist for the header.
        If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: pulumi.Input[bool]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 header_value: pulumi.Input[str],
                 replace: pulumi.Input[bool]):
        """
        :param pulumi.Input[str] header_name: The name of the header to add.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: If false, headerValue is appended to any values that already exist for the header.
               If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)
        pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> pulumi.Input[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> pulumi.Input[bool]:
        """
        If false, headerValue is appended to any values that already exist for the header.
        If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: pulumi.Input[bool]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleMatchRuleArgs:
    def __init__(__self__, *,
                 full_path_match: Optional[pulumi.Input[str]] = None,
                 header_matches: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs']]]] = None,
                 ignore_case: Optional[pulumi.Input[bool]] = None,
                 metadata_filters: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs']]]] = None,
                 prefix_match: Optional[pulumi.Input[str]] = None,
                 query_parameter_matches: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs']]]] = None,
                 regex_match: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] full_path_match: For satisfying the matchRule condition, the path of the request must exactly
               match the value specified in fullPathMatch after removing any query parameters
               and anchor that may be part of the original URL. FullPathMatch must be between 1
               and 1024 characters. Only one of prefixMatch, fullPathMatch or regexMatch must
               be specified.
        :param pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs']]] header_matches: Specifies a list of header match criteria, all of which must match corresponding
               headers in the request.
               Structure is documented below.
        :param pulumi.Input[bool] ignore_case: Specifies that prefixMatch and fullPathMatch matches are case sensitive.
               Defaults to false.
        :param pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs']]] metadata_filters: Opaque filter criteria used by Loadbalancer to restrict routing configuration to
               a limited set xDS compliant clients. In their xDS requests to Loadbalancer, xDS
               clients present node metadata. If a match takes place, the relevant routing
               configuration is made available to those proxies. For each metadataFilter in
               this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the
               filterLabels must match the corresponding label provided in the metadata. If its
               filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match
               with corresponding labels in the provided metadata. metadataFilters specified
               here can be overrides those specified in ForwardingRule that refers to this
               UrlMap. metadataFilters only applies to Loadbalancers that have their
               loadBalancingScheme set to INTERNAL_SELF_MANAGED.
               Structure is documented below.
        :param pulumi.Input[str] prefix_match: The value of the header must start with the contents of prefixMatch. Only one of
               exactMatch, prefixMatch, suffixMatch, regexMatch, presentMatch or rangeMatch
               must be set.
        :param pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs']]] query_parameter_matches: Specifies a list of query parameter match criteria, all of which must match
               corresponding query parameters in the request.
               Structure is documented below.
        :param pulumi.Input[str] regex_match: The queryParameterMatch matches if the value of the parameter matches the
               regular expression specified by regexMatch. For the regular expression grammar,
               please see en.cppreference.com/w/cpp/regex/ecmascript  Only one of presentMatch,
               exactMatch and regexMatch must be set.
        """
        if full_path_match is not None:
            pulumi.set(__self__, "full_path_match", full_path_match)
        if header_matches is not None:
            pulumi.set(__self__, "header_matches", header_matches)
        if ignore_case is not None:
            pulumi.set(__self__, "ignore_case", ignore_case)
        if metadata_filters is not None:
            pulumi.set(__self__, "metadata_filters", metadata_filters)
        if prefix_match is not None:
            pulumi.set(__self__, "prefix_match", prefix_match)
        if query_parameter_matches is not None:
            pulumi.set(__self__, "query_parameter_matches", query_parameter_matches)
        if regex_match is not None:
            pulumi.set(__self__, "regex_match", regex_match)

    @property
    @pulumi.getter(name="fullPathMatch")
    def full_path_match(self) -> Optional[pulumi.Input[str]]:
        """
        For satisfying the matchRule condition, the path of the request must exactly
        match the value specified in fullPathMatch after removing any query parameters
        and anchor that may be part of the original URL. FullPathMatch must be between 1
        and 1024 characters. Only one of prefixMatch, fullPathMatch or regexMatch must
        be specified.
        """
        return pulumi.get(self, "full_path_match")

    @full_path_match.setter
    def full_path_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "full_path_match", value)

    @property
    @pulumi.getter(name="headerMatches")
    def header_matches(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs']]]]:
        """
        Specifies a list of header match criteria, all of which must match corresponding
        headers in the request.
        Structure is documented below.
        """
        return pulumi.get(self, "header_matches")

    @header_matches.setter
    def header_matches(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs']]]]):
        pulumi.set(self, "header_matches", value)

    @property
    @pulumi.getter(name="ignoreCase")
    def ignore_case(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies that prefixMatch and fullPathMatch matches are case sensitive.
        Defaults to false.
        """
        return pulumi.get(self, "ignore_case")

    @ignore_case.setter
    def ignore_case(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ignore_case", value)

    @property
    @pulumi.getter(name="metadataFilters")
    def metadata_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs']]]]:
        """
        Opaque filter criteria used by Loadbalancer to restrict routing configuration to
        a limited set xDS compliant clients. In their xDS requests to Loadbalancer, xDS
        clients present node metadata. If a match takes place, the relevant routing
        configuration is made available to those proxies. For each metadataFilter in
        this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the
        filterLabels must match the corresponding label provided in the metadata. If its
        filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match
        with corresponding labels in the provided metadata. metadataFilters specified
        here can be overrides those specified in ForwardingRule that refers to this
        UrlMap. metadataFilters only applies to Loadbalancers that have their
        loadBalancingScheme set to INTERNAL_SELF_MANAGED.
        Structure is documented below.
        """
        return pulumi.get(self, "metadata_filters")

    @metadata_filters.setter
    def metadata_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs']]]]):
        pulumi.set(self, "metadata_filters", value)

    @property
    @pulumi.getter(name="prefixMatch")
    def prefix_match(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the header must start with the contents of prefixMatch. Only one of
        exactMatch, prefixMatch, suffixMatch, regexMatch, presentMatch or rangeMatch
        must be set.
        """
        return pulumi.get(self, "prefix_match")

    @prefix_match.setter
    def prefix_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "prefix_match", value)

    @property
    @pulumi.getter(name="queryParameterMatches")
    def query_parameter_matches(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs']]]]:
        """
        Specifies a list of query parameter match criteria, all of which must match
        corresponding query parameters in the request.
        Structure is documented below.
        """
        return pulumi.get(self, "query_parameter_matches")

    @query_parameter_matches.setter
    def query_parameter_matches(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs']]]]):
        pulumi.set(self, "query_parameter_matches", value)

    @property
    @pulumi.getter(name="regexMatch")
    def regex_match(self) -> Optional[pulumi.Input[str]]:
        """
        The queryParameterMatch matches if the value of the parameter matches the
        regular expression specified by regexMatch. For the regular expression grammar,
        please see en.cppreference.com/w/cpp/regex/ecmascript  Only one of presentMatch,
        exactMatch and regexMatch must be set.
        """
        return pulumi.get(self, "regex_match")

    @regex_match.setter
    def regex_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "regex_match", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 exact_match: Optional[pulumi.Input[str]] = None,
                 invert_match: Optional[pulumi.Input[bool]] = None,
                 prefix_match: Optional[pulumi.Input[str]] = None,
                 present_match: Optional[pulumi.Input[bool]] = None,
                 range_match: Optional[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatchArgs']] = None,
                 regex_match: Optional[pulumi.Input[str]] = None,
                 suffix_match: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] header_name: The name of the header to add.
        :param pulumi.Input[str] exact_match: The queryParameterMatch matches if the value of the parameter exactly matches
               the contents of exactMatch. Only one of presentMatch, exactMatch and regexMatch
               must be set.
        :param pulumi.Input[bool] invert_match: If set to false, the headerMatch is considered a match if the match criteria
               above are met. If set to true, the headerMatch is considered a match if the
               match criteria above are NOT met. Defaults to false.
        :param pulumi.Input[str] prefix_match: The value of the header must start with the contents of prefixMatch. Only one of
               exactMatch, prefixMatch, suffixMatch, regexMatch, presentMatch or rangeMatch
               must be set.
        :param pulumi.Input[bool] present_match: Specifies that the queryParameterMatch matches if the request contains the query
               parameter, irrespective of whether the parameter has a value or not. Only one of
               presentMatch, exactMatch and regexMatch must be set.
        :param pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatchArgs'] range_match: The header value must be an integer and its value must be in the range specified
               in rangeMatch. If the header does not contain an integer, number or is empty,
               the match fails. For example for a range [-5, 0]   - -3 will match.  - 0 will
               not match.  - 0.25 will not match.  - -3someString will not match.   Only one of
               exactMatch, prefixMatch, suffixMatch, regexMatch, presentMatch or rangeMatch
               must be set.
               Structure is documented below.
        :param pulumi.Input[str] regex_match: The queryParameterMatch matches if the value of the parameter matches the
               regular expression specified by regexMatch. For the regular expression grammar,
               please see en.cppreference.com/w/cpp/regex/ecmascript  Only one of presentMatch,
               exactMatch and regexMatch must be set.
        :param pulumi.Input[str] suffix_match: The value of the header must end with the contents of suffixMatch. Only one of
               exactMatch, prefixMatch, suffixMatch, regexMatch, presentMatch or rangeMatch
               must be set.
        """
        pulumi.set(__self__, "header_name", header_name)
        if exact_match is not None:
            pulumi.set(__self__, "exact_match", exact_match)
        if invert_match is not None:
            pulumi.set(__self__, "invert_match", invert_match)
        if prefix_match is not None:
            pulumi.set(__self__, "prefix_match", prefix_match)
        if present_match is not None:
            pulumi.set(__self__, "present_match", present_match)
        if range_match is not None:
            pulumi.set(__self__, "range_match", range_match)
        if regex_match is not None:
            pulumi.set(__self__, "regex_match", regex_match)
        if suffix_match is not None:
            pulumi.set(__self__, "suffix_match", suffix_match)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="exactMatch")
    def exact_match(self) -> Optional[pulumi.Input[str]]:
        """
        The queryParameterMatch matches if the value of the parameter exactly matches
        the contents of exactMatch. Only one of presentMatch, exactMatch and regexMatch
        must be set.
        """
        return pulumi.get(self, "exact_match")

    @exact_match.setter
    def exact_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "exact_match", value)

    @property
    @pulumi.getter(name="invertMatch")
    def invert_match(self) -> Optional[pulumi.Input[bool]]:
        """
        If set to false, the headerMatch is considered a match if the match criteria
        above are met. If set to true, the headerMatch is considered a match if the
        match criteria above are NOT met. Defaults to false.
        """
        return pulumi.get(self, "invert_match")

    @invert_match.setter
    def invert_match(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "invert_match", value)

    @property
    @pulumi.getter(name="prefixMatch")
    def prefix_match(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the header must start with the contents of prefixMatch. Only one of
        exactMatch, prefixMatch, suffixMatch, regexMatch, presentMatch or rangeMatch
        must be set.
        """
        return pulumi.get(self, "prefix_match")

    @prefix_match.setter
    def prefix_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "prefix_match", value)

    @property
    @pulumi.getter(name="presentMatch")
    def present_match(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies that the queryParameterMatch matches if the request contains the query
        parameter, irrespective of whether the parameter has a value or not. Only one of
        presentMatch, exactMatch and regexMatch must be set.
        """
        return pulumi.get(self, "present_match")

    @present_match.setter
    def present_match(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "present_match", value)

    @property
    @pulumi.getter(name="rangeMatch")
    def range_match(self) -> Optional[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatchArgs']]:
        """
        The header value must be an integer and its value must be in the range specified
        in rangeMatch. If the header does not contain an integer, number or is empty,
        the match fails. For example for a range [-5, 0]   - -3 will match.  - 0 will
        not match.  - 0.25 will not match.  - -3someString will not match.   Only one of
        exactMatch, prefixMatch, suffixMatch, regexMatch, presentMatch or rangeMatch
        must be set.
        Structure is documented below.
        """
        return pulumi.get(self, "range_match")

    @range_match.setter
    def range_match(self, value: Optional[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatchArgs']]):
        pulumi.set(self, "range_match", value)

    @property
    @pulumi.getter(name="regexMatch")
    def regex_match(self) -> Optional[pulumi.Input[str]]:
        """
        The queryParameterMatch matches if the value of the parameter matches the
        regular expression specified by regexMatch. For the regular expression grammar,
        please see en.cppreference.com/w/cpp/regex/ecmascript  Only one of presentMatch,
        exactMatch and regexMatch must be set.
        """
        return pulumi.get(self, "regex_match")

    @regex_match.setter
    def regex_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "regex_match", value)

    @property
    @pulumi.getter(name="suffixMatch")
    def suffix_match(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the header must end with the contents of suffixMatch. Only one of
        exactMatch, prefixMatch, suffixMatch, regexMatch, presentMatch or rangeMatch
        must be set.
        """
        return pulumi.get(self, "suffix_match")

    @suffix_match.setter
    def suffix_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "suffix_match", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatchArgs:
    def __init__(__self__, *,
                 range_end: pulumi.Input[int],
                 range_start: pulumi.Input[int]):
        """
        :param pulumi.Input[int] range_end: The end of the range (exclusive).
        :param pulumi.Input[int] range_start: The start of the range (inclusive).
        """
        pulumi.set(__self__, "range_end", range_end)
        pulumi.set(__self__, "range_start", range_start)

    @property
    @pulumi.getter(name="rangeEnd")
    def range_end(self) -> pulumi.Input[int]:
        """
        The end of the range (exclusive).
        """
        return pulumi.get(self, "range_end")

    @range_end.setter
    def range_end(self, value: pulumi.Input[int]):
        pulumi.set(self, "range_end", value)

    @property
    @pulumi.getter(name="rangeStart")
    def range_start(self) -> pulumi.Input[int]:
        """
        The start of the range (inclusive).
        """
        return pulumi.get(self, "range_start")

    @range_start.setter
    def range_start(self, value: pulumi.Input[int]):
        pulumi.set(self, "range_start", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs:
    def __init__(__self__, *,
                 filter_labels: pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs']]],
                 filter_match_criteria: pulumi.Input[str]):
        """
        :param pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs']]] filter_labels: The list of label value pairs that must match labels in the provided metadata
               based on filterMatchCriteria  This list must not be empty and can have at the
               most 64 entries.
               Structure is documented below.
        :param pulumi.Input[str] filter_match_criteria: Specifies how individual filterLabel matches within the list of filterLabels
               contribute towards the overall metadataFilter match. Supported values are:
               - MATCH_ANY: At least one of the filterLabels must have a matching label in the
               provided metadata.
               - MATCH_ALL: All filterLabels must have matching labels in
               the provided metadata.
               Possible values are `MATCH_ALL` and `MATCH_ANY`.
        """
        pulumi.set(__self__, "filter_labels", filter_labels)
        pulumi.set(__self__, "filter_match_criteria", filter_match_criteria)

    @property
    @pulumi.getter(name="filterLabels")
    def filter_labels(self) -> pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs']]]:
        """
        The list of label value pairs that must match labels in the provided metadata
        based on filterMatchCriteria  This list must not be empty and can have at the
        most 64 entries.
        Structure is documented below.
        """
        return pulumi.get(self, "filter_labels")

    @filter_labels.setter
    def filter_labels(self, value: pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs']]]):
        pulumi.set(self, "filter_labels", value)

    @property
    @pulumi.getter(name="filterMatchCriteria")
    def filter_match_criteria(self) -> pulumi.Input[str]:
        """
        Specifies how individual filterLabel matches within the list of filterLabels
        contribute towards the overall metadataFilter match. Supported values are:
        - MATCH_ANY: At least one of the filterLabels must have a matching label in the
        provided metadata.
        - MATCH_ALL: All filterLabels must have matching labels in
        the provided metadata.
        Possible values are `MATCH_ALL` and `MATCH_ANY`.
        """
        return pulumi.get(self, "filter_match_criteria")

    @filter_match_criteria.setter
    def filter_match_criteria(self, value: pulumi.Input[str]):
        pulumi.set(self, "filter_match_criteria", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] name: The name of the query parameter to match. The query parameter must exist in the
               request, in the absence of which the request match fails.
        :param pulumi.Input[str] value: The value of the label must match the specified value. value can have a maximum
               length of 1024 characters.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the query parameter to match. The query parameter must exist in the
        request, in the absence of which the request match fails.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        The value of the label must match the specified value. value can have a maximum
        length of 1024 characters.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 exact_match: Optional[pulumi.Input[str]] = None,
                 present_match: Optional[pulumi.Input[bool]] = None,
                 regex_match: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The name of the query parameter to match. The query parameter must exist in the
               request, in the absence of which the request match fails.
        :param pulumi.Input[str] exact_match: The queryParameterMatch matches if the value of the parameter exactly matches
               the contents of exactMatch. Only one of presentMatch, exactMatch and regexMatch
               must be set.
        :param pulumi.Input[bool] present_match: Specifies that the queryParameterMatch matches if the request contains the query
               parameter, irrespective of whether the parameter has a value or not. Only one of
               presentMatch, exactMatch and regexMatch must be set.
        :param pulumi.Input[str] regex_match: The queryParameterMatch matches if the value of the parameter matches the
               regular expression specified by regexMatch. For the regular expression grammar,
               please see en.cppreference.com/w/cpp/regex/ecmascript  Only one of presentMatch,
               exactMatch and regexMatch must be set.
        """
        pulumi.set(__self__, "name", name)
        if exact_match is not None:
            pulumi.set(__self__, "exact_match", exact_match)
        if present_match is not None:
            pulumi.set(__self__, "present_match", present_match)
        if regex_match is not None:
            pulumi.set(__self__, "regex_match", regex_match)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the query parameter to match. The query parameter must exist in the
        request, in the absence of which the request match fails.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="exactMatch")
    def exact_match(self) -> Optional[pulumi.Input[str]]:
        """
        The queryParameterMatch matches if the value of the parameter exactly matches
        the contents of exactMatch. Only one of presentMatch, exactMatch and regexMatch
        must be set.
        """
        return pulumi.get(self, "exact_match")

    @exact_match.setter
    def exact_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "exact_match", value)

    @property
    @pulumi.getter(name="presentMatch")
    def present_match(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies that the queryParameterMatch matches if the request contains the query
        parameter, irrespective of whether the parameter has a value or not. Only one of
        presentMatch, exactMatch and regexMatch must be set.
        """
        return pulumi.get(self, "present_match")

    @present_match.setter
    def present_match(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "present_match", value)

    @property
    @pulumi.getter(name="regexMatch")
    def regex_match(self) -> Optional[pulumi.Input[str]]:
        """
        The queryParameterMatch matches if the value of the parameter matches the
        regular expression specified by regexMatch. For the regular expression grammar,
        please see en.cppreference.com/w/cpp/regex/ecmascript  Only one of presentMatch,
        exactMatch and regexMatch must be set.
        """
        return pulumi.get(self, "regex_match")

    @regex_match.setter
    def regex_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "regex_match", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleRouteActionArgs:
    def __init__(__self__, *,
                 cors_policy: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionCorsPolicyArgs']] = None,
                 fault_injection_policy: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyArgs']] = None,
                 request_mirror_policy: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicyArgs']] = None,
                 retry_policy: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionRetryPolicyArgs']] = None,
                 timeout: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionTimeoutArgs']] = None,
                 url_rewrite: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionUrlRewriteArgs']] = None,
                 weighted_backend_services: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceArgs']]]] = None):
        """
        :param pulumi.Input['URLMapPathMatcherRouteRuleRouteActionCorsPolicyArgs'] cors_policy: The specification for allowing client side cross-origin requests. Please see
               [W3C Recommendation for Cross Origin Resource Sharing](https://www.w3.org/TR/cors/)
               Structure is documented below.
        :param pulumi.Input['URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyArgs'] fault_injection_policy: The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure.
               As part of fault injection, when clients send requests to a backend service, delays can be introduced by Loadbalancer on a
               percentage of requests before sending those request to the backend service. Similarly requests from clients can be aborted
               by the Loadbalancer for a percentage of requests.
               timeout and retryPolicy will be ignored by clients that are configured with a faultInjectionPolicy.
               Structure is documented below.
        :param pulumi.Input['URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicyArgs'] request_mirror_policy: Specifies the policy on how requests intended for the route's backends are shadowed to a separate mirrored backend service.
               Loadbalancer does not wait for responses from the shadow service. Prior to sending traffic to the shadow service,
               the host / authority header is suffixed with -shadow.
               Structure is documented below.
        :param pulumi.Input['URLMapPathMatcherRouteRuleRouteActionRetryPolicyArgs'] retry_policy: Specifies the retry policy associated with this route.
               Structure is documented below.
        :param pulumi.Input['URLMapPathMatcherRouteRuleRouteActionTimeoutArgs'] timeout: Specifies the timeout for the selected route. Timeout is computed from the time the request has been
               fully processed (i.e. end-of-stream) up until the response has been completely processed. Timeout includes all retries.
               If not specified, will use the largest timeout among all backend services associated with the route.
               Structure is documented below.
        :param pulumi.Input['URLMapPathMatcherRouteRuleRouteActionUrlRewriteArgs'] url_rewrite: The spec to modify the URL of the request, prior to forwarding the request to the matched service.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceArgs']]] weighted_backend_services: A list of weighted backend services to send traffic to when a route match occurs.
               The weights determine the fraction of traffic that flows to their corresponding backend service.
               If all traffic needs to go to a single backend service, there must be one weightedBackendService
               with weight set to a non 0 number.
               Once a backendService is identified and before forwarding the request to the backend service,
               advanced routing actions like Url rewrites and header transformations are applied depending on
               additional settings specified in this HttpRouteAction.
               Structure is documented below.
        """
        if cors_policy is not None:
            pulumi.set(__self__, "cors_policy", cors_policy)
        if fault_injection_policy is not None:
            pulumi.set(__self__, "fault_injection_policy", fault_injection_policy)
        if request_mirror_policy is not None:
            pulumi.set(__self__, "request_mirror_policy", request_mirror_policy)
        if retry_policy is not None:
            pulumi.set(__self__, "retry_policy", retry_policy)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)
        if url_rewrite is not None:
            pulumi.set(__self__, "url_rewrite", url_rewrite)
        if weighted_backend_services is not None:
            pulumi.set(__self__, "weighted_backend_services", weighted_backend_services)

    @property
    @pulumi.getter(name="corsPolicy")
    def cors_policy(self) -> Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionCorsPolicyArgs']]:
        """
        The specification for allowing client side cross-origin requests. Please see
        [W3C Recommendation for Cross Origin Resource Sharing](https://www.w3.org/TR/cors/)
        Structure is documented below.
        """
        return pulumi.get(self, "cors_policy")

    @cors_policy.setter
    def cors_policy(self, value: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionCorsPolicyArgs']]):
        pulumi.set(self, "cors_policy", value)

    @property
    @pulumi.getter(name="faultInjectionPolicy")
    def fault_injection_policy(self) -> Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyArgs']]:
        """
        The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure.
        As part of fault injection, when clients send requests to a backend service, delays can be introduced by Loadbalancer on a
        percentage of requests before sending those request to the backend service. Similarly requests from clients can be aborted
        by the Loadbalancer for a percentage of requests.
        timeout and retryPolicy will be ignored by clients that are configured with a faultInjectionPolicy.
        Structure is documented below.
        """
        return pulumi.get(self, "fault_injection_policy")

    @fault_injection_policy.setter
    def fault_injection_policy(self, value: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyArgs']]):
        pulumi.set(self, "fault_injection_policy", value)

    @property
    @pulumi.getter(name="requestMirrorPolicy")
    def request_mirror_policy(self) -> Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicyArgs']]:
        """
        Specifies the policy on how requests intended for the route's backends are shadowed to a separate mirrored backend service.
        Loadbalancer does not wait for responses from the shadow service. Prior to sending traffic to the shadow service,
        the host / authority header is suffixed with -shadow.
        Structure is documented below.
        """
        return pulumi.get(self, "request_mirror_policy")

    @request_mirror_policy.setter
    def request_mirror_policy(self, value: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicyArgs']]):
        pulumi.set(self, "request_mirror_policy", value)

    @property
    @pulumi.getter(name="retryPolicy")
    def retry_policy(self) -> Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionRetryPolicyArgs']]:
        """
        Specifies the retry policy associated with this route.
        Structure is documented below.
        """
        return pulumi.get(self, "retry_policy")

    @retry_policy.setter
    def retry_policy(self, value: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionRetryPolicyArgs']]):
        pulumi.set(self, "retry_policy", value)

    @property
    @pulumi.getter
    def timeout(self) -> Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionTimeoutArgs']]:
        """
        Specifies the timeout for the selected route. Timeout is computed from the time the request has been
        fully processed (i.e. end-of-stream) up until the response has been completely processed. Timeout includes all retries.
        If not specified, will use the largest timeout among all backend services associated with the route.
        Structure is documented below.
        """
        return pulumi.get(self, "timeout")

    @timeout.setter
    def timeout(self, value: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionTimeoutArgs']]):
        pulumi.set(self, "timeout", value)

    @property
    @pulumi.getter(name="urlRewrite")
    def url_rewrite(self) -> Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionUrlRewriteArgs']]:
        """
        The spec to modify the URL of the request, prior to forwarding the request to the matched service.
        Structure is documented below.
        """
        return pulumi.get(self, "url_rewrite")

    @url_rewrite.setter
    def url_rewrite(self, value: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionUrlRewriteArgs']]):
        pulumi.set(self, "url_rewrite", value)

    @property
    @pulumi.getter(name="weightedBackendServices")
    def weighted_backend_services(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceArgs']]]]:
        """
        A list of weighted backend services to send traffic to when a route match occurs.
        The weights determine the fraction of traffic that flows to their corresponding backend service.
        If all traffic needs to go to a single backend service, there must be one weightedBackendService
        with weight set to a non 0 number.
        Once a backendService is identified and before forwarding the request to the backend service,
        advanced routing actions like Url rewrites and header transformations are applied depending on
        additional settings specified in this HttpRouteAction.
        Structure is documented below.
        """
        return pulumi.get(self, "weighted_backend_services")

    @weighted_backend_services.setter
    def weighted_backend_services(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceArgs']]]]):
        pulumi.set(self, "weighted_backend_services", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleRouteActionCorsPolicyArgs:
    def __init__(__self__, *,
                 allow_credentials: Optional[pulumi.Input[bool]] = None,
                 allow_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_methods: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_origin_regexes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_origins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 disabled: Optional[pulumi.Input[bool]] = None,
                 expose_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 max_age: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[bool] allow_credentials: In response to a preflight request, setting this to true indicates that the actual request can include user credentials.
               This translates to the Access-Control-Allow-Credentials header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_headers: Specifies the content for the Access-Control-Allow-Headers header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_methods: Specifies the content for the Access-Control-Allow-Methods header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_origin_regexes: Specifies the regular expression patterns that match allowed origins. For regular expression grammar
               please see en.cppreference.com/w/cpp/regex/ecmascript
               An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_origins: Specifies the list of origins that will be allowed to do CORS requests.
               An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.
        :param pulumi.Input[bool] disabled: If true, specifies the CORS policy is disabled. The default value is false, which indicates that the CORS policy is in effect.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] expose_headers: Specifies the content for the Access-Control-Expose-Headers header.
        :param pulumi.Input[int] max_age: Specifies how long results of a preflight request can be cached in seconds.
               This translates to the Access-Control-Max-Age header.
        """
        if allow_credentials is not None:
            pulumi.set(__self__, "allow_credentials", allow_credentials)
        if allow_headers is not None:
            pulumi.set(__self__, "allow_headers", allow_headers)
        if allow_methods is not None:
            pulumi.set(__self__, "allow_methods", allow_methods)
        if allow_origin_regexes is not None:
            pulumi.set(__self__, "allow_origin_regexes", allow_origin_regexes)
        if allow_origins is not None:
            pulumi.set(__self__, "allow_origins", allow_origins)
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)
        if expose_headers is not None:
            pulumi.set(__self__, "expose_headers", expose_headers)
        if max_age is not None:
            pulumi.set(__self__, "max_age", max_age)

    @property
    @pulumi.getter(name="allowCredentials")
    def allow_credentials(self) -> Optional[pulumi.Input[bool]]:
        """
        In response to a preflight request, setting this to true indicates that the actual request can include user credentials.
        This translates to the Access-Control-Allow-Credentials header.
        """
        return pulumi.get(self, "allow_credentials")

    @allow_credentials.setter
    def allow_credentials(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_credentials", value)

    @property
    @pulumi.getter(name="allowHeaders")
    def allow_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for the Access-Control-Allow-Headers header.
        """
        return pulumi.get(self, "allow_headers")

    @allow_headers.setter
    def allow_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_headers", value)

    @property
    @pulumi.getter(name="allowMethods")
    def allow_methods(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for the Access-Control-Allow-Methods header.
        """
        return pulumi.get(self, "allow_methods")

    @allow_methods.setter
    def allow_methods(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_methods", value)

    @property
    @pulumi.getter(name="allowOriginRegexes")
    def allow_origin_regexes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the regular expression patterns that match allowed origins. For regular expression grammar
        please see en.cppreference.com/w/cpp/regex/ecmascript
        An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.
        """
        return pulumi.get(self, "allow_origin_regexes")

    @allow_origin_regexes.setter
    def allow_origin_regexes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_origin_regexes", value)

    @property
    @pulumi.getter(name="allowOrigins")
    def allow_origins(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the list of origins that will be allowed to do CORS requests.
        An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.
        """
        return pulumi.get(self, "allow_origins")

    @allow_origins.setter
    def allow_origins(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_origins", value)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        If true, specifies the CORS policy is disabled. The default value is false, which indicates that the CORS policy is in effect.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)

    @property
    @pulumi.getter(name="exposeHeaders")
    def expose_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for the Access-Control-Expose-Headers header.
        """
        return pulumi.get(self, "expose_headers")

    @expose_headers.setter
    def expose_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "expose_headers", value)

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies how long results of a preflight request can be cached in seconds.
        This translates to the Access-Control-Max-Age header.
        """
        return pulumi.get(self, "max_age")

    @max_age.setter
    def max_age(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_age", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyArgs:
    def __init__(__self__, *,
                 abort: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbortArgs']] = None,
                 delay: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayArgs']] = None):
        """
        :param pulumi.Input['URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbortArgs'] abort: The specification for how client requests are aborted as part of fault injection.
               Structure is documented below.
        :param pulumi.Input['URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayArgs'] delay: The specification for how client requests are delayed as part of fault injection, before being sent to a backend service.
               Structure is documented below.
        """
        if abort is not None:
            pulumi.set(__self__, "abort", abort)
        if delay is not None:
            pulumi.set(__self__, "delay", delay)

    @property
    @pulumi.getter
    def abort(self) -> Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbortArgs']]:
        """
        The specification for how client requests are aborted as part of fault injection.
        Structure is documented below.
        """
        return pulumi.get(self, "abort")

    @abort.setter
    def abort(self, value: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbortArgs']]):
        pulumi.set(self, "abort", value)

    @property
    @pulumi.getter
    def delay(self) -> Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayArgs']]:
        """
        The specification for how client requests are delayed as part of fault injection, before being sent to a backend service.
        Structure is documented below.
        """
        return pulumi.get(self, "delay")

    @delay.setter
    def delay(self, value: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayArgs']]):
        pulumi.set(self, "delay", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbortArgs:
    def __init__(__self__, *,
                 http_status: Optional[pulumi.Input[int]] = None,
                 percentage: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[int] http_status: The HTTP status code used to abort the request.
               The value must be between 200 and 599 inclusive.
        :param pulumi.Input[float] percentage: The percentage of traffic (connections/operations/requests) which will be aborted as part of fault injection.
               The value must be between 0.0 and 100.0 inclusive.
        """
        if http_status is not None:
            pulumi.set(__self__, "http_status", http_status)
        if percentage is not None:
            pulumi.set(__self__, "percentage", percentage)

    @property
    @pulumi.getter(name="httpStatus")
    def http_status(self) -> Optional[pulumi.Input[int]]:
        """
        The HTTP status code used to abort the request.
        The value must be between 200 and 599 inclusive.
        """
        return pulumi.get(self, "http_status")

    @http_status.setter
    def http_status(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "http_status", value)

    @property
    @pulumi.getter
    def percentage(self) -> Optional[pulumi.Input[float]]:
        """
        The percentage of traffic (connections/operations/requests) which will be aborted as part of fault injection.
        The value must be between 0.0 and 100.0 inclusive.
        """
        return pulumi.get(self, "percentage")

    @percentage.setter
    def percentage(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "percentage", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayArgs:
    def __init__(__self__, *,
                 fixed_delay: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs']] = None,
                 percentage: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input['URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs'] fixed_delay: Specifies the value of the fixed delay interval.
               Structure is documented below.
        :param pulumi.Input[float] percentage: The percentage of traffic (connections/operations/requests) which will be aborted as part of fault injection.
               The value must be between 0.0 and 100.0 inclusive.
        """
        if fixed_delay is not None:
            pulumi.set(__self__, "fixed_delay", fixed_delay)
        if percentage is not None:
            pulumi.set(__self__, "percentage", percentage)

    @property
    @pulumi.getter(name="fixedDelay")
    def fixed_delay(self) -> Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs']]:
        """
        Specifies the value of the fixed delay interval.
        Structure is documented below.
        """
        return pulumi.get(self, "fixed_delay")

    @fixed_delay.setter
    def fixed_delay(self, value: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs']]):
        pulumi.set(self, "fixed_delay", value)

    @property
    @pulumi.getter
    def percentage(self) -> Optional[pulumi.Input[float]]:
        """
        The percentage of traffic (connections/operations/requests) which will be aborted as part of fault injection.
        The value must be between 0.0 and 100.0 inclusive.
        """
        return pulumi.get(self, "percentage")

    @percentage.setter
    def percentage(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "percentage", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs:
    def __init__(__self__, *,
                 seconds: pulumi.Input[str],
                 nanos: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
               Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
               represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        """
        pulumi.set(__self__, "seconds", seconds)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)

    @property
    @pulumi.getter
    def seconds(self) -> pulumi.Input[str]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
        Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: pulumi.Input[str]):
        pulumi.set(self, "seconds", value)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
        represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicyArgs:
    def __init__(__self__, *,
                 backend_service: pulumi.Input[str]):
        """
        :param pulumi.Input[str] backend_service: The full or partial URL to the BackendService resource being mirrored to.
        """
        pulumi.set(__self__, "backend_service", backend_service)

    @property
    @pulumi.getter(name="backendService")
    def backend_service(self) -> pulumi.Input[str]:
        """
        The full or partial URL to the BackendService resource being mirrored to.
        """
        return pulumi.get(self, "backend_service")

    @backend_service.setter
    def backend_service(self, value: pulumi.Input[str]):
        pulumi.set(self, "backend_service", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleRouteActionRetryPolicyArgs:
    def __init__(__self__, *,
                 num_retries: pulumi.Input[int],
                 per_try_timeout: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeoutArgs']] = None,
                 retry_conditions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[int] num_retries: Specifies the allowed number retries. This number must be > 0. If not specified, defaults to 1.
        :param pulumi.Input['URLMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeoutArgs'] per_try_timeout: Specifies a non-zero timeout per retry attempt.
               If not specified, will use the timeout set in HttpRouteAction. If timeout in HttpRouteAction is not set,
               will use the largest timeout among all backend services associated with the route.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] retry_conditions: Specfies one or more conditions when this retry rule applies. Valid values are:
               * 5xx: Loadbalancer will attempt a retry if the backend service responds with any 5xx response code,
               or if the backend service does not respond at all, example: disconnects, reset, read timeout,
               * connection failure, and refused streams.
               * gateway-error: Similar to 5xx, but only applies to response codes 502, 503 or 504.
               * connect-failure: Loadbalancer will retry on failures connecting to backend services,
               for example due to connection timeouts.
               * retriable-4xx: Loadbalancer will retry for retriable 4xx response codes.
               Currently the only retriable error supported is 409.
               * refused-stream:Loadbalancer will retry if the backend service resets the stream with a REFUSED_STREAM error code.
               This reset type indicates that it is safe to retry.
               * cancelled: Loadbalancer will retry if the gRPC status code in the response header is set to cancelled
               * deadline-exceeded: Loadbalancer will retry if the gRPC status code in the response header is set to deadline-exceeded
               * resource-exhausted: Loadbalancer will retry if the gRPC status code in the response header is set to resource-exhausted
               * unavailable: Loadbalancer will retry if the gRPC status code in the response header is set to unavailable
        """
        pulumi.set(__self__, "num_retries", num_retries)
        if per_try_timeout is not None:
            pulumi.set(__self__, "per_try_timeout", per_try_timeout)
        if retry_conditions is not None:
            pulumi.set(__self__, "retry_conditions", retry_conditions)

    @property
    @pulumi.getter(name="numRetries")
    def num_retries(self) -> pulumi.Input[int]:
        """
        Specifies the allowed number retries. This number must be > 0. If not specified, defaults to 1.
        """
        return pulumi.get(self, "num_retries")

    @num_retries.setter
    def num_retries(self, value: pulumi.Input[int]):
        pulumi.set(self, "num_retries", value)

    @property
    @pulumi.getter(name="perTryTimeout")
    def per_try_timeout(self) -> Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeoutArgs']]:
        """
        Specifies a non-zero timeout per retry attempt.
        If not specified, will use the timeout set in HttpRouteAction. If timeout in HttpRouteAction is not set,
        will use the largest timeout among all backend services associated with the route.
        Structure is documented below.
        """
        return pulumi.get(self, "per_try_timeout")

    @per_try_timeout.setter
    def per_try_timeout(self, value: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeoutArgs']]):
        pulumi.set(self, "per_try_timeout", value)

    @property
    @pulumi.getter(name="retryConditions")
    def retry_conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specfies one or more conditions when this retry rule applies. Valid values are:
        * 5xx: Loadbalancer will attempt a retry if the backend service responds with any 5xx response code,
        or if the backend service does not respond at all, example: disconnects, reset, read timeout,
        * connection failure, and refused streams.
        * gateway-error: Similar to 5xx, but only applies to response codes 502, 503 or 504.
        * connect-failure: Loadbalancer will retry on failures connecting to backend services,
        for example due to connection timeouts.
        * retriable-4xx: Loadbalancer will retry for retriable 4xx response codes.
        Currently the only retriable error supported is 409.
        * refused-stream:Loadbalancer will retry if the backend service resets the stream with a REFUSED_STREAM error code.
        This reset type indicates that it is safe to retry.
        * cancelled: Loadbalancer will retry if the gRPC status code in the response header is set to cancelled
        * deadline-exceeded: Loadbalancer will retry if the gRPC status code in the response header is set to deadline-exceeded
        * resource-exhausted: Loadbalancer will retry if the gRPC status code in the response header is set to resource-exhausted
        * unavailable: Loadbalancer will retry if the gRPC status code in the response header is set to unavailable
        """
        return pulumi.get(self, "retry_conditions")

    @retry_conditions.setter
    def retry_conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "retry_conditions", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeoutArgs:
    def __init__(__self__, *,
                 seconds: pulumi.Input[str],
                 nanos: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
               Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
               represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        """
        pulumi.set(__self__, "seconds", seconds)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)

    @property
    @pulumi.getter
    def seconds(self) -> pulumi.Input[str]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
        Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: pulumi.Input[str]):
        pulumi.set(self, "seconds", value)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
        represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleRouteActionTimeoutArgs:
    def __init__(__self__, *,
                 seconds: pulumi.Input[str],
                 nanos: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
               Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        :param pulumi.Input[int] nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
               represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        """
        pulumi.set(__self__, "seconds", seconds)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)

    @property
    @pulumi.getter
    def seconds(self) -> pulumi.Input[str]:
        """
        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
        Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: pulumi.Input[str]):
        pulumi.set(self, "seconds", value)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are
        represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleRouteActionUrlRewriteArgs:
    def __init__(__self__, *,
                 host_rewrite: Optional[pulumi.Input[str]] = None,
                 path_prefix_rewrite: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host_rewrite: Prior to forwarding the request to the selected service, the request's host header is replaced
               with contents of hostRewrite.
               The value must be between 1 and 255 characters.
        :param pulumi.Input[str] path_prefix_rewrite: Prior to forwarding the request to the selected backend service, the matching portion of the
               request's path is replaced by pathPrefixRewrite.
               The value must be between 1 and 1024 characters.
        """
        if host_rewrite is not None:
            pulumi.set(__self__, "host_rewrite", host_rewrite)
        if path_prefix_rewrite is not None:
            pulumi.set(__self__, "path_prefix_rewrite", path_prefix_rewrite)

    @property
    @pulumi.getter(name="hostRewrite")
    def host_rewrite(self) -> Optional[pulumi.Input[str]]:
        """
        Prior to forwarding the request to the selected service, the request's host header is replaced
        with contents of hostRewrite.
        The value must be between 1 and 255 characters.
        """
        return pulumi.get(self, "host_rewrite")

    @host_rewrite.setter
    def host_rewrite(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_rewrite", value)

    @property
    @pulumi.getter(name="pathPrefixRewrite")
    def path_prefix_rewrite(self) -> Optional[pulumi.Input[str]]:
        """
        Prior to forwarding the request to the selected backend service, the matching portion of the
        request's path is replaced by pathPrefixRewrite.
        The value must be between 1 and 1024 characters.
        """
        return pulumi.get(self, "path_prefix_rewrite")

    @path_prefix_rewrite.setter
    def path_prefix_rewrite(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path_prefix_rewrite", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceArgs:
    def __init__(__self__, *,
                 backend_service: pulumi.Input[str],
                 weight: pulumi.Input[int],
                 header_action: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionArgs']] = None):
        """
        :param pulumi.Input[str] backend_service: The full or partial URL to the BackendService resource being mirrored to.
        :param pulumi.Input[int] weight: Specifies the fraction of traffic sent to backendService, computed as
               weight / (sum of all weightedBackendService weights in routeAction) .
               The selection of a backend service is determined only for new traffic. Once a user's request
               has been directed to a backendService, subsequent requests will be sent to the same backendService
               as determined by the BackendService's session affinity policy.
               The value must be between 0 and 1000
        :param pulumi.Input['URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionArgs'] header_action: Specifies changes to request and response headers that need to take effect for
               the selected backendService.
               headerAction specified here take effect before headerAction in the enclosing
               HttpRouteRule, PathMatcher and UrlMap.
               Structure is documented below.
        """
        pulumi.set(__self__, "backend_service", backend_service)
        pulumi.set(__self__, "weight", weight)
        if header_action is not None:
            pulumi.set(__self__, "header_action", header_action)

    @property
    @pulumi.getter(name="backendService")
    def backend_service(self) -> pulumi.Input[str]:
        """
        The full or partial URL to the BackendService resource being mirrored to.
        """
        return pulumi.get(self, "backend_service")

    @backend_service.setter
    def backend_service(self, value: pulumi.Input[str]):
        pulumi.set(self, "backend_service", value)

    @property
    @pulumi.getter
    def weight(self) -> pulumi.Input[int]:
        """
        Specifies the fraction of traffic sent to backendService, computed as
        weight / (sum of all weightedBackendService weights in routeAction) .
        The selection of a backend service is determined only for new traffic. Once a user's request
        has been directed to a backendService, subsequent requests will be sent to the same backendService
        as determined by the BackendService's session affinity policy.
        The value must be between 0 and 1000
        """
        return pulumi.get(self, "weight")

    @weight.setter
    def weight(self, value: pulumi.Input[int]):
        pulumi.set(self, "weight", value)

    @property
    @pulumi.getter(name="headerAction")
    def header_action(self) -> Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionArgs']]:
        """
        Specifies changes to request and response headers that need to take effect for
        the selected backendService.
        headerAction specified here take effect before headerAction in the enclosing
        HttpRouteRule, PathMatcher and UrlMap.
        Structure is documented below.
        """
        return pulumi.get(self, "header_action")

    @header_action.setter
    def header_action(self, value: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionArgs']]):
        pulumi.set(self, "header_action", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionArgs:
    def __init__(__self__, *,
                 request_headers_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]]] = None,
                 request_headers_to_removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 response_headers_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]]] = None,
                 response_headers_to_removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]] request_headers_to_adds: Headers to add to a matching request prior to forwarding the request to the backendService.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] request_headers_to_removes: A list of header names for headers that need to be removed from the request prior to
               forwarding the request to the backendService.
        :param pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]] response_headers_to_adds: Headers to add the response prior to sending the response back to the client.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] response_headers_to_removes: A list of header names for headers that need to be removed from the response prior to sending the
               response back to the client.
        """
        if request_headers_to_adds is not None:
            pulumi.set(__self__, "request_headers_to_adds", request_headers_to_adds)
        if request_headers_to_removes is not None:
            pulumi.set(__self__, "request_headers_to_removes", request_headers_to_removes)
        if response_headers_to_adds is not None:
            pulumi.set(__self__, "response_headers_to_adds", response_headers_to_adds)
        if response_headers_to_removes is not None:
            pulumi.set(__self__, "response_headers_to_removes", response_headers_to_removes)

    @property
    @pulumi.getter(name="requestHeadersToAdds")
    def request_headers_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]]]:
        """
        Headers to add to a matching request prior to forwarding the request to the backendService.
        Structure is documented below.
        """
        return pulumi.get(self, "request_headers_to_adds")

    @request_headers_to_adds.setter
    def request_headers_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs']]]]):
        pulumi.set(self, "request_headers_to_adds", value)

    @property
    @pulumi.getter(name="requestHeadersToRemoves")
    def request_headers_to_removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of header names for headers that need to be removed from the request prior to
        forwarding the request to the backendService.
        """
        return pulumi.get(self, "request_headers_to_removes")

    @request_headers_to_removes.setter
    def request_headers_to_removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "request_headers_to_removes", value)

    @property
    @pulumi.getter(name="responseHeadersToAdds")
    def response_headers_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]]]:
        """
        Headers to add the response prior to sending the response back to the client.
        Structure is documented below.
        """
        return pulumi.get(self, "response_headers_to_adds")

    @response_headers_to_adds.setter
    def response_headers_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs']]]]):
        pulumi.set(self, "response_headers_to_adds", value)

    @property
    @pulumi.getter(name="responseHeadersToRemoves")
    def response_headers_to_removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of header names for headers that need to be removed from the response prior to sending the
        response back to the client.
        """
        return pulumi.get(self, "response_headers_to_removes")

    @response_headers_to_removes.setter
    def response_headers_to_removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "response_headers_to_removes", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 header_value: pulumi.Input[str],
                 replace: pulumi.Input[bool]):
        """
        :param pulumi.Input[str] header_name: The name of the header to add.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: If false, headerValue is appended to any values that already exist for the header.
               If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)
        pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> pulumi.Input[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> pulumi.Input[bool]:
        """
        If false, headerValue is appended to any values that already exist for the header.
        If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: pulumi.Input[bool]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 header_value: pulumi.Input[str],
                 replace: pulumi.Input[bool]):
        """
        :param pulumi.Input[str] header_name: The name of the header to add.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: If false, headerValue is appended to any values that already exist for the header.
               If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)
        pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> pulumi.Input[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> pulumi.Input[bool]:
        """
        If false, headerValue is appended to any values that already exist for the header.
        If true, headerValue is set for the header, discarding any values that were set for that header.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: pulumi.Input[bool]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class URLMapPathMatcherRouteRuleUrlRedirectArgs:
    def __init__(__self__, *,
                 host_redirect: Optional[pulumi.Input[str]] = None,
                 https_redirect: Optional[pulumi.Input[bool]] = None,
                 path_redirect: Optional[pulumi.Input[str]] = None,
                 prefix_redirect: Optional[pulumi.Input[str]] = None,
                 redirect_response_code: Optional[pulumi.Input[str]] = None,
                 strip_query: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] host_redirect: The host that will be used in the redirect response instead of the one that was
               supplied in the request. The value must be between 1 and 255 characters.
        :param pulumi.Input[bool] https_redirect: If set to true, the URL scheme in the redirected request is set to https. If set to
               false, the URL scheme of the redirected request will remain the same as that of the
               request. This must only be set for UrlMaps used in TargetHttpProxys. Setting this
               true for TargetHttpsProxy is not permitted. The default is set to false.
        :param pulumi.Input[str] path_redirect: The path that will be used in the redirect response instead of the one that was
               supplied in the request. pathRedirect cannot be supplied together with
               prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the
               original request will be used for the redirect. The value must be between 1 and 1024
               characters.
        :param pulumi.Input[str] prefix_redirect: The prefix that replaces the prefixMatch specified in the HttpRouteRuleMatch,
               retaining the remaining portion of the URL before redirecting the request.
               prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or
               neither. If neither is supplied, the path of the original request will be used for
               the redirect. The value must be between 1 and 1024 characters.
        :param pulumi.Input[str] redirect_response_code: The HTTP Status code to use for this RedirectAction. Supported values are:
               * MOVED_PERMANENTLY_DEFAULT, which is the default value and corresponds to 301.
               * FOUND, which corresponds to 302.
               * SEE_OTHER which corresponds to 303.
               * TEMPORARY_REDIRECT, which corresponds to 307. In this case, the request method
               will be retained.
               * PERMANENT_REDIRECT, which corresponds to 308. In this case,
               the request method will be retained.
        :param pulumi.Input[bool] strip_query: If set to true, any accompanying query portion of the original URL is removed prior
               to redirecting the request. If set to false, the query portion of the original URL is
               retained. The default is set to false.
               This field is required to ensure an empty block is not set. The normal default value is false.
        """
        if host_redirect is not None:
            pulumi.set(__self__, "host_redirect", host_redirect)
        if https_redirect is not None:
            pulumi.set(__self__, "https_redirect", https_redirect)
        if path_redirect is not None:
            pulumi.set(__self__, "path_redirect", path_redirect)
        if prefix_redirect is not None:
            pulumi.set(__self__, "prefix_redirect", prefix_redirect)
        if redirect_response_code is not None:
            pulumi.set(__self__, "redirect_response_code", redirect_response_code)
        if strip_query is not None:
            pulumi.set(__self__, "strip_query", strip_query)

    @property
    @pulumi.getter(name="hostRedirect")
    def host_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The host that will be used in the redirect response instead of the one that was
        supplied in the request. The value must be between 1 and 255 characters.
        """
        return pulumi.get(self, "host_redirect")

    @host_redirect.setter
    def host_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_redirect", value)

    @property
    @pulumi.getter(name="httpsRedirect")
    def https_redirect(self) -> Optional[pulumi.Input[bool]]:
        """
        If set to true, the URL scheme in the redirected request is set to https. If set to
        false, the URL scheme of the redirected request will remain the same as that of the
        request. This must only be set for UrlMaps used in TargetHttpProxys. Setting this
        true for TargetHttpsProxy is not permitted. The default is set to false.
        """
        return pulumi.get(self, "https_redirect")

    @https_redirect.setter
    def https_redirect(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "https_redirect", value)

    @property
    @pulumi.getter(name="pathRedirect")
    def path_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The path that will be used in the redirect response instead of the one that was
        supplied in the request. pathRedirect cannot be supplied together with
        prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the
        original request will be used for the redirect. The value must be between 1 and 1024
        characters.
        """
        return pulumi.get(self, "path_redirect")

    @path_redirect.setter
    def path_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path_redirect", value)

    @property
    @pulumi.getter(name="prefixRedirect")
    def prefix_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The prefix that replaces the prefixMatch specified in the HttpRouteRuleMatch,
        retaining the remaining portion of the URL before redirecting the request.
        prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or
        neither. If neither is supplied, the path of the original request will be used for
        the redirect. The value must be between 1 and 1024 characters.
        """
        return pulumi.get(self, "prefix_redirect")

    @prefix_redirect.setter
    def prefix_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "prefix_redirect", value)

    @property
    @pulumi.getter(name="redirectResponseCode")
    def redirect_response_code(self) -> Optional[pulumi.Input[str]]:
        """
        The HTTP Status code to use for this RedirectAction. Supported values are:
        * MOVED_PERMANENTLY_DEFAULT, which is the default value and corresponds to 301.
        * FOUND, which corresponds to 302.
        * SEE_OTHER which corresponds to 303.
        * TEMPORARY_REDIRECT, which corresponds to 307. In this case, the request method
        will be retained.
        * PERMANENT_REDIRECT, which corresponds to 308. In this case,
        the request method will be retained.
        """
        return pulumi.get(self, "redirect_response_code")

    @redirect_response_code.setter
    def redirect_response_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "redirect_response_code", value)

    @property
    @pulumi.getter(name="stripQuery")
    def strip_query(self) -> Optional[pulumi.Input[bool]]:
        """
        If set to true, any accompanying query portion of the original URL is removed prior
        to redirecting the request. If set to false, the query portion of the original URL is
        retained. The default is set to false.
        This field is required to ensure an empty block is not set. The normal default value is false.
        """
        return pulumi.get(self, "strip_query")

    @strip_query.setter
    def strip_query(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "strip_query", value)


@pulumi.input_type
class URLMapTestArgs:
    def __init__(__self__, *,
                 host: pulumi.Input[str],
                 path: pulumi.Input[str],
                 service: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host: Host portion of the URL.
        :param pulumi.Input[str] path: Path portion of the URL.
        :param pulumi.Input[str] service: The backend service or backend bucket link that should be matched by this test.
        :param pulumi.Input[str] description: Description of this test case.
        """
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "service", service)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def host(self) -> pulumi.Input[str]:
        """
        Host portion of the URL.
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: pulumi.Input[str]):
        pulumi.set(self, "host", value)

    @property
    @pulumi.getter
    def path(self) -> pulumi.Input[str]:
        """
        Path portion of the URL.
        """
        return pulumi.get(self, "path")

    @path.setter
    def path(self, value: pulumi.Input[str]):
        pulumi.set(self, "path", value)

    @property
    @pulumi.getter
    def service(self) -> pulumi.Input[str]:
        """
        The backend service or backend bucket link that should be matched by this test.
        """
        return pulumi.get(self, "service")

    @service.setter
    def service(self, value: pulumi.Input[str]):
        pulumi.set(self, "service", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        Description of this test case.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


