# 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
from . import outputs

__all__ = [
    'AutoscalarAutoscalingPolicy',
    'AutoscalarAutoscalingPolicyCpuUtilization',
    'AutoscalarAutoscalingPolicyLoadBalancingUtilization',
    'AutoscalarAutoscalingPolicyMetric',
    'AutoscalarAutoscalingPolicyScaleDownControl',
    'AutoscalarAutoscalingPolicyScaleDownControlMaxScaledDownReplicas',
    'AutoscalarAutoscalingPolicyScaleInControl',
    'AutoscalarAutoscalingPolicyScaleInControlMaxScaledInReplicas',
    'AutoscalarAutoscalingPolicyScalingSchedule',
    'AutoscalerAutoscalingPolicy',
    'AutoscalerAutoscalingPolicyCpuUtilization',
    'AutoscalerAutoscalingPolicyLoadBalancingUtilization',
    'AutoscalerAutoscalingPolicyMetric',
    'AutoscalerAutoscalingPolicyScaleDownControl',
    'AutoscalerAutoscalingPolicyScaleDownControlMaxScaledDownReplicas',
    'AutoscalerAutoscalingPolicyScaleInControl',
    'AutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicas',
    'AutoscalerAutoscalingPolicyScalingSchedule',
    'BackendBucketCdnPolicy',
    'BackendBucketCdnPolicyBypassCacheOnRequestHeader',
    'BackendBucketCdnPolicyCacheKeyPolicy',
    'BackendBucketCdnPolicyNegativeCachingPolicy',
    'BackendBucketIamBindingCondition',
    'BackendBucketIamMemberCondition',
    'BackendServiceBackend',
    'BackendServiceCdnPolicy',
    'BackendServiceCdnPolicyCacheKeyPolicy',
    'BackendServiceCdnPolicyNegativeCachingPolicy',
    'BackendServiceCircuitBreakers',
    'BackendServiceCircuitBreakersConnectTimeout',
    'BackendServiceConsistentHash',
    'BackendServiceConsistentHashHttpCookie',
    'BackendServiceConsistentHashHttpCookieTtl',
    'BackendServiceIamBindingCondition',
    'BackendServiceIamMemberCondition',
    'BackendServiceIap',
    'BackendServiceLocalityLbPolicy',
    'BackendServiceLocalityLbPolicyCustomPolicy',
    'BackendServiceLocalityLbPolicyPolicy',
    'BackendServiceLogConfig',
    'BackendServiceOutlierDetection',
    'BackendServiceOutlierDetectionBaseEjectionTime',
    'BackendServiceOutlierDetectionInterval',
    'BackendServiceSecuritySettings',
    'DiskDiskEncryptionKey',
    'DiskIamBindingCondition',
    'DiskIamMemberCondition',
    'DiskSourceImageEncryptionKey',
    'DiskSourceSnapshotEncryptionKey',
    'ExternalVpnGatewayInterface',
    'FirewallAllow',
    'FirewallDeny',
    'FirewallLogConfig',
    'FirewallPolicyRuleMatch',
    'FirewallPolicyRuleMatchLayer4Config',
    'ForwardingRuleServiceDirectoryRegistration',
    'GlobalForwardingRuleMetadataFilter',
    'GlobalForwardingRuleMetadataFilterFilterLabel',
    'HaVpnGatewayVpnInterface',
    'HealthCheckGrpcHealthCheck',
    'HealthCheckHttp2HealthCheck',
    'HealthCheckHttpHealthCheck',
    'HealthCheckHttpsHealthCheck',
    'HealthCheckLogConfig',
    'HealthCheckSslHealthCheck',
    'HealthCheckTcpHealthCheck',
    'ImageGuestOsFeature',
    'ImageIamBindingCondition',
    'ImageIamMemberCondition',
    'ImageImageEncryptionKey',
    'ImageRawDisk',
    'InstanceAdvancedMachineFeatures',
    'InstanceAttachedDisk',
    'InstanceBootDisk',
    'InstanceBootDiskInitializeParams',
    'InstanceConfidentialInstanceConfig',
    'InstanceFromMachineImageAdvancedMachineFeatures',
    'InstanceFromMachineImageAttachedDisk',
    'InstanceFromMachineImageBootDisk',
    'InstanceFromMachineImageBootDiskInitializeParams',
    'InstanceFromMachineImageConfidentialInstanceConfig',
    'InstanceFromMachineImageGuestAccelerator',
    'InstanceFromMachineImageNetworkInterface',
    'InstanceFromMachineImageNetworkInterfaceAccessConfig',
    'InstanceFromMachineImageNetworkInterfaceAliasIpRange',
    'InstanceFromMachineImageNetworkInterfaceIpv6AccessConfig',
    'InstanceFromMachineImageNetworkPerformanceConfig',
    'InstanceFromMachineImageReservationAffinity',
    'InstanceFromMachineImageReservationAffinitySpecificReservation',
    'InstanceFromMachineImageScheduling',
    'InstanceFromMachineImageSchedulingMaxRunDuration',
    'InstanceFromMachineImageSchedulingNodeAffinity',
    'InstanceFromMachineImageScratchDisk',
    'InstanceFromMachineImageServiceAccount',
    'InstanceFromMachineImageShieldedInstanceConfig',
    'InstanceFromTemplateAdvancedMachineFeatures',
    'InstanceFromTemplateAttachedDisk',
    'InstanceFromTemplateBootDisk',
    'InstanceFromTemplateBootDiskInitializeParams',
    'InstanceFromTemplateConfidentialInstanceConfig',
    'InstanceFromTemplateGuestAccelerator',
    'InstanceFromTemplateNetworkInterface',
    'InstanceFromTemplateNetworkInterfaceAccessConfig',
    'InstanceFromTemplateNetworkInterfaceAliasIpRange',
    'InstanceFromTemplateNetworkInterfaceIpv6AccessConfig',
    'InstanceFromTemplateNetworkPerformanceConfig',
    'InstanceFromTemplateReservationAffinity',
    'InstanceFromTemplateReservationAffinitySpecificReservation',
    'InstanceFromTemplateScheduling',
    'InstanceFromTemplateSchedulingMaxRunDuration',
    'InstanceFromTemplateSchedulingNodeAffinity',
    'InstanceFromTemplateScratchDisk',
    'InstanceFromTemplateServiceAccount',
    'InstanceFromTemplateShieldedInstanceConfig',
    'InstanceGroupManagerAllInstancesConfig',
    'InstanceGroupManagerAutoHealingPolicies',
    'InstanceGroupManagerInstanceLifecyclePolicy',
    'InstanceGroupManagerNamedPort',
    'InstanceGroupManagerStatefulDisk',
    'InstanceGroupManagerStatefulExternalIp',
    'InstanceGroupManagerStatefulInternalIp',
    'InstanceGroupManagerStatus',
    'InstanceGroupManagerStatusAllInstancesConfig',
    'InstanceGroupManagerStatusStateful',
    'InstanceGroupManagerStatusStatefulPerInstanceConfig',
    'InstanceGroupManagerStatusVersionTarget',
    'InstanceGroupManagerUpdatePolicy',
    'InstanceGroupManagerVersion',
    'InstanceGroupManagerVersionTargetSize',
    'InstanceGroupNamedPort',
    'InstanceGuestAccelerator',
    'InstanceIAMBindingCondition',
    'InstanceIAMMemberCondition',
    'InstanceNetworkInterface',
    'InstanceNetworkInterfaceAccessConfig',
    'InstanceNetworkInterfaceAliasIpRange',
    'InstanceNetworkInterfaceIpv6AccessConfig',
    'InstanceNetworkPerformanceConfig',
    'InstanceReservationAffinity',
    'InstanceReservationAffinitySpecificReservation',
    'InstanceScheduling',
    'InstanceSchedulingMaxRunDuration',
    'InstanceSchedulingNodeAffinity',
    'InstanceScratchDisk',
    'InstanceServiceAccount',
    'InstanceShieldedInstanceConfig',
    'InstanceTemplateAdvancedMachineFeatures',
    'InstanceTemplateConfidentialInstanceConfig',
    'InstanceTemplateDisk',
    'InstanceTemplateDiskDiskEncryptionKey',
    'InstanceTemplateDiskSourceImageEncryptionKey',
    'InstanceTemplateDiskSourceSnapshotEncryptionKey',
    'InstanceTemplateGuestAccelerator',
    'InstanceTemplateNetworkInterface',
    'InstanceTemplateNetworkInterfaceAccessConfig',
    'InstanceTemplateNetworkInterfaceAliasIpRange',
    'InstanceTemplateNetworkInterfaceIpv6AccessConfig',
    'InstanceTemplateNetworkPerformanceConfig',
    'InstanceTemplateReservationAffinity',
    'InstanceTemplateReservationAffinitySpecificReservation',
    'InstanceTemplateScheduling',
    'InstanceTemplateSchedulingMaxRunDuration',
    'InstanceTemplateSchedulingNodeAffinity',
    'InstanceTemplateServiceAccount',
    'InstanceTemplateShieldedInstanceConfig',
    'InterconnectAttachmentPrivateInterconnectInfo',
    'MachineImageIamBindingCondition',
    'MachineImageIamMemberCondition',
    'MachineImageMachineImageEncryptionKey',
    'ManagedSslCertificateManaged',
    'MangedSslCertificateManaged',
    'NetworkFirewallPolicyRuleMatch',
    'NetworkFirewallPolicyRuleMatchLayer4Config',
    'NetworkFirewallPolicyRuleMatchSrcSecureTag',
    'NetworkFirewallPolicyRuleTargetSecureTag',
    'NodeGroupAutoscalingPolicy',
    'NodeGroupMaintenanceWindow',
    'NodeGroupShareSettings',
    'NodeGroupShareSettingsProjectMap',
    'NodeTemplateNodeTypeFlexibility',
    'NodeTemplateServerBinding',
    'OrganizationSecurityPolicyRuleMatch',
    'OrganizationSecurityPolicyRuleMatchConfig',
    'OrganizationSecurityPolicyRuleMatchConfigLayer4Config',
    'PacketMirroringCollectorIlb',
    'PacketMirroringFilter',
    'PacketMirroringMirroredResources',
    'PacketMirroringMirroredResourcesInstance',
    'PacketMirroringMirroredResourcesSubnetwork',
    'PacketMirroringNetwork',
    'PerInstanceConfigPreservedState',
    'PerInstanceConfigPreservedStateDisk',
    'PerInstanceConfigPreservedStateExternalIp',
    'PerInstanceConfigPreservedStateExternalIpIpAddress',
    'PerInstanceConfigPreservedStateInternalIp',
    'PerInstanceConfigPreservedStateInternalIpIpAddress',
    'RegionAutoscalerAutoscalingPolicy',
    'RegionAutoscalerAutoscalingPolicyCpuUtilization',
    'RegionAutoscalerAutoscalingPolicyLoadBalancingUtilization',
    'RegionAutoscalerAutoscalingPolicyMetric',
    'RegionAutoscalerAutoscalingPolicyScaleDownControl',
    'RegionAutoscalerAutoscalingPolicyScaleDownControlMaxScaledDownReplicas',
    'RegionAutoscalerAutoscalingPolicyScaleInControl',
    'RegionAutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicas',
    'RegionAutoscalerAutoscalingPolicyScalingSchedule',
    'RegionBackendServiceBackend',
    'RegionBackendServiceCdnPolicy',
    'RegionBackendServiceCdnPolicyCacheKeyPolicy',
    'RegionBackendServiceCdnPolicyNegativeCachingPolicy',
    'RegionBackendServiceCircuitBreakers',
    'RegionBackendServiceCircuitBreakersConnectTimeout',
    'RegionBackendServiceConnectionTrackingPolicy',
    'RegionBackendServiceConsistentHash',
    'RegionBackendServiceConsistentHashHttpCookie',
    'RegionBackendServiceConsistentHashHttpCookieTtl',
    'RegionBackendServiceFailoverPolicy',
    'RegionBackendServiceIamBindingCondition',
    'RegionBackendServiceIamMemberCondition',
    'RegionBackendServiceIap',
    'RegionBackendServiceLogConfig',
    'RegionBackendServiceOutlierDetection',
    'RegionBackendServiceOutlierDetectionBaseEjectionTime',
    'RegionBackendServiceOutlierDetectionInterval',
    'RegionBackendServiceSubsetting',
    'RegionDiskDiskEncryptionKey',
    'RegionDiskIamBindingCondition',
    'RegionDiskIamMemberCondition',
    'RegionDiskSourceSnapshotEncryptionKey',
    'RegionHealthCheckGrpcHealthCheck',
    'RegionHealthCheckHttp2HealthCheck',
    'RegionHealthCheckHttpHealthCheck',
    'RegionHealthCheckHttpsHealthCheck',
    'RegionHealthCheckLogConfig',
    'RegionHealthCheckSslHealthCheck',
    'RegionHealthCheckTcpHealthCheck',
    'RegionInstanceGroupManagerAllInstancesConfig',
    'RegionInstanceGroupManagerAutoHealingPolicies',
    'RegionInstanceGroupManagerInstanceLifecyclePolicy',
    'RegionInstanceGroupManagerNamedPort',
    'RegionInstanceGroupManagerStatefulDisk',
    'RegionInstanceGroupManagerStatefulExternalIp',
    'RegionInstanceGroupManagerStatefulInternalIp',
    'RegionInstanceGroupManagerStatus',
    'RegionInstanceGroupManagerStatusAllInstancesConfig',
    'RegionInstanceGroupManagerStatusStateful',
    'RegionInstanceGroupManagerStatusStatefulPerInstanceConfig',
    'RegionInstanceGroupManagerStatusVersionTarget',
    'RegionInstanceGroupManagerUpdatePolicy',
    'RegionInstanceGroupManagerVersion',
    'RegionInstanceGroupManagerVersionTargetSize',
    'RegionNetworkEndpointGroupAppEngine',
    'RegionNetworkEndpointGroupCloudFunction',
    'RegionNetworkEndpointGroupCloudRun',
    'RegionNetworkEndpointGroupServerlessDeployment',
    'RegionNetworkFirewallPolicyRuleMatch',
    'RegionNetworkFirewallPolicyRuleMatchLayer4Config',
    'RegionNetworkFirewallPolicyRuleMatchSrcSecureTag',
    'RegionNetworkFirewallPolicyRuleTargetSecureTag',
    'RegionPerInstanceConfigPreservedState',
    'RegionPerInstanceConfigPreservedStateDisk',
    'RegionPerInstanceConfigPreservedStateExternalIp',
    'RegionPerInstanceConfigPreservedStateExternalIpIpAddress',
    'RegionPerInstanceConfigPreservedStateInternalIp',
    'RegionPerInstanceConfigPreservedStateInternalIpIpAddress',
    'RegionUrlMapDefaultRouteAction',
    'RegionUrlMapDefaultRouteActionCorsPolicy',
    'RegionUrlMapDefaultRouteActionFaultInjectionPolicy',
    'RegionUrlMapDefaultRouteActionFaultInjectionPolicyAbort',
    'RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelay',
    'RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelay',
    'RegionUrlMapDefaultRouteActionRequestMirrorPolicy',
    'RegionUrlMapDefaultRouteActionRetryPolicy',
    'RegionUrlMapDefaultRouteActionRetryPolicyPerTryTimeout',
    'RegionUrlMapDefaultRouteActionTimeout',
    'RegionUrlMapDefaultRouteActionUrlRewrite',
    'RegionUrlMapDefaultRouteActionWeightedBackendService',
    'RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderAction',
    'RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd',
    'RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd',
    'RegionUrlMapDefaultUrlRedirect',
    'RegionUrlMapHostRule',
    'RegionUrlMapPathMatcher',
    'RegionUrlMapPathMatcherDefaultUrlRedirect',
    'RegionUrlMapPathMatcherPathRule',
    'RegionUrlMapPathMatcherPathRuleRouteAction',
    'RegionUrlMapPathMatcherPathRuleRouteActionCorsPolicy',
    'RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicy',
    'RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbort',
    'RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelay',
    'RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelay',
    'RegionUrlMapPathMatcherPathRuleRouteActionRequestMirrorPolicy',
    'RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicy',
    'RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeout',
    'RegionUrlMapPathMatcherPathRuleRouteActionTimeout',
    'RegionUrlMapPathMatcherPathRuleRouteActionUrlRewrite',
    'RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendService',
    'RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderAction',
    'RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd',
    'RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd',
    'RegionUrlMapPathMatcherPathRuleUrlRedirect',
    'RegionUrlMapPathMatcherRouteRule',
    'RegionUrlMapPathMatcherRouteRuleHeaderAction',
    'RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAdd',
    'RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAdd',
    'RegionUrlMapPathMatcherRouteRuleMatchRule',
    'RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatch',
    'RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatch',
    'RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilter',
    'RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabel',
    'RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatch',
    'RegionUrlMapPathMatcherRouteRuleRouteAction',
    'RegionUrlMapPathMatcherRouteRuleRouteActionCorsPolicy',
    'RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicy',
    'RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbort',
    'RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelay',
    'RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelay',
    'RegionUrlMapPathMatcherRouteRuleRouteActionRequestMirrorPolicy',
    'RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicy',
    'RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeout',
    'RegionUrlMapPathMatcherRouteRuleRouteActionTimeout',
    'RegionUrlMapPathMatcherRouteRuleRouteActionUrlRewrite',
    'RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendService',
    'RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderAction',
    'RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd',
    'RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd',
    'RegionUrlMapPathMatcherRouteRuleUrlRedirect',
    'RegionUrlMapTest',
    'ReservationShareSettings',
    'ReservationShareSettingsProjectMap',
    'ReservationSpecificReservation',
    'ReservationSpecificReservationInstanceProperties',
    'ReservationSpecificReservationInstancePropertiesGuestAccelerator',
    'ReservationSpecificReservationInstancePropertiesLocalSsd',
    'ResourcePolicyGroupPlacementPolicy',
    'ResourcePolicyInstanceSchedulePolicy',
    'ResourcePolicyInstanceSchedulePolicyVmStartSchedule',
    'ResourcePolicyInstanceSchedulePolicyVmStopSchedule',
    'ResourcePolicySnapshotSchedulePolicy',
    'ResourcePolicySnapshotSchedulePolicyRetentionPolicy',
    'ResourcePolicySnapshotSchedulePolicySchedule',
    'ResourcePolicySnapshotSchedulePolicyScheduleDailySchedule',
    'ResourcePolicySnapshotSchedulePolicyScheduleHourlySchedule',
    'ResourcePolicySnapshotSchedulePolicyScheduleWeeklySchedule',
    'ResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleDayOfWeek',
    'ResourcePolicySnapshotSchedulePolicySnapshotProperties',
    'RouterBgp',
    'RouterBgpAdvertisedIpRange',
    'RouterNatLogConfig',
    'RouterNatRule',
    'RouterNatRuleAction',
    'RouterNatSubnetwork',
    'RouterPeerAdvertisedIpRange',
    'RouterPeerBfd',
    'RouterStatusBestRouteResult',
    'RouterStatusBestRoutesForRouterResult',
    'SecurityPolicyAdaptiveProtectionConfig',
    'SecurityPolicyAdaptiveProtectionConfigAutoDeployConfig',
    'SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig',
    'SecurityPolicyAdvancedOptionsConfig',
    'SecurityPolicyAdvancedOptionsConfigJsonCustomConfig',
    'SecurityPolicyRecaptchaOptionsConfig',
    'SecurityPolicyRule',
    'SecurityPolicyRuleHeaderAction',
    'SecurityPolicyRuleHeaderActionRequestHeadersToAdd',
    'SecurityPolicyRuleMatch',
    'SecurityPolicyRuleMatchConfig',
    'SecurityPolicyRuleMatchExpr',
    'SecurityPolicyRulePreconfiguredWafConfig',
    'SecurityPolicyRulePreconfiguredWafConfigExclusion',
    'SecurityPolicyRulePreconfiguredWafConfigExclusionRequestCooky',
    'SecurityPolicyRulePreconfiguredWafConfigExclusionRequestHeader',
    'SecurityPolicyRulePreconfiguredWafConfigExclusionRequestQueryParam',
    'SecurityPolicyRulePreconfiguredWafConfigExclusionRequestUri',
    'SecurityPolicyRuleRateLimitOptions',
    'SecurityPolicyRuleRateLimitOptionsBanThreshold',
    'SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig',
    'SecurityPolicyRuleRateLimitOptionsExceedRedirectOptions',
    'SecurityPolicyRuleRateLimitOptionsRateLimitThreshold',
    'SecurityPolicyRuleRedirectOptions',
    'SecurityScanConfigAuthentication',
    'SecurityScanConfigAuthenticationCustomAccount',
    'SecurityScanConfigAuthenticationGoogleAccount',
    'SecurityScanConfigSchedule',
    'ServiceAttachmentConnectedEndpoint',
    'ServiceAttachmentConsumerAcceptList',
    'SnapshotIamBindingCondition',
    'SnapshotIamMemberCondition',
    'SnapshotSnapshotEncryptionKey',
    'SnapshotSourceDiskEncryptionKey',
    'SubnetworkIAMBindingCondition',
    'SubnetworkIAMMemberCondition',
    'SubnetworkLogConfig',
    'SubnetworkSecondaryIpRange',
    'URLMapDefaultRouteAction',
    'URLMapDefaultRouteActionCorsPolicy',
    'URLMapDefaultRouteActionFaultInjectionPolicy',
    'URLMapDefaultRouteActionFaultInjectionPolicyAbort',
    'URLMapDefaultRouteActionFaultInjectionPolicyDelay',
    'URLMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelay',
    'URLMapDefaultRouteActionRequestMirrorPolicy',
    'URLMapDefaultRouteActionRetryPolicy',
    'URLMapDefaultRouteActionRetryPolicyPerTryTimeout',
    'URLMapDefaultRouteActionTimeout',
    'URLMapDefaultRouteActionUrlRewrite',
    'URLMapDefaultRouteActionWeightedBackendService',
    'URLMapDefaultRouteActionWeightedBackendServiceHeaderAction',
    'URLMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd',
    'URLMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd',
    'URLMapDefaultUrlRedirect',
    'URLMapHeaderAction',
    'URLMapHeaderActionRequestHeadersToAdd',
    'URLMapHeaderActionResponseHeadersToAdd',
    'URLMapHostRule',
    'URLMapPathMatcher',
    'URLMapPathMatcherDefaultRouteAction',
    'URLMapPathMatcherDefaultRouteActionCorsPolicy',
    'URLMapPathMatcherDefaultRouteActionFaultInjectionPolicy',
    'URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyAbort',
    'URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelay',
    'URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayFixedDelay',
    'URLMapPathMatcherDefaultRouteActionRequestMirrorPolicy',
    'URLMapPathMatcherDefaultRouteActionRetryPolicy',
    'URLMapPathMatcherDefaultRouteActionRetryPolicyPerTryTimeout',
    'URLMapPathMatcherDefaultRouteActionTimeout',
    'URLMapPathMatcherDefaultRouteActionUrlRewrite',
    'URLMapPathMatcherDefaultRouteActionWeightedBackendService',
    'URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderAction',
    'URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd',
    'URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd',
    'URLMapPathMatcherDefaultUrlRedirect',
    'URLMapPathMatcherHeaderAction',
    'URLMapPathMatcherHeaderActionRequestHeadersToAdd',
    'URLMapPathMatcherHeaderActionResponseHeadersToAdd',
    'URLMapPathMatcherPathRule',
    'URLMapPathMatcherPathRuleRouteAction',
    'URLMapPathMatcherPathRuleRouteActionCorsPolicy',
    'URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicy',
    'URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbort',
    'URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelay',
    'URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelay',
    'URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicy',
    'URLMapPathMatcherPathRuleRouteActionRetryPolicy',
    'URLMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeout',
    'URLMapPathMatcherPathRuleRouteActionTimeout',
    'URLMapPathMatcherPathRuleRouteActionUrlRewrite',
    'URLMapPathMatcherPathRuleRouteActionWeightedBackendService',
    'URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderAction',
    'URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd',
    'URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd',
    'URLMapPathMatcherPathRuleUrlRedirect',
    'URLMapPathMatcherRouteRule',
    'URLMapPathMatcherRouteRuleHeaderAction',
    'URLMapPathMatcherRouteRuleHeaderActionRequestHeadersToAdd',
    'URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAdd',
    'URLMapPathMatcherRouteRuleMatchRule',
    'URLMapPathMatcherRouteRuleMatchRuleHeaderMatch',
    'URLMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatch',
    'URLMapPathMatcherRouteRuleMatchRuleMetadataFilter',
    'URLMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabel',
    'URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatch',
    'URLMapPathMatcherRouteRuleRouteAction',
    'URLMapPathMatcherRouteRuleRouteActionCorsPolicy',
    'URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicy',
    'URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbort',
    'URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelay',
    'URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelay',
    'URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicy',
    'URLMapPathMatcherRouteRuleRouteActionRetryPolicy',
    'URLMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeout',
    'URLMapPathMatcherRouteRuleRouteActionTimeout',
    'URLMapPathMatcherRouteRuleRouteActionUrlRewrite',
    'URLMapPathMatcherRouteRuleRouteActionWeightedBackendService',
    'URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderAction',
    'URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd',
    'URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd',
    'URLMapPathMatcherRouteRuleUrlRedirect',
    'URLMapTest',
    'GetAddressesAddressResult',
    'GetBackendBucketCdnPolicyResult',
    'GetBackendBucketCdnPolicyBypassCacheOnRequestHeaderResult',
    'GetBackendBucketCdnPolicyCacheKeyPolicyResult',
    'GetBackendBucketCdnPolicyNegativeCachingPolicyResult',
    'GetBackendServiceBackendResult',
    'GetBackendServiceCdnPolicyResult',
    'GetBackendServiceCdnPolicyCacheKeyPolicyResult',
    'GetBackendServiceCdnPolicyNegativeCachingPolicyResult',
    'GetBackendServiceCircuitBreakerResult',
    'GetBackendServiceCircuitBreakerConnectTimeoutResult',
    'GetBackendServiceConsistentHashResult',
    'GetBackendServiceConsistentHashHttpCookyResult',
    'GetBackendServiceConsistentHashHttpCookyTtlResult',
    'GetBackendServiceIapResult',
    'GetBackendServiceLocalityLbPolicyResult',
    'GetBackendServiceLocalityLbPolicyCustomPolicyResult',
    'GetBackendServiceLocalityLbPolicyPolicyResult',
    'GetBackendServiceLogConfigResult',
    'GetBackendServiceOutlierDetectionResult',
    'GetBackendServiceOutlierDetectionBaseEjectionTimeResult',
    'GetBackendServiceOutlierDetectionIntervalResult',
    'GetBackendServiceSecuritySettingResult',
    'GetDiskDiskEncryptionKeyResult',
    'GetDiskSourceImageEncryptionKeyResult',
    'GetDiskSourceSnapshotEncryptionKeyResult',
    'GetForwardingRuleServiceDirectoryRegistrationResult',
    'GetGlobalForwardingRuleMetadataFilterResult',
    'GetGlobalForwardingRuleMetadataFilterFilterLabelResult',
    'GetHcVpnGatewayVpnInterfaceResult',
    'GetHealthCheckGrpcHealthCheckResult',
    'GetHealthCheckHttp2HealthCheckResult',
    'GetHealthCheckHttpHealthCheckResult',
    'GetHealthCheckHttpsHealthCheckResult',
    'GetHealthCheckLogConfigResult',
    'GetHealthCheckSslHealthCheckResult',
    'GetHealthCheckTcpHealthCheckResult',
    'GetInstanceAdvancedMachineFeatureResult',
    'GetInstanceAttachedDiskResult',
    'GetInstanceBootDiskResult',
    'GetInstanceBootDiskInitializeParamResult',
    'GetInstanceConfidentialInstanceConfigResult',
    'GetInstanceGroupManagerAllInstancesConfigResult',
    'GetInstanceGroupManagerAutoHealingPolicyResult',
    'GetInstanceGroupManagerInstanceLifecyclePolicyResult',
    'GetInstanceGroupManagerNamedPortResult',
    'GetInstanceGroupManagerStatefulDiskResult',
    'GetInstanceGroupManagerStatefulExternalIpResult',
    'GetInstanceGroupManagerStatefulInternalIpResult',
    'GetInstanceGroupManagerStatusResult',
    'GetInstanceGroupManagerStatusAllInstancesConfigResult',
    'GetInstanceGroupManagerStatusStatefulResult',
    'GetInstanceGroupManagerStatusStatefulPerInstanceConfigResult',
    'GetInstanceGroupManagerStatusVersionTargetResult',
    'GetInstanceGroupManagerUpdatePolicyResult',
    'GetInstanceGroupManagerVersionResult',
    'GetInstanceGroupManagerVersionTargetSizeResult',
    'GetInstanceGroupNamedPortResult',
    'GetInstanceGuestAcceleratorResult',
    'GetInstanceNetworkInterfaceResult',
    'GetInstanceNetworkInterfaceAccessConfigResult',
    'GetInstanceNetworkInterfaceAliasIpRangeResult',
    'GetInstanceNetworkInterfaceIpv6AccessConfigResult',
    'GetInstanceNetworkPerformanceConfigResult',
    'GetInstanceReservationAffinityResult',
    'GetInstanceReservationAffinitySpecificReservationResult',
    'GetInstanceSchedulingResult',
    'GetInstanceSchedulingMaxRunDurationResult',
    'GetInstanceSchedulingNodeAffinityResult',
    'GetInstanceScratchDiskResult',
    'GetInstanceServiceAccountResult',
    'GetInstanceShieldedInstanceConfigResult',
    'GetInstanceTemplateAdvancedMachineFeatureResult',
    'GetInstanceTemplateConfidentialInstanceConfigResult',
    'GetInstanceTemplateDiskResult',
    'GetInstanceTemplateDiskDiskEncryptionKeyResult',
    'GetInstanceTemplateDiskSourceImageEncryptionKeyResult',
    'GetInstanceTemplateDiskSourceSnapshotEncryptionKeyResult',
    'GetInstanceTemplateGuestAcceleratorResult',
    'GetInstanceTemplateNetworkInterfaceResult',
    'GetInstanceTemplateNetworkInterfaceAccessConfigResult',
    'GetInstanceTemplateNetworkInterfaceAliasIpRangeResult',
    'GetInstanceTemplateNetworkInterfaceIpv6AccessConfigResult',
    'GetInstanceTemplateNetworkPerformanceConfigResult',
    'GetInstanceTemplateReservationAffinityResult',
    'GetInstanceTemplateReservationAffinitySpecificReservationResult',
    'GetInstanceTemplateSchedulingResult',
    'GetInstanceTemplateSchedulingMaxRunDurationResult',
    'GetInstanceTemplateSchedulingNodeAffinityResult',
    'GetInstanceTemplateServiceAccountResult',
    'GetInstanceTemplateShieldedInstanceConfigResult',
    'GetRegionInstanceGroupInstanceResult',
    'GetRegionInstanceGroupInstanceNamedPortResult',
    'GetRegionNetworkEndpointGroupAppEngineResult',
    'GetRegionNetworkEndpointGroupCloudFunctionResult',
    'GetRegionNetworkEndpointGroupCloudRunResult',
    'GetRegionNetworkEndpointGroupServerlessDeploymentResult',
    'GetResourcePolicyGroupPlacementPolicyResult',
    'GetResourcePolicyInstanceSchedulePolicyResult',
    'GetResourcePolicyInstanceSchedulePolicyVmStartScheduleResult',
    'GetResourcePolicyInstanceSchedulePolicyVmStopScheduleResult',
    'GetResourcePolicySnapshotSchedulePolicyResult',
    'GetResourcePolicySnapshotSchedulePolicyRetentionPolicyResult',
    'GetResourcePolicySnapshotSchedulePolicyScheduleResult',
    'GetResourcePolicySnapshotSchedulePolicyScheduleDailyScheduleResult',
    'GetResourcePolicySnapshotSchedulePolicyScheduleHourlyScheduleResult',
    'GetResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleResult',
    'GetResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleDayOfWeekResult',
    'GetResourcePolicySnapshotSchedulePolicySnapshotPropertyResult',
    'GetRouterBgpResult',
    'GetRouterBgpAdvertisedIpRangeResult',
    'GetRouterNatLogConfigResult',
    'GetRouterNatRuleResult',
    'GetRouterNatRuleActionResult',
    'GetRouterNatSubnetworkResult',
    'GetRouterStatusBestRouteResult',
    'GetRouterStatusBestRoutesForRouterResult',
    'GetSnapshotSnapshotEncryptionKeyResult',
    'GetSnapshotSourceDiskEncryptionKeyResult',
    'GetSubnetworkSecondaryIpRangeResult',
]

@pulumi.output_type
class AutoscalarAutoscalingPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxReplicas":
            suggest = "max_replicas"
        elif key == "minReplicas":
            suggest = "min_replicas"
        elif key == "cooldownPeriod":
            suggest = "cooldown_period"
        elif key == "cpuUtilization":
            suggest = "cpu_utilization"
        elif key == "loadBalancingUtilization":
            suggest = "load_balancing_utilization"
        elif key == "scaleDownControl":
            suggest = "scale_down_control"
        elif key == "scaleInControl":
            suggest = "scale_in_control"
        elif key == "scalingSchedules":
            suggest = "scaling_schedules"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AutoscalarAutoscalingPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AutoscalarAutoscalingPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AutoscalarAutoscalingPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 max_replicas: int,
                 min_replicas: int,
                 cooldown_period: Optional[int] = None,
                 cpu_utilization: Optional['outputs.AutoscalarAutoscalingPolicyCpuUtilization'] = None,
                 load_balancing_utilization: Optional['outputs.AutoscalarAutoscalingPolicyLoadBalancingUtilization'] = None,
                 metrics: Optional[Sequence['outputs.AutoscalarAutoscalingPolicyMetric']] = None,
                 mode: Optional[str] = None,
                 scale_down_control: Optional['outputs.AutoscalarAutoscalingPolicyScaleDownControl'] = None,
                 scale_in_control: Optional['outputs.AutoscalarAutoscalingPolicyScaleInControl'] = None,
                 scaling_schedules: Optional[Sequence['outputs.AutoscalarAutoscalingPolicyScalingSchedule']] = None):
        """
        :param 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 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 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 '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 'AutoscalarAutoscalingPolicyLoadBalancingUtilizationArgs' load_balancing_utilization: Configuration parameters of autoscaling based on a load balancer.
               Structure is documented below.
        :param Sequence['AutoscalarAutoscalingPolicyMetricArgs'] metrics: Configuration parameters of autoscaling based on a custom metric.
               Structure is documented below.
        :param str mode: Defines operating mode for this policy.
               Default value is `ON`.
               Possible values are `OFF`, `ONLY_UP`, and `ON`.
        :param '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 '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 Sequence['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) -> 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")

    @property
    @pulumi.getter(name="minReplicas")
    def min_replicas(self) -> 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")

    @property
    @pulumi.getter(name="cooldownPeriod")
    def cooldown_period(self) -> Optional[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")

    @property
    @pulumi.getter(name="cpuUtilization")
    def cpu_utilization(self) -> Optional['outputs.AutoscalarAutoscalingPolicyCpuUtilization']:
        """
        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")

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

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

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

    @property
    @pulumi.getter(name="scaleDownControl")
    def scale_down_control(self) -> Optional['outputs.AutoscalarAutoscalingPolicyScaleDownControl']:
        """
        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")

    @property
    @pulumi.getter(name="scaleInControl")
    def scale_in_control(self) -> Optional['outputs.AutoscalarAutoscalingPolicyScaleInControl']:
        """
        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")

    @property
    @pulumi.getter(name="scalingSchedules")
    def scaling_schedules(self) -> Optional[Sequence['outputs.AutoscalarAutoscalingPolicyScalingSchedule']]:
        """
        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")


@pulumi.output_type
class AutoscalarAutoscalingPolicyCpuUtilization(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "predictiveMethod":
            suggest = "predictive_method"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AutoscalarAutoscalingPolicyCpuUtilization. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AutoscalarAutoscalingPolicyCpuUtilization.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AutoscalarAutoscalingPolicyCpuUtilization.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 target: float,
                 predictive_method: Optional[str] = None):
        """
        :param float target: The target CPU utilization that the autoscaler should maintain.
               Must be a float value in the range (0, 1]. If not specified, the
               default is 0.6.
               If the CPU level is below the target utilization, the autoscaler
               scales down the number of instances until it reaches the minimum
               number of instances you specified or until the average CPU of
               your instances reaches the target utilization.
               If the average CPU is above the target utilization, the autoscaler
               scales up until it reaches the maximum number of instances you
               specified or until the average utilization reaches the target
               utilization.
        :param 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) -> float:
        """
        The target CPU utilization that the autoscaler should maintain.
        Must be a float value in the range (0, 1]. If not specified, the
        default is 0.6.
        If the CPU level is below the target utilization, the autoscaler
        scales down the number of instances until it reaches the minimum
        number of instances you specified or until the average CPU of
        your instances reaches the target utilization.
        If the average CPU is above the target utilization, the autoscaler
        scales up until it reaches the maximum number of instances you
        specified or until the average utilization reaches the target
        utilization.
        """
        return pulumi.get(self, "target")

    @property
    @pulumi.getter(name="predictiveMethod")
    def predictive_method(self) -> Optional[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")


@pulumi.output_type
class AutoscalarAutoscalingPolicyLoadBalancingUtilization(dict):
    def __init__(__self__, *,
                 target: float):
        """
        :param 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) -> 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")


@pulumi.output_type
class AutoscalarAutoscalingPolicyMetric(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "singleInstanceAssignment":
            suggest = "single_instance_assignment"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AutoscalarAutoscalingPolicyMetric. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AutoscalarAutoscalingPolicyMetric.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AutoscalarAutoscalingPolicyMetric.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 filter: Optional[str] = None,
                 single_instance_assignment: Optional[float] = None,
                 target: Optional[float] = None,
                 type: Optional[str] = None):
        """
        :param str name: The identifier (type) of the Stackdriver Monitoring metric.
               The metric cannot have negative values.
               The metric must have a value type of INT64 or DOUBLE.
        :param 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 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 float target: The target value of the metric that autoscaler should
               maintain. This must be a positive value. A utilization
               metric scales number of virtual machines handling requests
               to increase or decrease proportionally to the metric.
               For example, a good metric to use as a utilizationTarget is
               www.googleapis.com/compute/instance/network/received_bytes_count.
               The autoscaler will work to keep this value constant for each
               of the instances.
        :param 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) -> str:
        """
        The identifier (type) of the Stackdriver Monitoring metric.
        The metric cannot have negative values.
        The metric must have a value type of INT64 or DOUBLE.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def filter(self) -> Optional[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")

    @property
    @pulumi.getter(name="singleInstanceAssignment")
    def single_instance_assignment(self) -> Optional[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")

    @property
    @pulumi.getter
    def target(self) -> Optional[float]:
        """
        The target value of the metric that autoscaler should
        maintain. This must be a positive value. A utilization
        metric scales number of virtual machines handling requests
        to increase or decrease proportionally to the metric.
        For example, a good metric to use as a utilizationTarget is
        www.googleapis.com/compute/instance/network/received_bytes_count.
        The autoscaler will work to keep this value constant for each
        of the instances.
        """
        return pulumi.get(self, "target")

    @property
    @pulumi.getter
    def type(self) -> Optional[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")


@pulumi.output_type
class AutoscalarAutoscalingPolicyScaleDownControl(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxScaledDownReplicas":
            suggest = "max_scaled_down_replicas"
        elif key == "timeWindowSec":
            suggest = "time_window_sec"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AutoscalarAutoscalingPolicyScaleDownControl. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AutoscalarAutoscalingPolicyScaleDownControl.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AutoscalarAutoscalingPolicyScaleDownControl.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 max_scaled_down_replicas: Optional['outputs.AutoscalarAutoscalingPolicyScaleDownControlMaxScaledDownReplicas'] = None,
                 time_window_sec: Optional[int] = None):
        """
        :param 'AutoscalarAutoscalingPolicyScaleDownControlMaxScaledDownReplicasArgs' max_scaled_down_replicas: A nested object resource
               Structure is documented below.
        :param 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['outputs.AutoscalarAutoscalingPolicyScaleDownControlMaxScaledDownReplicas']:
        """
        A nested object resource
        Structure is documented below.
        """
        return pulumi.get(self, "max_scaled_down_replicas")

    @property
    @pulumi.getter(name="timeWindowSec")
    def time_window_sec(self) -> Optional[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")


@pulumi.output_type
class AutoscalarAutoscalingPolicyScaleDownControlMaxScaledDownReplicas(dict):
    def __init__(__self__, *,
                 fixed: Optional[int] = None,
                 percent: Optional[int] = None):
        """
        :param int fixed: Specifies a fixed number of VM instances. This must be a positive
               integer.
        :param 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[int]:
        """
        Specifies a fixed number of VM instances. This must be a positive
        integer.
        """
        return pulumi.get(self, "fixed")

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


@pulumi.output_type
class AutoscalarAutoscalingPolicyScaleInControl(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxScaledInReplicas":
            suggest = "max_scaled_in_replicas"
        elif key == "timeWindowSec":
            suggest = "time_window_sec"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AutoscalarAutoscalingPolicyScaleInControl. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AutoscalarAutoscalingPolicyScaleInControl.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AutoscalarAutoscalingPolicyScaleInControl.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 max_scaled_in_replicas: Optional['outputs.AutoscalarAutoscalingPolicyScaleInControlMaxScaledInReplicas'] = None,
                 time_window_sec: Optional[int] = None):
        """
        :param 'AutoscalarAutoscalingPolicyScaleInControlMaxScaledInReplicasArgs' max_scaled_in_replicas: A nested object resource
               Structure is documented below.
        :param 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['outputs.AutoscalarAutoscalingPolicyScaleInControlMaxScaledInReplicas']:
        """
        A nested object resource
        Structure is documented below.
        """
        return pulumi.get(self, "max_scaled_in_replicas")

    @property
    @pulumi.getter(name="timeWindowSec")
    def time_window_sec(self) -> Optional[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")


@pulumi.output_type
class AutoscalarAutoscalingPolicyScaleInControlMaxScaledInReplicas(dict):
    def __init__(__self__, *,
                 fixed: Optional[int] = None,
                 percent: Optional[int] = None):
        """
        :param int fixed: Specifies a fixed number of VM instances. This must be a positive
               integer.
        :param 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[int]:
        """
        Specifies a fixed number of VM instances. This must be a positive
        integer.
        """
        return pulumi.get(self, "fixed")

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


@pulumi.output_type
class AutoscalarAutoscalingPolicyScalingSchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "durationSec":
            suggest = "duration_sec"
        elif key == "minRequiredReplicas":
            suggest = "min_required_replicas"
        elif key == "timeZone":
            suggest = "time_zone"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AutoscalarAutoscalingPolicyScalingSchedule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AutoscalarAutoscalingPolicyScalingSchedule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AutoscalarAutoscalingPolicyScalingSchedule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 duration_sec: int,
                 min_required_replicas: int,
                 name: str,
                 schedule: str,
                 description: Optional[str] = None,
                 disabled: Optional[bool] = None,
                 time_zone: Optional[str] = None):
        """
        :param 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 int min_required_replicas: Minimum number of VM instances that autoscaler will recommend in time intervals starting according to schedule.
        :param str name: The identifier for this object. Format specified above.
        :param 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 str description: An optional description of this resource.
        :param 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 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) -> 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")

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

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

    @property
    @pulumi.getter
    def schedule(self) -> 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")

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

    @property
    @pulumi.getter
    def disabled(self) -> Optional[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")

    @property
    @pulumi.getter(name="timeZone")
    def time_zone(self) -> Optional[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")


@pulumi.output_type
class AutoscalerAutoscalingPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxReplicas":
            suggest = "max_replicas"
        elif key == "minReplicas":
            suggest = "min_replicas"
        elif key == "cooldownPeriod":
            suggest = "cooldown_period"
        elif key == "cpuUtilization":
            suggest = "cpu_utilization"
        elif key == "loadBalancingUtilization":
            suggest = "load_balancing_utilization"
        elif key == "scaleDownControl":
            suggest = "scale_down_control"
        elif key == "scaleInControl":
            suggest = "scale_in_control"
        elif key == "scalingSchedules":
            suggest = "scaling_schedules"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AutoscalerAutoscalingPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AutoscalerAutoscalingPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AutoscalerAutoscalingPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 max_replicas: int,
                 min_replicas: int,
                 cooldown_period: Optional[int] = None,
                 cpu_utilization: Optional['outputs.AutoscalerAutoscalingPolicyCpuUtilization'] = None,
                 load_balancing_utilization: Optional['outputs.AutoscalerAutoscalingPolicyLoadBalancingUtilization'] = None,
                 metrics: Optional[Sequence['outputs.AutoscalerAutoscalingPolicyMetric']] = None,
                 mode: Optional[str] = None,
                 scale_down_control: Optional['outputs.AutoscalerAutoscalingPolicyScaleDownControl'] = None,
                 scale_in_control: Optional['outputs.AutoscalerAutoscalingPolicyScaleInControl'] = None,
                 scaling_schedules: Optional[Sequence['outputs.AutoscalerAutoscalingPolicyScalingSchedule']] = None):
        """
        :param 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 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 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 '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 'AutoscalerAutoscalingPolicyLoadBalancingUtilizationArgs' load_balancing_utilization: Configuration parameters of autoscaling based on a load balancer.
               Structure is documented below.
        :param Sequence['AutoscalerAutoscalingPolicyMetricArgs'] metrics: Configuration parameters of autoscaling based on a custom metric.
               Structure is documented below.
        :param str mode: Defines operating mode for this policy.
               Default value is `ON`.
               Possible values are `OFF`, `ONLY_UP`, and `ON`.
        :param '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 '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 Sequence['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) -> 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")

    @property
    @pulumi.getter(name="minReplicas")
    def min_replicas(self) -> 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")

    @property
    @pulumi.getter(name="cooldownPeriod")
    def cooldown_period(self) -> Optional[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")

    @property
    @pulumi.getter(name="cpuUtilization")
    def cpu_utilization(self) -> Optional['outputs.AutoscalerAutoscalingPolicyCpuUtilization']:
        """
        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")

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

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

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

    @property
    @pulumi.getter(name="scaleDownControl")
    def scale_down_control(self) -> Optional['outputs.AutoscalerAutoscalingPolicyScaleDownControl']:
        """
        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")

    @property
    @pulumi.getter(name="scaleInControl")
    def scale_in_control(self) -> Optional['outputs.AutoscalerAutoscalingPolicyScaleInControl']:
        """
        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")

    @property
    @pulumi.getter(name="scalingSchedules")
    def scaling_schedules(self) -> Optional[Sequence['outputs.AutoscalerAutoscalingPolicyScalingSchedule']]:
        """
        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")


@pulumi.output_type
class AutoscalerAutoscalingPolicyCpuUtilization(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "predictiveMethod":
            suggest = "predictive_method"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AutoscalerAutoscalingPolicyCpuUtilization. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AutoscalerAutoscalingPolicyCpuUtilization.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AutoscalerAutoscalingPolicyCpuUtilization.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 target: float,
                 predictive_method: Optional[str] = None):
        """
        :param float target: The target CPU utilization that the autoscaler should maintain.
               Must be a float value in the range (0, 1]. If not specified, the
               default is 0.6.
               If the CPU level is below the target utilization, the autoscaler
               scales down the number of instances until it reaches the minimum
               number of instances you specified or until the average CPU of
               your instances reaches the target utilization.
               If the average CPU is above the target utilization, the autoscaler
               scales up until it reaches the maximum number of instances you
               specified or until the average utilization reaches the target
               utilization.
        :param 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) -> float:
        """
        The target CPU utilization that the autoscaler should maintain.
        Must be a float value in the range (0, 1]. If not specified, the
        default is 0.6.
        If the CPU level is below the target utilization, the autoscaler
        scales down the number of instances until it reaches the minimum
        number of instances you specified or until the average CPU of
        your instances reaches the target utilization.
        If the average CPU is above the target utilization, the autoscaler
        scales up until it reaches the maximum number of instances you
        specified or until the average utilization reaches the target
        utilization.
        """
        return pulumi.get(self, "target")

    @property
    @pulumi.getter(name="predictiveMethod")
    def predictive_method(self) -> Optional[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")


@pulumi.output_type
class AutoscalerAutoscalingPolicyLoadBalancingUtilization(dict):
    def __init__(__self__, *,
                 target: float):
        """
        :param 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) -> 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")


@pulumi.output_type
class AutoscalerAutoscalingPolicyMetric(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "singleInstanceAssignment":
            suggest = "single_instance_assignment"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AutoscalerAutoscalingPolicyMetric. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AutoscalerAutoscalingPolicyMetric.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AutoscalerAutoscalingPolicyMetric.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 filter: Optional[str] = None,
                 single_instance_assignment: Optional[float] = None,
                 target: Optional[float] = None,
                 type: Optional[str] = None):
        """
        :param str name: The identifier (type) of the Stackdriver Monitoring metric.
               The metric cannot have negative values.
               The metric must have a value type of INT64 or DOUBLE.
        :param 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 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 float target: The target value of the metric that autoscaler should
               maintain. This must be a positive value. A utilization
               metric scales number of virtual machines handling requests
               to increase or decrease proportionally to the metric.
               For example, a good metric to use as a utilizationTarget is
               www.googleapis.com/compute/instance/network/received_bytes_count.
               The autoscaler will work to keep this value constant for each
               of the instances.
        :param 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) -> str:
        """
        The identifier (type) of the Stackdriver Monitoring metric.
        The metric cannot have negative values.
        The metric must have a value type of INT64 or DOUBLE.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def filter(self) -> Optional[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")

    @property
    @pulumi.getter(name="singleInstanceAssignment")
    def single_instance_assignment(self) -> Optional[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")

    @property
    @pulumi.getter
    def target(self) -> Optional[float]:
        """
        The target value of the metric that autoscaler should
        maintain. This must be a positive value. A utilization
        metric scales number of virtual machines handling requests
        to increase or decrease proportionally to the metric.
        For example, a good metric to use as a utilizationTarget is
        www.googleapis.com/compute/instance/network/received_bytes_count.
        The autoscaler will work to keep this value constant for each
        of the instances.
        """
        return pulumi.get(self, "target")

    @property
    @pulumi.getter
    def type(self) -> Optional[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")


@pulumi.output_type
class AutoscalerAutoscalingPolicyScaleDownControl(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxScaledDownReplicas":
            suggest = "max_scaled_down_replicas"
        elif key == "timeWindowSec":
            suggest = "time_window_sec"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AutoscalerAutoscalingPolicyScaleDownControl. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AutoscalerAutoscalingPolicyScaleDownControl.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AutoscalerAutoscalingPolicyScaleDownControl.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 max_scaled_down_replicas: Optional['outputs.AutoscalerAutoscalingPolicyScaleDownControlMaxScaledDownReplicas'] = None,
                 time_window_sec: Optional[int] = None):
        """
        :param 'AutoscalerAutoscalingPolicyScaleDownControlMaxScaledDownReplicasArgs' max_scaled_down_replicas: A nested object resource
               Structure is documented below.
        :param 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['outputs.AutoscalerAutoscalingPolicyScaleDownControlMaxScaledDownReplicas']:
        """
        A nested object resource
        Structure is documented below.
        """
        return pulumi.get(self, "max_scaled_down_replicas")

    @property
    @pulumi.getter(name="timeWindowSec")
    def time_window_sec(self) -> Optional[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")


@pulumi.output_type
class AutoscalerAutoscalingPolicyScaleDownControlMaxScaledDownReplicas(dict):
    def __init__(__self__, *,
                 fixed: Optional[int] = None,
                 percent: Optional[int] = None):
        """
        :param int fixed: Specifies a fixed number of VM instances. This must be a positive
               integer.
        :param 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[int]:
        """
        Specifies a fixed number of VM instances. This must be a positive
        integer.
        """
        return pulumi.get(self, "fixed")

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


@pulumi.output_type
class AutoscalerAutoscalingPolicyScaleInControl(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxScaledInReplicas":
            suggest = "max_scaled_in_replicas"
        elif key == "timeWindowSec":
            suggest = "time_window_sec"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AutoscalerAutoscalingPolicyScaleInControl. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AutoscalerAutoscalingPolicyScaleInControl.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AutoscalerAutoscalingPolicyScaleInControl.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 max_scaled_in_replicas: Optional['outputs.AutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicas'] = None,
                 time_window_sec: Optional[int] = None):
        """
        :param 'AutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicasArgs' max_scaled_in_replicas: A nested object resource
               Structure is documented below.
        :param 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['outputs.AutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicas']:
        """
        A nested object resource
        Structure is documented below.
        """
        return pulumi.get(self, "max_scaled_in_replicas")

    @property
    @pulumi.getter(name="timeWindowSec")
    def time_window_sec(self) -> Optional[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")


@pulumi.output_type
class AutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicas(dict):
    def __init__(__self__, *,
                 fixed: Optional[int] = None,
                 percent: Optional[int] = None):
        """
        :param int fixed: Specifies a fixed number of VM instances. This must be a positive
               integer.
        :param 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[int]:
        """
        Specifies a fixed number of VM instances. This must be a positive
        integer.
        """
        return pulumi.get(self, "fixed")

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


@pulumi.output_type
class AutoscalerAutoscalingPolicyScalingSchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "durationSec":
            suggest = "duration_sec"
        elif key == "minRequiredReplicas":
            suggest = "min_required_replicas"
        elif key == "timeZone":
            suggest = "time_zone"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AutoscalerAutoscalingPolicyScalingSchedule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AutoscalerAutoscalingPolicyScalingSchedule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AutoscalerAutoscalingPolicyScalingSchedule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 duration_sec: int,
                 min_required_replicas: int,
                 name: str,
                 schedule: str,
                 description: Optional[str] = None,
                 disabled: Optional[bool] = None,
                 time_zone: Optional[str] = None):
        """
        :param 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 int min_required_replicas: Minimum number of VM instances that autoscaler will recommend in time intervals starting according to schedule.
        :param str name: The identifier for this object. Format specified above.
        :param 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 str description: An optional description of this resource.
        :param 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 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) -> 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")

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

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

    @property
    @pulumi.getter
    def schedule(self) -> 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")

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

    @property
    @pulumi.getter
    def disabled(self) -> Optional[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")

    @property
    @pulumi.getter(name="timeZone")
    def time_zone(self) -> Optional[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")


@pulumi.output_type
class BackendBucketCdnPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bypassCacheOnRequestHeaders":
            suggest = "bypass_cache_on_request_headers"
        elif key == "cacheKeyPolicy":
            suggest = "cache_key_policy"
        elif key == "cacheMode":
            suggest = "cache_mode"
        elif key == "clientTtl":
            suggest = "client_ttl"
        elif key == "defaultTtl":
            suggest = "default_ttl"
        elif key == "maxTtl":
            suggest = "max_ttl"
        elif key == "negativeCaching":
            suggest = "negative_caching"
        elif key == "negativeCachingPolicies":
            suggest = "negative_caching_policies"
        elif key == "requestCoalescing":
            suggest = "request_coalescing"
        elif key == "serveWhileStale":
            suggest = "serve_while_stale"
        elif key == "signedUrlCacheMaxAgeSec":
            suggest = "signed_url_cache_max_age_sec"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in BackendBucketCdnPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        BackendBucketCdnPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        BackendBucketCdnPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 bypass_cache_on_request_headers: Optional[Sequence['outputs.BackendBucketCdnPolicyBypassCacheOnRequestHeader']] = None,
                 cache_key_policy: Optional['outputs.BackendBucketCdnPolicyCacheKeyPolicy'] = None,
                 cache_mode: Optional[str] = None,
                 client_ttl: Optional[int] = None,
                 default_ttl: Optional[int] = None,
                 max_ttl: Optional[int] = None,
                 negative_caching: Optional[bool] = None,
                 negative_caching_policies: Optional[Sequence['outputs.BackendBucketCdnPolicyNegativeCachingPolicy']] = None,
                 request_coalescing: Optional[bool] = None,
                 serve_while_stale: Optional[int] = None,
                 signed_url_cache_max_age_sec: Optional[int] = None):
        """
        :param Sequence['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 'BackendBucketCdnPolicyCacheKeyPolicyArgs' cache_key_policy: The CacheKeyPolicy for this CdnPolicy.
               Structure is documented below.
        :param 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 int client_ttl: Specifies the maximum allowed TTL for cached content served by this origin.
        :param 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 int max_ttl: Specifies the maximum allowed TTL for cached content served by this origin.
        :param 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 Sequence['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 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 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 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[Sequence['outputs.BackendBucketCdnPolicyBypassCacheOnRequestHeader']]:
        """
        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")

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

    @property
    @pulumi.getter(name="cacheMode")
    def cache_mode(self) -> Optional[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")

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

    @property
    @pulumi.getter(name="defaultTtl")
    def default_ttl(self) -> Optional[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")

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

    @property
    @pulumi.getter(name="negativeCaching")
    def negative_caching(self) -> Optional[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")

    @property
    @pulumi.getter(name="negativeCachingPolicies")
    def negative_caching_policies(self) -> Optional[Sequence['outputs.BackendBucketCdnPolicyNegativeCachingPolicy']]:
        """
        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")

    @property
    @pulumi.getter(name="requestCoalescing")
    def request_coalescing(self) -> Optional[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")

    @property
    @pulumi.getter(name="serveWhileStale")
    def serve_while_stale(self) -> Optional[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")

    @property
    @pulumi.getter(name="signedUrlCacheMaxAgeSec")
    def signed_url_cache_max_age_sec(self) -> Optional[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")


@pulumi.output_type
class BackendBucketCdnPolicyBypassCacheOnRequestHeader(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in BackendBucketCdnPolicyBypassCacheOnRequestHeader. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        BackendBucketCdnPolicyBypassCacheOnRequestHeader.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        BackendBucketCdnPolicyBypassCacheOnRequestHeader.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: Optional[str] = None):
        """
        :param 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[str]:
        """
        The header field name to match on when bypassing cache. Values are case-insensitive.
        """
        return pulumi.get(self, "header_name")


@pulumi.output_type
class BackendBucketCdnPolicyCacheKeyPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "includeHttpHeaders":
            suggest = "include_http_headers"
        elif key == "queryStringWhitelists":
            suggest = "query_string_whitelists"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in BackendBucketCdnPolicyCacheKeyPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        BackendBucketCdnPolicyCacheKeyPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        BackendBucketCdnPolicyCacheKeyPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 include_http_headers: Optional[Sequence[str]] = None,
                 query_string_whitelists: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] include_http_headers: Allows HTTP request headers (by name) to be used in the
               cache key.
        :param Sequence[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[Sequence[str]]:
        """
        Allows HTTP request headers (by name) to be used in the
        cache key.
        """
        return pulumi.get(self, "include_http_headers")

    @property
    @pulumi.getter(name="queryStringWhitelists")
    def query_string_whitelists(self) -> Optional[Sequence[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")


@pulumi.output_type
class BackendBucketCdnPolicyNegativeCachingPolicy(dict):
    def __init__(__self__, *,
                 code: Optional[int] = None,
                 ttl: Optional[int] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter
    def ttl(self) -> Optional[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")


@pulumi.output_type
class BackendBucketIamBindingCondition(dict):
    def __init__(__self__, *,
                 expression: str,
                 title: str,
                 description: Optional[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) -> str:
        return pulumi.get(self, "expression")

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

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


@pulumi.output_type
class BackendBucketIamMemberCondition(dict):
    def __init__(__self__, *,
                 expression: str,
                 title: str,
                 description: Optional[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) -> str:
        return pulumi.get(self, "expression")

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

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


@pulumi.output_type
class BackendServiceBackend(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "balancingMode":
            suggest = "balancing_mode"
        elif key == "capacityScaler":
            suggest = "capacity_scaler"
        elif key == "maxConnections":
            suggest = "max_connections"
        elif key == "maxConnectionsPerEndpoint":
            suggest = "max_connections_per_endpoint"
        elif key == "maxConnectionsPerInstance":
            suggest = "max_connections_per_instance"
        elif key == "maxRate":
            suggest = "max_rate"
        elif key == "maxRatePerEndpoint":
            suggest = "max_rate_per_endpoint"
        elif key == "maxRatePerInstance":
            suggest = "max_rate_per_instance"
        elif key == "maxUtilization":
            suggest = "max_utilization"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in BackendServiceBackend. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        BackendServiceBackend.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        BackendServiceBackend.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 group: str,
                 balancing_mode: Optional[str] = None,
                 capacity_scaler: Optional[float] = None,
                 description: Optional[str] = None,
                 max_connections: Optional[int] = None,
                 max_connections_per_endpoint: Optional[int] = None,
                 max_connections_per_instance: Optional[int] = None,
                 max_rate: Optional[int] = None,
                 max_rate_per_endpoint: Optional[float] = None,
                 max_rate_per_instance: Optional[float] = None,
                 max_utilization: Optional[float] = None):
        """
        :param 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 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 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 str description: An optional description of this resource.
               Provide this property when you create the resource.
        :param int max_connections: The max number of simultaneous connections for the group. Can
               be used with either CONNECTION or UTILIZATION balancing modes.
               For CONNECTION mode, either maxConnections or one
               of maxConnectionsPerInstance or maxConnectionsPerEndpoint,
               as appropriate for group type, must be set.
        :param 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 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 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 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 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 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) -> 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")

    @property
    @pulumi.getter(name="balancingMode")
    def balancing_mode(self) -> Optional[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")

    @property
    @pulumi.getter(name="capacityScaler")
    def capacity_scaler(self) -> Optional[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")

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

    @property
    @pulumi.getter(name="maxConnections")
    def max_connections(self) -> Optional[int]:
        """
        The max number of simultaneous connections for the group. Can
        be used with either CONNECTION or UTILIZATION balancing modes.
        For CONNECTION mode, either maxConnections or one
        of maxConnectionsPerInstance or maxConnectionsPerEndpoint,
        as appropriate for group type, must be set.
        """
        return pulumi.get(self, "max_connections")

    @property
    @pulumi.getter(name="maxConnectionsPerEndpoint")
    def max_connections_per_endpoint(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxConnectionsPerInstance")
    def max_connections_per_instance(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxRate")
    def max_rate(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxRatePerEndpoint")
    def max_rate_per_endpoint(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxRatePerInstance")
    def max_rate_per_instance(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxUtilization")
    def max_utilization(self) -> Optional[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")


@pulumi.output_type
class BackendServiceCdnPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cacheKeyPolicy":
            suggest = "cache_key_policy"
        elif key == "cacheMode":
            suggest = "cache_mode"
        elif key == "clientTtl":
            suggest = "client_ttl"
        elif key == "defaultTtl":
            suggest = "default_ttl"
        elif key == "maxTtl":
            suggest = "max_ttl"
        elif key == "negativeCaching":
            suggest = "negative_caching"
        elif key == "negativeCachingPolicies":
            suggest = "negative_caching_policies"
        elif key == "serveWhileStale":
            suggest = "serve_while_stale"
        elif key == "signedUrlCacheMaxAgeSec":
            suggest = "signed_url_cache_max_age_sec"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in BackendServiceCdnPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        BackendServiceCdnPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        BackendServiceCdnPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cache_key_policy: Optional['outputs.BackendServiceCdnPolicyCacheKeyPolicy'] = None,
                 cache_mode: Optional[str] = None,
                 client_ttl: Optional[int] = None,
                 default_ttl: Optional[int] = None,
                 max_ttl: Optional[int] = None,
                 negative_caching: Optional[bool] = None,
                 negative_caching_policies: Optional[Sequence['outputs.BackendServiceCdnPolicyNegativeCachingPolicy']] = None,
                 serve_while_stale: Optional[int] = None,
                 signed_url_cache_max_age_sec: Optional[int] = None):
        """
        :param 'BackendServiceCdnPolicyCacheKeyPolicyArgs' cache_key_policy: The CacheKeyPolicy for this CdnPolicy.
               Structure is documented below.
        :param 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 int client_ttl: Specifies the maximum allowed TTL for cached content served by this origin.
        :param 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 int max_ttl: Specifies the maximum allowed TTL for cached content served by this origin.
        :param 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 Sequence['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 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 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['outputs.BackendServiceCdnPolicyCacheKeyPolicy']:
        """
        The CacheKeyPolicy for this CdnPolicy.
        Structure is documented below.
        """
        return pulumi.get(self, "cache_key_policy")

    @property
    @pulumi.getter(name="cacheMode")
    def cache_mode(self) -> Optional[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")

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

    @property
    @pulumi.getter(name="defaultTtl")
    def default_ttl(self) -> Optional[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")

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

    @property
    @pulumi.getter(name="negativeCaching")
    def negative_caching(self) -> Optional[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")

    @property
    @pulumi.getter(name="negativeCachingPolicies")
    def negative_caching_policies(self) -> Optional[Sequence['outputs.BackendServiceCdnPolicyNegativeCachingPolicy']]:
        """
        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")

    @property
    @pulumi.getter(name="serveWhileStale")
    def serve_while_stale(self) -> Optional[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")

    @property
    @pulumi.getter(name="signedUrlCacheMaxAgeSec")
    def signed_url_cache_max_age_sec(self) -> Optional[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")


@pulumi.output_type
class BackendServiceCdnPolicyCacheKeyPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "includeHost":
            suggest = "include_host"
        elif key == "includeHttpHeaders":
            suggest = "include_http_headers"
        elif key == "includeNamedCookies":
            suggest = "include_named_cookies"
        elif key == "includeProtocol":
            suggest = "include_protocol"
        elif key == "includeQueryString":
            suggest = "include_query_string"
        elif key == "queryStringBlacklists":
            suggest = "query_string_blacklists"
        elif key == "queryStringWhitelists":
            suggest = "query_string_whitelists"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in BackendServiceCdnPolicyCacheKeyPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        BackendServiceCdnPolicyCacheKeyPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        BackendServiceCdnPolicyCacheKeyPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 include_host: Optional[bool] = None,
                 include_http_headers: Optional[Sequence[str]] = None,
                 include_named_cookies: Optional[Sequence[str]] = None,
                 include_protocol: Optional[bool] = None,
                 include_query_string: Optional[bool] = None,
                 query_string_blacklists: Optional[Sequence[str]] = None,
                 query_string_whitelists: Optional[Sequence[str]] = None):
        """
        :param bool include_host: If true requests to different hosts will be cached separately.
        :param Sequence[str] include_http_headers: Allows HTTP request headers (by name) to be used in the
               cache key.
        :param Sequence[str] include_named_cookies: Names of cookies to include in cache keys.
        :param bool include_protocol: If true, http and https requests will be cached separately.
        :param 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 Sequence[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 Sequence[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_http_headers is not None:
            pulumi.set(__self__, "include_http_headers", include_http_headers)
        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[bool]:
        """
        If true requests to different hosts will be cached separately.
        """
        return pulumi.get(self, "include_host")

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

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

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

    @property
    @pulumi.getter(name="includeQueryString")
    def include_query_string(self) -> Optional[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")

    @property
    @pulumi.getter(name="queryStringBlacklists")
    def query_string_blacklists(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter(name="queryStringWhitelists")
    def query_string_whitelists(self) -> Optional[Sequence[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")


@pulumi.output_type
class BackendServiceCdnPolicyNegativeCachingPolicy(dict):
    def __init__(__self__, *,
                 code: Optional[int] = None,
                 ttl: Optional[int] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter
    def ttl(self) -> Optional[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")


@pulumi.output_type
class BackendServiceCircuitBreakers(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "connectTimeout":
            suggest = "connect_timeout"
        elif key == "maxConnections":
            suggest = "max_connections"
        elif key == "maxPendingRequests":
            suggest = "max_pending_requests"
        elif key == "maxRequests":
            suggest = "max_requests"
        elif key == "maxRequestsPerConnection":
            suggest = "max_requests_per_connection"
        elif key == "maxRetries":
            suggest = "max_retries"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in BackendServiceCircuitBreakers. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        BackendServiceCircuitBreakers.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        BackendServiceCircuitBreakers.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 connect_timeout: Optional['outputs.BackendServiceCircuitBreakersConnectTimeout'] = None,
                 max_connections: Optional[int] = None,
                 max_pending_requests: Optional[int] = None,
                 max_requests: Optional[int] = None,
                 max_requests_per_connection: Optional[int] = None,
                 max_retries: Optional[int] = None):
        """
        :param 'BackendServiceCircuitBreakersConnectTimeoutArgs' connect_timeout: The timeout for new network connections to hosts.
               Structure is documented below.
        :param int max_connections: The maximum number of connections to the backend cluster.
               Defaults to 1024.
        :param int max_pending_requests: The maximum number of pending requests to the backend cluster.
               Defaults to 1024.
        :param int max_requests: The maximum number of parallel requests to the backend cluster.
               Defaults to 1024.
        :param 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 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['outputs.BackendServiceCircuitBreakersConnectTimeout']:
        """
        The timeout for new network connections to hosts.
        Structure is documented below.
        """
        return pulumi.get(self, "connect_timeout")

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

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

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

    @property
    @pulumi.getter(name="maxRequestsPerConnection")
    def max_requests_per_connection(self) -> Optional[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")

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


@pulumi.output_type
class BackendServiceCircuitBreakersConnectTimeout(dict):
    def __init__(__self__, *,
                 seconds: int,
                 nanos: Optional[int] = None):
        """
        :param int seconds: Span of time at a resolution of a second.
               Must be from 0 to 315,576,000,000 inclusive.
        :param 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) -> 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")

    @property
    @pulumi.getter
    def nanos(self) -> Optional[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")


@pulumi.output_type
class BackendServiceConsistentHash(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "httpCookie":
            suggest = "http_cookie"
        elif key == "httpHeaderName":
            suggest = "http_header_name"
        elif key == "minimumRingSize":
            suggest = "minimum_ring_size"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in BackendServiceConsistentHash. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        BackendServiceConsistentHash.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        BackendServiceConsistentHash.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 http_cookie: Optional['outputs.BackendServiceConsistentHashHttpCookie'] = None,
                 http_header_name: Optional[str] = None,
                 minimum_ring_size: Optional[int] = None):
        """
        :param '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 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 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['outputs.BackendServiceConsistentHashHttpCookie']:
        """
        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")

    @property
    @pulumi.getter(name="httpHeaderName")
    def http_header_name(self) -> Optional[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")

    @property
    @pulumi.getter(name="minimumRingSize")
    def minimum_ring_size(self) -> Optional[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")


@pulumi.output_type
class BackendServiceConsistentHashHttpCookie(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None,
                 path: Optional[str] = None,
                 ttl: Optional['outputs.BackendServiceConsistentHashHttpCookieTtl'] = None):
        """
        :param str name: Name of the cookie.
        :param str path: Path to set for the cookie.
        :param 'BackendServiceConsistentHashHttpCookieTtlArgs' ttl: Lifetime of the cookie.
               Structure is documented below.
        """
        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[str]:
        """
        Name of the cookie.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def ttl(self) -> Optional['outputs.BackendServiceConsistentHashHttpCookieTtl']:
        """
        Lifetime of the cookie.
        Structure is documented below.
        """
        return pulumi.get(self, "ttl")


@pulumi.output_type
class BackendServiceConsistentHashHttpCookieTtl(dict):
    def __init__(__self__, *,
                 seconds: int,
                 nanos: Optional[int] = None):
        """
        :param int seconds: Span of time at a resolution of a second.
               Must be from 0 to 315,576,000,000 inclusive.
        :param 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) -> 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")

    @property
    @pulumi.getter
    def nanos(self) -> Optional[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")


@pulumi.output_type
class BackendServiceIamBindingCondition(dict):
    def __init__(__self__, *,
                 expression: str,
                 title: str,
                 description: Optional[str] = None):
        """
        :param str expression: Textual representation of an expression in Common Expression Language syntax.
        :param str title: A title for the expression, i.e. a short string describing its purpose.
        :param 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) -> str:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[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")


@pulumi.output_type
class BackendServiceIamMemberCondition(dict):
    def __init__(__self__, *,
                 expression: str,
                 title: str,
                 description: Optional[str] = None):
        """
        :param str expression: Textual representation of an expression in Common Expression Language syntax.
        :param str title: A title for the expression, i.e. a short string describing its purpose.
        :param 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) -> str:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[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")


@pulumi.output_type
class BackendServiceIap(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "oauth2ClientId":
            suggest = "oauth2_client_id"
        elif key == "oauth2ClientSecret":
            suggest = "oauth2_client_secret"
        elif key == "oauth2ClientSecretSha256":
            suggest = "oauth2_client_secret_sha256"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in BackendServiceIap. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        BackendServiceIap.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        BackendServiceIap.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 oauth2_client_id: str,
                 oauth2_client_secret: str,
                 oauth2_client_secret_sha256: Optional[str] = None):
        """
        :param str oauth2_client_id: OAuth2 Client ID for IAP
        :param str oauth2_client_secret: OAuth2 Client Secret for IAP
               **Note**: This property is sensitive and will not be displayed in the plan.
        :param 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) -> str:
        """
        OAuth2 Client ID for IAP
        """
        return pulumi.get(self, "oauth2_client_id")

    @property
    @pulumi.getter(name="oauth2ClientSecret")
    def oauth2_client_secret(self) -> 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")

    @property
    @pulumi.getter(name="oauth2ClientSecretSha256")
    def oauth2_client_secret_sha256(self) -> Optional[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")


@pulumi.output_type
class BackendServiceLocalityLbPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "customPolicy":
            suggest = "custom_policy"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in BackendServiceLocalityLbPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        BackendServiceLocalityLbPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        BackendServiceLocalityLbPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 custom_policy: Optional['outputs.BackendServiceLocalityLbPolicyCustomPolicy'] = None,
                 policy: Optional['outputs.BackendServiceLocalityLbPolicyPolicy'] = None):
        """
        :param 'BackendServiceLocalityLbPolicyCustomPolicyArgs' custom_policy: The configuration for a custom policy implemented by the user and
               deployed with the client.
               Structure is documented below.
        :param 'BackendServiceLocalityLbPolicyPolicyArgs' policy: The configuration for a built-in load balancing policy.
               Structure is documented below.
        """
        if custom_policy is not None:
            pulumi.set(__self__, "custom_policy", custom_policy)
        if policy is not None:
            pulumi.set(__self__, "policy", policy)

    @property
    @pulumi.getter(name="customPolicy")
    def custom_policy(self) -> Optional['outputs.BackendServiceLocalityLbPolicyCustomPolicy']:
        """
        The configuration for a custom policy implemented by the user and
        deployed with the client.
        Structure is documented below.
        """
        return pulumi.get(self, "custom_policy")

    @property
    @pulumi.getter
    def policy(self) -> Optional['outputs.BackendServiceLocalityLbPolicyPolicy']:
        """
        The configuration for a built-in load balancing policy.
        Structure is documented below.
        """
        return pulumi.get(self, "policy")


@pulumi.output_type
class BackendServiceLocalityLbPolicyCustomPolicy(dict):
    def __init__(__self__, *,
                 name: str,
                 data: Optional[str] = None):
        """
        :param str name: Identifies the custom policy.
               The value should match the type the custom implementation is registered
               with on the gRPC clients. It should follow protocol buffer
               message naming conventions and include the full path (e.g.
               myorg.CustomLbPolicy). The maximum length is 256 characters.
               Note that specifying the same custom policy more than once for a
               backend is not a valid configuration and will be rejected.
        :param str data: An optional, arbitrary JSON object with configuration data, understood
               by a locally installed custom policy implementation.
        """
        pulumi.set(__self__, "name", name)
        if data is not None:
            pulumi.set(__self__, "data", data)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Identifies the custom policy.
        The value should match the type the custom implementation is registered
        with on the gRPC clients. It should follow protocol buffer
        message naming conventions and include the full path (e.g.
        myorg.CustomLbPolicy). The maximum length is 256 characters.
        Note that specifying the same custom policy more than once for a
        backend is not a valid configuration and will be rejected.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def data(self) -> Optional[str]:
        """
        An optional, arbitrary JSON object with configuration data, understood
        by a locally installed custom policy implementation.
        """
        return pulumi.get(self, "data")


@pulumi.output_type
class BackendServiceLocalityLbPolicyPolicy(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param str name: The name of a locality load balancer policy to be used. The value
               should be one of the predefined ones as supported by localityLbPolicy,
               although at the moment only ROUND_ROBIN is supported.
               This field should only be populated when the customPolicy field is not
               used.
               Note that specifying the same policy more than once for a backend is
               not a valid configuration and will be rejected.
               The possible values are:
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of a locality load balancer policy to be used. The value
        should be one of the predefined ones as supported by localityLbPolicy,
        although at the moment only ROUND_ROBIN is supported.
        This field should only be populated when the customPolicy field is not
        used.
        Note that specifying the same policy more than once for a backend is
        not a valid configuration and will be rejected.
        The possible values are:
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class BackendServiceLogConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sampleRate":
            suggest = "sample_rate"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in BackendServiceLogConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        BackendServiceLogConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        BackendServiceLogConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enable: Optional[bool] = None,
                 sample_rate: Optional[float] = None):
        """
        :param bool enable: Whether to enable logging for the load balancer traffic served by this backend service.
        :param 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[bool]:
        """
        Whether to enable logging for the load balancer traffic served by this backend service.
        """
        return pulumi.get(self, "enable")

    @property
    @pulumi.getter(name="sampleRate")
    def sample_rate(self) -> Optional[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")


@pulumi.output_type
class BackendServiceOutlierDetection(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "baseEjectionTime":
            suggest = "base_ejection_time"
        elif key == "consecutiveErrors":
            suggest = "consecutive_errors"
        elif key == "consecutiveGatewayFailure":
            suggest = "consecutive_gateway_failure"
        elif key == "enforcingConsecutiveErrors":
            suggest = "enforcing_consecutive_errors"
        elif key == "enforcingConsecutiveGatewayFailure":
            suggest = "enforcing_consecutive_gateway_failure"
        elif key == "enforcingSuccessRate":
            suggest = "enforcing_success_rate"
        elif key == "maxEjectionPercent":
            suggest = "max_ejection_percent"
        elif key == "successRateMinimumHosts":
            suggest = "success_rate_minimum_hosts"
        elif key == "successRateRequestVolume":
            suggest = "success_rate_request_volume"
        elif key == "successRateStdevFactor":
            suggest = "success_rate_stdev_factor"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in BackendServiceOutlierDetection. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        BackendServiceOutlierDetection.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        BackendServiceOutlierDetection.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 base_ejection_time: Optional['outputs.BackendServiceOutlierDetectionBaseEjectionTime'] = None,
                 consecutive_errors: Optional[int] = None,
                 consecutive_gateway_failure: Optional[int] = None,
                 enforcing_consecutive_errors: Optional[int] = None,
                 enforcing_consecutive_gateway_failure: Optional[int] = None,
                 enforcing_success_rate: Optional[int] = None,
                 interval: Optional['outputs.BackendServiceOutlierDetectionInterval'] = None,
                 max_ejection_percent: Optional[int] = None,
                 success_rate_minimum_hosts: Optional[int] = None,
                 success_rate_request_volume: Optional[int] = None,
                 success_rate_stdev_factor: Optional[int] = None):
        """
        :param '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 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 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 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 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 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 '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 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 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 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 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['outputs.BackendServiceOutlierDetectionBaseEjectionTime']:
        """
        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")

    @property
    @pulumi.getter(name="consecutiveErrors")
    def consecutive_errors(self) -> Optional[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")

    @property
    @pulumi.getter(name="consecutiveGatewayFailure")
    def consecutive_gateway_failure(self) -> Optional[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")

    @property
    @pulumi.getter(name="enforcingConsecutiveErrors")
    def enforcing_consecutive_errors(self) -> Optional[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")

    @property
    @pulumi.getter(name="enforcingConsecutiveGatewayFailure")
    def enforcing_consecutive_gateway_failure(self) -> Optional[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")

    @property
    @pulumi.getter(name="enforcingSuccessRate")
    def enforcing_success_rate(self) -> Optional[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")

    @property
    @pulumi.getter
    def interval(self) -> Optional['outputs.BackendServiceOutlierDetectionInterval']:
        """
        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")

    @property
    @pulumi.getter(name="maxEjectionPercent")
    def max_ejection_percent(self) -> Optional[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")

    @property
    @pulumi.getter(name="successRateMinimumHosts")
    def success_rate_minimum_hosts(self) -> Optional[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")

    @property
    @pulumi.getter(name="successRateRequestVolume")
    def success_rate_request_volume(self) -> Optional[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")

    @property
    @pulumi.getter(name="successRateStdevFactor")
    def success_rate_stdev_factor(self) -> Optional[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")


@pulumi.output_type
class BackendServiceOutlierDetectionBaseEjectionTime(dict):
    def __init__(__self__, *,
                 seconds: int,
                 nanos: Optional[int] = None):
        """
        :param int seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
               inclusive.
        :param 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) -> 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")

    @property
    @pulumi.getter
    def nanos(self) -> Optional[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")


@pulumi.output_type
class BackendServiceOutlierDetectionInterval(dict):
    def __init__(__self__, *,
                 seconds: int,
                 nanos: Optional[int] = None):
        """
        :param int seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
               inclusive.
        :param 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) -> 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")

    @property
    @pulumi.getter
    def nanos(self) -> Optional[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")


@pulumi.output_type
class BackendServiceSecuritySettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientTlsPolicy":
            suggest = "client_tls_policy"
        elif key == "subjectAltNames":
            suggest = "subject_alt_names"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in BackendServiceSecuritySettings. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        BackendServiceSecuritySettings.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        BackendServiceSecuritySettings.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 client_tls_policy: str,
                 subject_alt_names: Sequence[str]):
        """
        :param 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 Sequence[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) -> 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")

    @property
    @pulumi.getter(name="subjectAltNames")
    def subject_alt_names(self) -> Sequence[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")


@pulumi.output_type
class DiskDiskEncryptionKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kmsKeySelfLink":
            suggest = "kms_key_self_link"
        elif key == "kmsKeyServiceAccount":
            suggest = "kms_key_service_account"
        elif key == "rawKey":
            suggest = "raw_key"
        elif key == "rsaEncryptedKey":
            suggest = "rsa_encrypted_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DiskDiskEncryptionKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DiskDiskEncryptionKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DiskDiskEncryptionKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kms_key_self_link: Optional[str] = None,
                 kms_key_service_account: Optional[str] = None,
                 raw_key: Optional[str] = None,
                 rsa_encrypted_key: Optional[str] = None,
                 sha256: Optional[str] = None):
        """
        :param 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 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 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 str rsa_encrypted_key: Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit
               customer-supplied encryption key to either encrypt or decrypt
               this resource. You can provide either the rawKey or the rsaEncryptedKey.
               **Note**: This property is sensitive and will not be displayed in the plan.
        :param 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 rsa_encrypted_key is not None:
            pulumi.set(__self__, "rsa_encrypted_key", rsa_encrypted_key)
        if sha256 is not None:
            pulumi.set(__self__, "sha256", sha256)

    @property
    @pulumi.getter(name="kmsKeySelfLink")
    def kms_key_self_link(self) -> Optional[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")

    @property
    @pulumi.getter(name="kmsKeyServiceAccount")
    def kms_key_service_account(self) -> Optional[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")

    @property
    @pulumi.getter(name="rawKey")
    def raw_key(self) -> Optional[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")

    @property
    @pulumi.getter(name="rsaEncryptedKey")
    def rsa_encrypted_key(self) -> Optional[str]:
        """
        Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit
        customer-supplied encryption key to either encrypt or decrypt
        this resource. You can provide either the rawKey or the rsaEncryptedKey.
        **Note**: This property is sensitive and will not be displayed in the plan.
        """
        return pulumi.get(self, "rsa_encrypted_key")

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


@pulumi.output_type
class DiskIamBindingCondition(dict):
    def __init__(__self__, *,
                 expression: str,
                 title: str,
                 description: Optional[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) -> str:
        return pulumi.get(self, "expression")

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

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


@pulumi.output_type
class DiskIamMemberCondition(dict):
    def __init__(__self__, *,
                 expression: str,
                 title: str,
                 description: Optional[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) -> str:
        return pulumi.get(self, "expression")

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

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


@pulumi.output_type
class DiskSourceImageEncryptionKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kmsKeySelfLink":
            suggest = "kms_key_self_link"
        elif key == "kmsKeyServiceAccount":
            suggest = "kms_key_service_account"
        elif key == "rawKey":
            suggest = "raw_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DiskSourceImageEncryptionKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DiskSourceImageEncryptionKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DiskSourceImageEncryptionKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kms_key_self_link: Optional[str] = None,
                 kms_key_service_account: Optional[str] = None,
                 raw_key: Optional[str] = None,
                 sha256: Optional[str] = None):
        """
        :param 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 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 str raw_key: Specifies a 256-bit customer-supplied encryption key, encoded in
               RFC 4648 base64 to either encrypt or decrypt this resource.
        :param 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[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")

    @property
    @pulumi.getter(name="kmsKeyServiceAccount")
    def kms_key_service_account(self) -> Optional[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")

    @property
    @pulumi.getter(name="rawKey")
    def raw_key(self) -> Optional[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")

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


@pulumi.output_type
class DiskSourceSnapshotEncryptionKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kmsKeySelfLink":
            suggest = "kms_key_self_link"
        elif key == "kmsKeyServiceAccount":
            suggest = "kms_key_service_account"
        elif key == "rawKey":
            suggest = "raw_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DiskSourceSnapshotEncryptionKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DiskSourceSnapshotEncryptionKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DiskSourceSnapshotEncryptionKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kms_key_self_link: Optional[str] = None,
                 kms_key_service_account: Optional[str] = None,
                 raw_key: Optional[str] = None,
                 sha256: Optional[str] = None):
        """
        :param 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 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 str raw_key: Specifies a 256-bit customer-supplied encryption key, encoded in
               RFC 4648 base64 to either encrypt or decrypt this resource.
        :param 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[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")

    @property
    @pulumi.getter(name="kmsKeyServiceAccount")
    def kms_key_service_account(self) -> Optional[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")

    @property
    @pulumi.getter(name="rawKey")
    def raw_key(self) -> Optional[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")

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


@pulumi.output_type
class ExternalVpnGatewayInterface(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipAddress":
            suggest = "ip_address"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ExternalVpnGatewayInterface. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ExternalVpnGatewayInterface.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ExternalVpnGatewayInterface.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 id: Optional[int] = None,
                 ip_address: Optional[str] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> Optional[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")


@pulumi.output_type
class FirewallAllow(dict):
    def __init__(__self__, *,
                 protocol: str,
                 ports: Optional[Sequence[str]] = None):
        """
        :param 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 Sequence[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) -> 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")

    @property
    @pulumi.getter
    def ports(self) -> Optional[Sequence[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")


@pulumi.output_type
class FirewallDeny(dict):
    def __init__(__self__, *,
                 protocol: str,
                 ports: Optional[Sequence[str]] = None):
        """
        :param 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 Sequence[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) -> 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")

    @property
    @pulumi.getter
    def ports(self) -> Optional[Sequence[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")


@pulumi.output_type
class FirewallLogConfig(dict):
    def __init__(__self__, *,
                 metadata: str):
        """
        :param 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) -> 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")


@pulumi.output_type
class FirewallPolicyRuleMatch(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "layer4Configs":
            suggest = "layer4_configs"
        elif key == "destIpRanges":
            suggest = "dest_ip_ranges"
        elif key == "srcIpRanges":
            suggest = "src_ip_ranges"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FirewallPolicyRuleMatch. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FirewallPolicyRuleMatch.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FirewallPolicyRuleMatch.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 layer4_configs: Sequence['outputs.FirewallPolicyRuleMatchLayer4Config'],
                 dest_ip_ranges: Optional[Sequence[str]] = None,
                 src_ip_ranges: Optional[Sequence[str]] = None):
        """
        :param Sequence['FirewallPolicyRuleMatchLayer4ConfigArgs'] layer4_configs: Pairs of IP protocols and ports that the rule should match. Structure is documented below.
        :param Sequence[str] dest_ip_ranges: CIDR IP address range. Maximum number of destination CIDR IP ranges allowed is 256.
        :param Sequence[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) -> Sequence['outputs.FirewallPolicyRuleMatchLayer4Config']:
        """
        Pairs of IP protocols and ports that the rule should match. Structure is documented below.
        """
        return pulumi.get(self, "layer4_configs")

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

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


@pulumi.output_type
class FirewallPolicyRuleMatchLayer4Config(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipProtocol":
            suggest = "ip_protocol"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in FirewallPolicyRuleMatchLayer4Config. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        FirewallPolicyRuleMatchLayer4Config.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        FirewallPolicyRuleMatchLayer4Config.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ip_protocol: str,
                 ports: Optional[Sequence[str]] = None):
        """
        :param 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 Sequence[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) -> 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")

    @property
    @pulumi.getter
    def ports(self) -> Optional[Sequence[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")


@pulumi.output_type
class ForwardingRuleServiceDirectoryRegistration(dict):
    def __init__(__self__, *,
                 namespace: Optional[str] = None,
                 service: Optional[str] = None):
        """
        :param str namespace: Service Directory namespace to register the forwarding rule under.
        :param 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[str]:
        """
        Service Directory namespace to register the forwarding rule under.
        """
        return pulumi.get(self, "namespace")

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


@pulumi.output_type
class GlobalForwardingRuleMetadataFilter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "filterLabels":
            suggest = "filter_labels"
        elif key == "filterMatchCriteria":
            suggest = "filter_match_criteria"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in GlobalForwardingRuleMetadataFilter. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        GlobalForwardingRuleMetadataFilter.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        GlobalForwardingRuleMetadataFilter.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 filter_labels: Sequence['outputs.GlobalForwardingRuleMetadataFilterFilterLabel'],
                 filter_match_criteria: str):
        """
        :param Sequence['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 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) -> Sequence['outputs.GlobalForwardingRuleMetadataFilterFilterLabel']:
        """
        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")

    @property
    @pulumi.getter(name="filterMatchCriteria")
    def filter_match_criteria(self) -> 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")


@pulumi.output_type
class GlobalForwardingRuleMetadataFilterFilterLabel(dict):
    def __init__(__self__, *,
                 name: str,
                 value: str):
        """
        :param str name: Name of the metadata label. The length must be between
               1 and 1024 characters, inclusive.
        :param 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) -> str:
        """
        Name of the metadata label. The length must be between
        1 and 1024 characters, inclusive.
        """
        return pulumi.get(self, "name")

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


@pulumi.output_type
class HaVpnGatewayVpnInterface(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "interconnectAttachment":
            suggest = "interconnect_attachment"
        elif key == "ipAddress":
            suggest = "ip_address"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in HaVpnGatewayVpnInterface. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        HaVpnGatewayVpnInterface.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        HaVpnGatewayVpnInterface.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 id: Optional[int] = None,
                 interconnect_attachment: Optional[str] = None,
                 ip_address: Optional[str] = None):
        """
        :param int id: The numeric ID of this VPN gateway interface.
        :param 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 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[int]:
        """
        The numeric ID of this VPN gateway interface.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="interconnectAttachment")
    def interconnect_attachment(self) -> Optional[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")

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


@pulumi.output_type
class HealthCheckGrpcHealthCheck(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "grpcServiceName":
            suggest = "grpc_service_name"
        elif key == "portName":
            suggest = "port_name"
        elif key == "portSpecification":
            suggest = "port_specification"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in HealthCheckGrpcHealthCheck. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        HealthCheckGrpcHealthCheck.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        HealthCheckGrpcHealthCheck.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 grpc_service_name: Optional[str] = None,
                 port: Optional[int] = None,
                 port_name: Optional[str] = None,
                 port_specification: Optional[str] = None):
        """
        :param 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 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 str port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param str port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
        """
        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[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")

    @property
    @pulumi.getter
    def port(self) -> Optional[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")

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> Optional[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")

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[str]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        """
        return pulumi.get(self, "port_specification")


@pulumi.output_type
class HealthCheckHttp2HealthCheck(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "portName":
            suggest = "port_name"
        elif key == "portSpecification":
            suggest = "port_specification"
        elif key == "proxyHeader":
            suggest = "proxy_header"
        elif key == "requestPath":
            suggest = "request_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in HealthCheckHttp2HealthCheck. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        HealthCheckHttp2HealthCheck.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        HealthCheckHttp2HealthCheck.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 host: Optional[str] = None,
                 port: Optional[int] = None,
                 port_name: Optional[str] = None,
                 port_specification: Optional[str] = None,
                 proxy_header: Optional[str] = None,
                 request_path: Optional[str] = None,
                 response: Optional[str] = None):
        """
        :param str host: The value of the host header in the HTTP health check request.
               If left empty (default value), the public IP on behalf of which this health
               check is performed will be used.
               (Optional)
               The value of the host header in the HTTPS health check request.
               If left empty (default value), the public IP on behalf of which this health
               check is performed will be used.
               (Optional)
               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 int port: The TCP port number for the HTTP health check request.
               The default value is 80.
               (Optional)
               The TCP port number for the HTTPS health check request.
               The default value is 443.
               (Optional)
               The TCP port number for the TCP health check request.
               The default value is 443.
               (Optional)
               The TCP port number for the SSL health check request.
               The default value is 443.
               (Optional)
               The TCP port number for the HTTP2 health check request.
               The default value is 443.
               (Optional)
               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 str port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
               (Optional)
               Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
               (Optional)
               Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
               (Optional)
               Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
               (Optional)
               Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
               (Optional)
               Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param str port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
               (Optional)
               Specifies how port is selected for health checking, can be one of the
               following values:
               (Optional)
               Specifies how port is selected for health checking, can be one of the
               following values:
               (Optional)
               Specifies how port is selected for health checking, can be one of the
               following values:
               (Optional)
               Specifies how port is selected for health checking, can be one of the
               following values:
               (Optional)
               Specifies how port is selected for health checking, can be one of the
               following values:
        :param 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`.
               (Optional)
               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`.
               (Optional)
               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`.
               (Optional)
               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`.
               (Optional)
               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 str request_path: The request path of the HTTP health check request.
               The default value is /.
               (Optional)
               The request path of the HTTPS health check request.
               The default value is /.
               (Optional)
               The request path of the HTTP2 health check request.
               The default value is /.
        :param 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.
               (Optional)
               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.
               (Optional)
               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.
               (Optional)
               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.
               (Optional)
               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[str]:
        """
        The value of the host header in the HTTP health check request.
        If left empty (default value), the public IP on behalf of which this health
        check is performed will be used.
        (Optional)
        The value of the host header in the HTTPS health check request.
        If left empty (default value), the public IP on behalf of which this health
        check is performed will be used.
        (Optional)
        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")

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        The TCP port number for the HTTP health check request.
        The default value is 80.
        (Optional)
        The TCP port number for the HTTPS health check request.
        The default value is 443.
        (Optional)
        The TCP port number for the TCP health check request.
        The default value is 443.
        (Optional)
        The TCP port number for the SSL health check request.
        The default value is 443.
        (Optional)
        The TCP port number for the HTTP2 health check request.
        The default value is 443.
        (Optional)
        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")

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

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[str]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        (Optional)
        Specifies how port is selected for health checking, can be one of the
        following values:
        (Optional)
        Specifies how port is selected for health checking, can be one of the
        following values:
        (Optional)
        Specifies how port is selected for health checking, can be one of the
        following values:
        (Optional)
        Specifies how port is selected for health checking, can be one of the
        following values:
        (Optional)
        Specifies how port is selected for health checking, can be one of the
        following values:
        """
        return pulumi.get(self, "port_specification")

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> Optional[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`.
        (Optional)
        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`.
        (Optional)
        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`.
        (Optional)
        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`.
        (Optional)
        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")

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

    @property
    @pulumi.getter
    def response(self) -> Optional[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.
        (Optional)
        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.
        (Optional)
        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.
        (Optional)
        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.
        (Optional)
        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")


@pulumi.output_type
class HealthCheckHttpHealthCheck(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "portName":
            suggest = "port_name"
        elif key == "portSpecification":
            suggest = "port_specification"
        elif key == "proxyHeader":
            suggest = "proxy_header"
        elif key == "requestPath":
            suggest = "request_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in HealthCheckHttpHealthCheck. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        HealthCheckHttpHealthCheck.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        HealthCheckHttpHealthCheck.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 host: Optional[str] = None,
                 port: Optional[int] = None,
                 port_name: Optional[str] = None,
                 port_specification: Optional[str] = None,
                 proxy_header: Optional[str] = None,
                 request_path: Optional[str] = None,
                 response: Optional[str] = None):
        """
        :param str host: The value of the host header in the HTTP health check request.
               If left empty (default value), the public IP on behalf of which this health
               check is performed will be used.
        :param int port: The TCP port number for the HTTP health check request.
               The default value is 80.
        :param str port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param str port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
        :param 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 str request_path: The request path of the HTTP health check request.
               The default value is /.
        :param 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[str]:
        """
        The value of the host header in the HTTP 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")

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        The TCP port number for the HTTP health check request.
        The default value is 80.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> Optional[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")

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[str]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        """
        return pulumi.get(self, "port_specification")

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> Optional[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")

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

    @property
    @pulumi.getter
    def response(self) -> Optional[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")


@pulumi.output_type
class HealthCheckHttpsHealthCheck(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "portName":
            suggest = "port_name"
        elif key == "portSpecification":
            suggest = "port_specification"
        elif key == "proxyHeader":
            suggest = "proxy_header"
        elif key == "requestPath":
            suggest = "request_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in HealthCheckHttpsHealthCheck. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        HealthCheckHttpsHealthCheck.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        HealthCheckHttpsHealthCheck.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 host: Optional[str] = None,
                 port: Optional[int] = None,
                 port_name: Optional[str] = None,
                 port_specification: Optional[str] = None,
                 proxy_header: Optional[str] = None,
                 request_path: Optional[str] = None,
                 response: Optional[str] = None):
        """
        :param str host: The value of the host header in the HTTPS health check request.
               If left empty (default value), the public IP on behalf of which this health
               check is performed will be used.
        :param int port: The TCP port number for the HTTPS health check request.
               The default value is 443.
        :param str port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param str port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
        :param 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 str request_path: The request path of the HTTPS health check request.
               The default value is /.
        :param 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[str]:
        """
        The value of the host header in the HTTPS 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")

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        The TCP port number for the HTTPS health check request.
        The default value is 443.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> Optional[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")

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[str]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        """
        return pulumi.get(self, "port_specification")

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> Optional[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")

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

    @property
    @pulumi.getter
    def response(self) -> Optional[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")


@pulumi.output_type
class HealthCheckLogConfig(dict):
    def __init__(__self__, *,
                 enable: Optional[bool] = None):
        """
        :param 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[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")


@pulumi.output_type
class HealthCheckSslHealthCheck(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "portName":
            suggest = "port_name"
        elif key == "portSpecification":
            suggest = "port_specification"
        elif key == "proxyHeader":
            suggest = "proxy_header"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in HealthCheckSslHealthCheck. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        HealthCheckSslHealthCheck.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        HealthCheckSslHealthCheck.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 port: Optional[int] = None,
                 port_name: Optional[str] = None,
                 port_specification: Optional[str] = None,
                 proxy_header: Optional[str] = None,
                 request: Optional[str] = None,
                 response: Optional[str] = None):
        """
        :param int port: The TCP port number for the HTTP2 health check request.
               The default value is 443.
        :param str port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param str port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
        :param 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 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 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[int]:
        """
        The TCP port number for the HTTP2 health check request.
        The default value is 443.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> Optional[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")

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[str]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        """
        return pulumi.get(self, "port_specification")

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> Optional[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")

    @property
    @pulumi.getter
    def request(self) -> Optional[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")

    @property
    @pulumi.getter
    def response(self) -> Optional[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")


@pulumi.output_type
class HealthCheckTcpHealthCheck(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "portName":
            suggest = "port_name"
        elif key == "portSpecification":
            suggest = "port_specification"
        elif key == "proxyHeader":
            suggest = "proxy_header"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in HealthCheckTcpHealthCheck. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        HealthCheckTcpHealthCheck.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        HealthCheckTcpHealthCheck.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 port: Optional[int] = None,
                 port_name: Optional[str] = None,
                 port_specification: Optional[str] = None,
                 proxy_header: Optional[str] = None,
                 request: Optional[str] = None,
                 response: Optional[str] = None):
        """
        :param int port: The TCP port number for the TCP health check request.
               The default value is 443.
        :param str port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param str port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
        :param 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 str request: The application data to send once the TCP 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 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[int]:
        """
        The TCP port number for the TCP health check request.
        The default value is 443.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> Optional[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")

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[str]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        """
        return pulumi.get(self, "port_specification")

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> Optional[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")

    @property
    @pulumi.getter
    def request(self) -> Optional[str]:
        """
        The application data to send once the TCP 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")

    @property
    @pulumi.getter
    def response(self) -> Optional[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")


@pulumi.output_type
class ImageGuestOsFeature(dict):
    def __init__(__self__, *,
                 type: str):
        """
        :param 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) -> 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")


@pulumi.output_type
class ImageIamBindingCondition(dict):
    def __init__(__self__, *,
                 expression: str,
                 title: str,
                 description: Optional[str] = None):
        """
        :param str expression: Textual representation of an expression in Common Expression Language syntax.
        :param str title: A title for the expression, i.e. a short string describing its purpose.
        :param 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) -> str:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[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")


@pulumi.output_type
class ImageIamMemberCondition(dict):
    def __init__(__self__, *,
                 expression: str,
                 title: str,
                 description: Optional[str] = None):
        """
        :param str expression: Textual representation of an expression in Common Expression Language syntax.
        :param str title: A title for the expression, i.e. a short string describing its purpose.
        :param 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) -> str:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[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")


@pulumi.output_type
class ImageImageEncryptionKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kmsKeySelfLink":
            suggest = "kms_key_self_link"
        elif key == "kmsKeyServiceAccount":
            suggest = "kms_key_service_account"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ImageImageEncryptionKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ImageImageEncryptionKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ImageImageEncryptionKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kms_key_self_link: Optional[str] = None,
                 kms_key_service_account: Optional[str] = None):
        """
        :param str kms_key_self_link: The self link of the encryption key that is stored in Google Cloud
               KMS.
        :param str kms_key_service_account: The service account being used for the encryption request for the
               given KMS key. If absent, the Compute Engine default service
               account is used.
        """
        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)

    @property
    @pulumi.getter(name="kmsKeySelfLink")
    def kms_key_self_link(self) -> Optional[str]:
        """
        The self link of the encryption key that is stored in Google Cloud
        KMS.
        """
        return pulumi.get(self, "kms_key_self_link")

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


@pulumi.output_type
class ImageRawDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "containerType":
            suggest = "container_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ImageRawDisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ImageRawDisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ImageRawDisk.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 source: str,
                 container_type: Optional[str] = None,
                 sha1: Optional[str] = None):
        """
        :param 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 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 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) -> 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")

    @property
    @pulumi.getter(name="containerType")
    def container_type(self) -> Optional[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")

    @property
    @pulumi.getter
    def sha1(self) -> Optional[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")


@pulumi.output_type
class InstanceAdvancedMachineFeatures(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableNestedVirtualization":
            suggest = "enable_nested_virtualization"
        elif key == "threadsPerCore":
            suggest = "threads_per_core"
        elif key == "visibleCoreCount":
            suggest = "visible_core_count"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceAdvancedMachineFeatures. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceAdvancedMachineFeatures.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceAdvancedMachineFeatures.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enable_nested_virtualization: Optional[bool] = None,
                 threads_per_core: Optional[int] = None,
                 visible_core_count: Optional[int] = None):
        """
        :param bool enable_nested_virtualization: Defines whether the instance should have nested virtualization  enabled. Defaults to false.
        :param 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.
        :param int visible_core_count: The number of physical cores to expose to an instance. [visible cores info (VC)](https://cloud.google.com/compute/docs/instances/customize-visible-cores).
        """
        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)
        if visible_core_count is not None:
            pulumi.set(__self__, "visible_core_count", visible_core_count)

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

    @property
    @pulumi.getter(name="threadsPerCore")
    def threads_per_core(self) -> Optional[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")

    @property
    @pulumi.getter(name="visibleCoreCount")
    def visible_core_count(self) -> Optional[int]:
        """
        The number of physical cores to expose to an instance. [visible cores info (VC)](https://cloud.google.com/compute/docs/instances/customize-visible-cores).
        """
        return pulumi.get(self, "visible_core_count")


@pulumi.output_type
class InstanceAttachedDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deviceName":
            suggest = "device_name"
        elif key == "diskEncryptionKeyRaw":
            suggest = "disk_encryption_key_raw"
        elif key == "diskEncryptionKeySha256":
            suggest = "disk_encryption_key_sha256"
        elif key == "kmsKeySelfLink":
            suggest = "kms_key_self_link"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceAttachedDisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceAttachedDisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceAttachedDisk.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 source: str,
                 device_name: Optional[str] = None,
                 disk_encryption_key_raw: Optional[str] = None,
                 disk_encryption_key_sha256: Optional[str] = None,
                 kms_key_self_link: Optional[str] = None,
                 mode: Optional[str] = None):
        """
        :param str source: The name or self_link of the disk to attach to this instance.
        :param str device_name: Name with which the attached disk will be accessible
               under `/dev/disk/by-id/google-*`
        :param 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 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 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) -> str:
        """
        The name or self_link of the disk to attach to this instance.
        """
        return pulumi.get(self, "source")

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

    @property
    @pulumi.getter(name="diskEncryptionKeyRaw")
    def disk_encryption_key_raw(self) -> Optional[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")

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

    @property
    @pulumi.getter(name="kmsKeySelfLink")
    def kms_key_self_link(self) -> Optional[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")

    @property
    @pulumi.getter
    def mode(self) -> Optional[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")


@pulumi.output_type
class InstanceBootDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "autoDelete":
            suggest = "auto_delete"
        elif key == "deviceName":
            suggest = "device_name"
        elif key == "diskEncryptionKeyRaw":
            suggest = "disk_encryption_key_raw"
        elif key == "diskEncryptionKeySha256":
            suggest = "disk_encryption_key_sha256"
        elif key == "initializeParams":
            suggest = "initialize_params"
        elif key == "kmsKeySelfLink":
            suggest = "kms_key_self_link"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceBootDisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceBootDisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceBootDisk.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 auto_delete: Optional[bool] = None,
                 device_name: Optional[str] = None,
                 disk_encryption_key_raw: Optional[str] = None,
                 disk_encryption_key_sha256: Optional[str] = None,
                 initialize_params: Optional['outputs.InstanceBootDiskInitializeParams'] = None,
                 kms_key_self_link: Optional[str] = None,
                 mode: Optional[str] = None,
                 source: Optional[str] = None):
        """
        :param bool auto_delete: Whether the disk will be auto-deleted when the instance
               is deleted. Defaults to true.
        :param str device_name: Name with which attached disk will be accessible.
               On the instance, this device will be `/dev/disk/by-id/google-{{device_name}}`.
        :param 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 '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 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 str mode: The mode in which to attach this disk, either `READ_WRITE`
               or `READ_ONLY`. If not specified, the default is to attach the disk in `READ_WRITE` mode.
        :param str source: The name or self_link of the existing disk (such as those managed by
               `compute.Disk`) or disk image. To create an instance from a snapshot, first create a
               `compute.Disk` from a snapshot and reference it here.
        """
        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[bool]:
        """
        Whether the disk will be auto-deleted when the instance
        is deleted. Defaults to true.
        """
        return pulumi.get(self, "auto_delete")

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

    @property
    @pulumi.getter(name="diskEncryptionKeyRaw")
    def disk_encryption_key_raw(self) -> Optional[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")

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

    @property
    @pulumi.getter(name="initializeParams")
    def initialize_params(self) -> Optional['outputs.InstanceBootDiskInitializeParams']:
        """
        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")

    @property
    @pulumi.getter(name="kmsKeySelfLink")
    def kms_key_self_link(self) -> Optional[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")

    @property
    @pulumi.getter
    def mode(self) -> Optional[str]:
        """
        The mode in which to attach this disk, either `READ_WRITE`
        or `READ_ONLY`. If not specified, the default is to attach the disk in `READ_WRITE` mode.
        """
        return pulumi.get(self, "mode")

    @property
    @pulumi.getter
    def source(self) -> Optional[str]:
        """
        The name or self_link of the existing disk (such as those managed by
        `compute.Disk`) or disk image. To create an instance from a snapshot, first create a
        `compute.Disk` from a snapshot and reference it here.
        """
        return pulumi.get(self, "source")


@pulumi.output_type
class InstanceBootDiskInitializeParams(dict):
    def __init__(__self__, *,
                 image: Optional[str] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 size: Optional[int] = None,
                 type: Optional[str] = None):
        """
        :param 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 Mapping[str, Any] labels: A set of key/value label pairs assigned to the disk. This  
               field is only applicable for persistent disks.
        :param int size: The size of the image in gigabytes. If not specified, it
               will inherit the size of its base image.
        :param str type: The GCE disk type. Such as pd-standard, pd-balanced or pd-ssd.
        """
        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[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")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, Any]]:
        """
        A set of key/value label pairs assigned to the disk. This  
        field is only applicable for persistent disks.
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter
    def size(self) -> Optional[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")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        The GCE disk type. Such as pd-standard, pd-balanced or pd-ssd.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class InstanceConfidentialInstanceConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableConfidentialCompute":
            suggest = "enable_confidential_compute"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceConfidentialInstanceConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceConfidentialInstanceConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceConfidentialInstanceConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enable_confidential_compute: bool):
        """
        :param 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) -> 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")


@pulumi.output_type
class InstanceFromMachineImageAdvancedMachineFeatures(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableNestedVirtualization":
            suggest = "enable_nested_virtualization"
        elif key == "threadsPerCore":
            suggest = "threads_per_core"
        elif key == "visibleCoreCount":
            suggest = "visible_core_count"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromMachineImageAdvancedMachineFeatures. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromMachineImageAdvancedMachineFeatures.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromMachineImageAdvancedMachineFeatures.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enable_nested_virtualization: Optional[bool] = None,
                 threads_per_core: Optional[int] = None,
                 visible_core_count: Optional[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)
        if visible_core_count is not None:
            pulumi.set(__self__, "visible_core_count", visible_core_count)

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

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

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


@pulumi.output_type
class InstanceFromMachineImageAttachedDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deviceName":
            suggest = "device_name"
        elif key == "diskEncryptionKeyRaw":
            suggest = "disk_encryption_key_raw"
        elif key == "diskEncryptionKeySha256":
            suggest = "disk_encryption_key_sha256"
        elif key == "kmsKeySelfLink":
            suggest = "kms_key_self_link"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromMachineImageAttachedDisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromMachineImageAttachedDisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromMachineImageAttachedDisk.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 source: str,
                 device_name: Optional[str] = None,
                 disk_encryption_key_raw: Optional[str] = None,
                 disk_encryption_key_sha256: Optional[str] = None,
                 kms_key_self_link: Optional[str] = None,
                 mode: Optional[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) -> str:
        return pulumi.get(self, "source")

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

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

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

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

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


@pulumi.output_type
class InstanceFromMachineImageBootDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "autoDelete":
            suggest = "auto_delete"
        elif key == "deviceName":
            suggest = "device_name"
        elif key == "diskEncryptionKeyRaw":
            suggest = "disk_encryption_key_raw"
        elif key == "diskEncryptionKeySha256":
            suggest = "disk_encryption_key_sha256"
        elif key == "initializeParams":
            suggest = "initialize_params"
        elif key == "kmsKeySelfLink":
            suggest = "kms_key_self_link"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromMachineImageBootDisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromMachineImageBootDisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromMachineImageBootDisk.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 auto_delete: Optional[bool] = None,
                 device_name: Optional[str] = None,
                 disk_encryption_key_raw: Optional[str] = None,
                 disk_encryption_key_sha256: Optional[str] = None,
                 initialize_params: Optional['outputs.InstanceFromMachineImageBootDiskInitializeParams'] = None,
                 kms_key_self_link: Optional[str] = None,
                 mode: Optional[str] = None,
                 source: Optional[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[bool]:
        return pulumi.get(self, "auto_delete")

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

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

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

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

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

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

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


@pulumi.output_type
class InstanceFromMachineImageBootDiskInitializeParams(dict):
    def __init__(__self__, *,
                 image: Optional[str] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 size: Optional[int] = None,
                 type: Optional[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[str]:
        return pulumi.get(self, "image")

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

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

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


@pulumi.output_type
class InstanceFromMachineImageConfidentialInstanceConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableConfidentialCompute":
            suggest = "enable_confidential_compute"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromMachineImageConfidentialInstanceConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromMachineImageConfidentialInstanceConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromMachineImageConfidentialInstanceConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enable_confidential_compute: bool):
        pulumi.set(__self__, "enable_confidential_compute", enable_confidential_compute)

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


@pulumi.output_type
class InstanceFromMachineImageGuestAccelerator(dict):
    def __init__(__self__, *,
                 count: int,
                 type: str):
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "type", type)

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

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


@pulumi.output_type
class InstanceFromMachineImageNetworkInterface(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessConfigs":
            suggest = "access_configs"
        elif key == "aliasIpRanges":
            suggest = "alias_ip_ranges"
        elif key == "ipv6AccessConfigs":
            suggest = "ipv6_access_configs"
        elif key == "ipv6AccessType":
            suggest = "ipv6_access_type"
        elif key == "networkIp":
            suggest = "network_ip"
        elif key == "nicType":
            suggest = "nic_type"
        elif key == "queueCount":
            suggest = "queue_count"
        elif key == "stackType":
            suggest = "stack_type"
        elif key == "subnetworkProject":
            suggest = "subnetwork_project"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromMachineImageNetworkInterface. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromMachineImageNetworkInterface.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromMachineImageNetworkInterface.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 access_configs: Optional[Sequence['outputs.InstanceFromMachineImageNetworkInterfaceAccessConfig']] = None,
                 alias_ip_ranges: Optional[Sequence['outputs.InstanceFromMachineImageNetworkInterfaceAliasIpRange']] = None,
                 ipv6_access_configs: Optional[Sequence['outputs.InstanceFromMachineImageNetworkInterfaceIpv6AccessConfig']] = None,
                 ipv6_access_type: Optional[str] = None,
                 name: Optional[str] = None,
                 network: Optional[str] = None,
                 network_ip: Optional[str] = None,
                 nic_type: Optional[str] = None,
                 queue_count: Optional[int] = None,
                 stack_type: Optional[str] = None,
                 subnetwork: Optional[str] = None,
                 subnetwork_project: Optional[str] = None):
        """
        :param 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[Sequence['outputs.InstanceFromMachineImageNetworkInterfaceAccessConfig']]:
        return pulumi.get(self, "access_configs")

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

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

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class InstanceFromMachineImageNetworkInterfaceAccessConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "natIp":
            suggest = "nat_ip"
        elif key == "networkTier":
            suggest = "network_tier"
        elif key == "publicPtrDomainName":
            suggest = "public_ptr_domain_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromMachineImageNetworkInterfaceAccessConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromMachineImageNetworkInterfaceAccessConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromMachineImageNetworkInterfaceAccessConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 nat_ip: Optional[str] = None,
                 network_tier: Optional[str] = None,
                 public_ptr_domain_name: Optional[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[str]:
        return pulumi.get(self, "nat_ip")

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

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


@pulumi.output_type
class InstanceFromMachineImageNetworkInterfaceAliasIpRange(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipCidrRange":
            suggest = "ip_cidr_range"
        elif key == "subnetworkRangeName":
            suggest = "subnetwork_range_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromMachineImageNetworkInterfaceAliasIpRange. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromMachineImageNetworkInterfaceAliasIpRange.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromMachineImageNetworkInterfaceAliasIpRange.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ip_cidr_range: str,
                 subnetwork_range_name: Optional[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) -> str:
        return pulumi.get(self, "ip_cidr_range")

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


@pulumi.output_type
class InstanceFromMachineImageNetworkInterfaceIpv6AccessConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "networkTier":
            suggest = "network_tier"
        elif key == "externalIpv6":
            suggest = "external_ipv6"
        elif key == "externalIpv6PrefixLength":
            suggest = "external_ipv6_prefix_length"
        elif key == "publicPtrDomainName":
            suggest = "public_ptr_domain_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromMachineImageNetworkInterfaceIpv6AccessConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromMachineImageNetworkInterfaceIpv6AccessConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromMachineImageNetworkInterfaceIpv6AccessConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 network_tier: str,
                 external_ipv6: Optional[str] = None,
                 external_ipv6_prefix_length: Optional[str] = None,
                 public_ptr_domain_name: Optional[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) -> str:
        return pulumi.get(self, "network_tier")

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

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

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


@pulumi.output_type
class InstanceFromMachineImageNetworkPerformanceConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "totalEgressBandwidthTier":
            suggest = "total_egress_bandwidth_tier"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromMachineImageNetworkPerformanceConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromMachineImageNetworkPerformanceConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromMachineImageNetworkPerformanceConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 total_egress_bandwidth_tier: str):
        pulumi.set(__self__, "total_egress_bandwidth_tier", total_egress_bandwidth_tier)

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


@pulumi.output_type
class InstanceFromMachineImageReservationAffinity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "specificReservation":
            suggest = "specific_reservation"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromMachineImageReservationAffinity. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromMachineImageReservationAffinity.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromMachineImageReservationAffinity.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 type: str,
                 specific_reservation: Optional['outputs.InstanceFromMachineImageReservationAffinitySpecificReservation'] = 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) -> str:
        return pulumi.get(self, "type")

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


@pulumi.output_type
class InstanceFromMachineImageReservationAffinitySpecificReservation(dict):
    def __init__(__self__, *,
                 key: str,
                 values: Sequence[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "values", values)

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

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


@pulumi.output_type
class InstanceFromMachineImageScheduling(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "automaticRestart":
            suggest = "automatic_restart"
        elif key == "instanceTerminationAction":
            suggest = "instance_termination_action"
        elif key == "maxRunDuration":
            suggest = "max_run_duration"
        elif key == "minNodeCpus":
            suggest = "min_node_cpus"
        elif key == "nodeAffinities":
            suggest = "node_affinities"
        elif key == "onHostMaintenance":
            suggest = "on_host_maintenance"
        elif key == "provisioningModel":
            suggest = "provisioning_model"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromMachineImageScheduling. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromMachineImageScheduling.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromMachineImageScheduling.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 automatic_restart: Optional[bool] = None,
                 instance_termination_action: Optional[str] = None,
                 max_run_duration: Optional['outputs.InstanceFromMachineImageSchedulingMaxRunDuration'] = None,
                 min_node_cpus: Optional[int] = None,
                 node_affinities: Optional[Sequence['outputs.InstanceFromMachineImageSchedulingNodeAffinity']] = None,
                 on_host_maintenance: Optional[str] = None,
                 preemptible: Optional[bool] = None,
                 provisioning_model: Optional[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 max_run_duration is not None:
            pulumi.set(__self__, "max_run_duration", max_run_duration)
        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[bool]:
        return pulumi.get(self, "automatic_restart")

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

    @property
    @pulumi.getter(name="maxRunDuration")
    def max_run_duration(self) -> Optional['outputs.InstanceFromMachineImageSchedulingMaxRunDuration']:
        return pulumi.get(self, "max_run_duration")

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

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

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

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

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


@pulumi.output_type
class InstanceFromMachineImageSchedulingMaxRunDuration(dict):
    def __init__(__self__, *,
                 seconds: int,
                 nanos: Optional[int] = None):
        pulumi.set(__self__, "seconds", seconds)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)

    @property
    @pulumi.getter
    def seconds(self) -> int:
        return pulumi.get(self, "seconds")

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


@pulumi.output_type
class InstanceFromMachineImageSchedulingNodeAffinity(dict):
    def __init__(__self__, *,
                 key: str,
                 operator: str,
                 values: Sequence[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

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

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

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


@pulumi.output_type
class InstanceFromMachineImageScratchDisk(dict):
    def __init__(__self__, *,
                 interface: str):
        pulumi.set(__self__, "interface", interface)

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


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

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

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


@pulumi.output_type
class InstanceFromMachineImageShieldedInstanceConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableIntegrityMonitoring":
            suggest = "enable_integrity_monitoring"
        elif key == "enableSecureBoot":
            suggest = "enable_secure_boot"
        elif key == "enableVtpm":
            suggest = "enable_vtpm"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromMachineImageShieldedInstanceConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromMachineImageShieldedInstanceConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromMachineImageShieldedInstanceConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enable_integrity_monitoring: Optional[bool] = None,
                 enable_secure_boot: Optional[bool] = None,
                 enable_vtpm: Optional[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[bool]:
        return pulumi.get(self, "enable_integrity_monitoring")

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

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


@pulumi.output_type
class InstanceFromTemplateAdvancedMachineFeatures(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableNestedVirtualization":
            suggest = "enable_nested_virtualization"
        elif key == "threadsPerCore":
            suggest = "threads_per_core"
        elif key == "visibleCoreCount":
            suggest = "visible_core_count"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromTemplateAdvancedMachineFeatures. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromTemplateAdvancedMachineFeatures.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromTemplateAdvancedMachineFeatures.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enable_nested_virtualization: Optional[bool] = None,
                 threads_per_core: Optional[int] = None,
                 visible_core_count: Optional[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)
        if visible_core_count is not None:
            pulumi.set(__self__, "visible_core_count", visible_core_count)

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

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

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


@pulumi.output_type
class InstanceFromTemplateAttachedDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deviceName":
            suggest = "device_name"
        elif key == "diskEncryptionKeyRaw":
            suggest = "disk_encryption_key_raw"
        elif key == "diskEncryptionKeySha256":
            suggest = "disk_encryption_key_sha256"
        elif key == "kmsKeySelfLink":
            suggest = "kms_key_self_link"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromTemplateAttachedDisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromTemplateAttachedDisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromTemplateAttachedDisk.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 source: str,
                 device_name: Optional[str] = None,
                 disk_encryption_key_raw: Optional[str] = None,
                 disk_encryption_key_sha256: Optional[str] = None,
                 kms_key_self_link: Optional[str] = None,
                 mode: Optional[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) -> str:
        return pulumi.get(self, "source")

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

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

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

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

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


@pulumi.output_type
class InstanceFromTemplateBootDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "autoDelete":
            suggest = "auto_delete"
        elif key == "deviceName":
            suggest = "device_name"
        elif key == "diskEncryptionKeyRaw":
            suggest = "disk_encryption_key_raw"
        elif key == "diskEncryptionKeySha256":
            suggest = "disk_encryption_key_sha256"
        elif key == "initializeParams":
            suggest = "initialize_params"
        elif key == "kmsKeySelfLink":
            suggest = "kms_key_self_link"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromTemplateBootDisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromTemplateBootDisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromTemplateBootDisk.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 auto_delete: Optional[bool] = None,
                 device_name: Optional[str] = None,
                 disk_encryption_key_raw: Optional[str] = None,
                 disk_encryption_key_sha256: Optional[str] = None,
                 initialize_params: Optional['outputs.InstanceFromTemplateBootDiskInitializeParams'] = None,
                 kms_key_self_link: Optional[str] = None,
                 mode: Optional[str] = None,
                 source: Optional[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[bool]:
        return pulumi.get(self, "auto_delete")

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

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

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

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

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

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

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


@pulumi.output_type
class InstanceFromTemplateBootDiskInitializeParams(dict):
    def __init__(__self__, *,
                 image: Optional[str] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 size: Optional[int] = None,
                 type: Optional[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[str]:
        return pulumi.get(self, "image")

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

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

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


@pulumi.output_type
class InstanceFromTemplateConfidentialInstanceConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableConfidentialCompute":
            suggest = "enable_confidential_compute"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromTemplateConfidentialInstanceConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromTemplateConfidentialInstanceConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromTemplateConfidentialInstanceConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enable_confidential_compute: bool):
        pulumi.set(__self__, "enable_confidential_compute", enable_confidential_compute)

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


@pulumi.output_type
class InstanceFromTemplateGuestAccelerator(dict):
    def __init__(__self__, *,
                 count: int,
                 type: str):
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "type", type)

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

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


@pulumi.output_type
class InstanceFromTemplateNetworkInterface(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessConfigs":
            suggest = "access_configs"
        elif key == "aliasIpRanges":
            suggest = "alias_ip_ranges"
        elif key == "ipv6AccessConfigs":
            suggest = "ipv6_access_configs"
        elif key == "ipv6AccessType":
            suggest = "ipv6_access_type"
        elif key == "networkIp":
            suggest = "network_ip"
        elif key == "nicType":
            suggest = "nic_type"
        elif key == "queueCount":
            suggest = "queue_count"
        elif key == "stackType":
            suggest = "stack_type"
        elif key == "subnetworkProject":
            suggest = "subnetwork_project"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromTemplateNetworkInterface. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromTemplateNetworkInterface.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromTemplateNetworkInterface.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 access_configs: Optional[Sequence['outputs.InstanceFromTemplateNetworkInterfaceAccessConfig']] = None,
                 alias_ip_ranges: Optional[Sequence['outputs.InstanceFromTemplateNetworkInterfaceAliasIpRange']] = None,
                 ipv6_access_configs: Optional[Sequence['outputs.InstanceFromTemplateNetworkInterfaceIpv6AccessConfig']] = None,
                 ipv6_access_type: Optional[str] = None,
                 name: Optional[str] = None,
                 network: Optional[str] = None,
                 network_ip: Optional[str] = None,
                 nic_type: Optional[str] = None,
                 queue_count: Optional[int] = None,
                 stack_type: Optional[str] = None,
                 subnetwork: Optional[str] = None,
                 subnetwork_project: Optional[str] = None):
        """
        :param 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[Sequence['outputs.InstanceFromTemplateNetworkInterfaceAccessConfig']]:
        return pulumi.get(self, "access_configs")

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

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

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class InstanceFromTemplateNetworkInterfaceAccessConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "natIp":
            suggest = "nat_ip"
        elif key == "networkTier":
            suggest = "network_tier"
        elif key == "publicPtrDomainName":
            suggest = "public_ptr_domain_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromTemplateNetworkInterfaceAccessConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromTemplateNetworkInterfaceAccessConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromTemplateNetworkInterfaceAccessConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 nat_ip: Optional[str] = None,
                 network_tier: Optional[str] = None,
                 public_ptr_domain_name: Optional[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[str]:
        return pulumi.get(self, "nat_ip")

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

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


@pulumi.output_type
class InstanceFromTemplateNetworkInterfaceAliasIpRange(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipCidrRange":
            suggest = "ip_cidr_range"
        elif key == "subnetworkRangeName":
            suggest = "subnetwork_range_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromTemplateNetworkInterfaceAliasIpRange. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromTemplateNetworkInterfaceAliasIpRange.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromTemplateNetworkInterfaceAliasIpRange.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ip_cidr_range: str,
                 subnetwork_range_name: Optional[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) -> str:
        return pulumi.get(self, "ip_cidr_range")

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


@pulumi.output_type
class InstanceFromTemplateNetworkInterfaceIpv6AccessConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "networkTier":
            suggest = "network_tier"
        elif key == "externalIpv6":
            suggest = "external_ipv6"
        elif key == "externalIpv6PrefixLength":
            suggest = "external_ipv6_prefix_length"
        elif key == "publicPtrDomainName":
            suggest = "public_ptr_domain_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromTemplateNetworkInterfaceIpv6AccessConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromTemplateNetworkInterfaceIpv6AccessConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromTemplateNetworkInterfaceIpv6AccessConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 network_tier: str,
                 external_ipv6: Optional[str] = None,
                 external_ipv6_prefix_length: Optional[str] = None,
                 public_ptr_domain_name: Optional[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) -> str:
        return pulumi.get(self, "network_tier")

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

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

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


@pulumi.output_type
class InstanceFromTemplateNetworkPerformanceConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "totalEgressBandwidthTier":
            suggest = "total_egress_bandwidth_tier"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromTemplateNetworkPerformanceConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromTemplateNetworkPerformanceConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromTemplateNetworkPerformanceConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 total_egress_bandwidth_tier: str):
        pulumi.set(__self__, "total_egress_bandwidth_tier", total_egress_bandwidth_tier)

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


@pulumi.output_type
class InstanceFromTemplateReservationAffinity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "specificReservation":
            suggest = "specific_reservation"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromTemplateReservationAffinity. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromTemplateReservationAffinity.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromTemplateReservationAffinity.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 type: str,
                 specific_reservation: Optional['outputs.InstanceFromTemplateReservationAffinitySpecificReservation'] = 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) -> str:
        return pulumi.get(self, "type")

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


@pulumi.output_type
class InstanceFromTemplateReservationAffinitySpecificReservation(dict):
    def __init__(__self__, *,
                 key: str,
                 values: Sequence[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "values", values)

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

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


@pulumi.output_type
class InstanceFromTemplateScheduling(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "automaticRestart":
            suggest = "automatic_restart"
        elif key == "instanceTerminationAction":
            suggest = "instance_termination_action"
        elif key == "maxRunDuration":
            suggest = "max_run_duration"
        elif key == "minNodeCpus":
            suggest = "min_node_cpus"
        elif key == "nodeAffinities":
            suggest = "node_affinities"
        elif key == "onHostMaintenance":
            suggest = "on_host_maintenance"
        elif key == "provisioningModel":
            suggest = "provisioning_model"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromTemplateScheduling. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromTemplateScheduling.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromTemplateScheduling.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 automatic_restart: Optional[bool] = None,
                 instance_termination_action: Optional[str] = None,
                 max_run_duration: Optional['outputs.InstanceFromTemplateSchedulingMaxRunDuration'] = None,
                 min_node_cpus: Optional[int] = None,
                 node_affinities: Optional[Sequence['outputs.InstanceFromTemplateSchedulingNodeAffinity']] = None,
                 on_host_maintenance: Optional[str] = None,
                 preemptible: Optional[bool] = None,
                 provisioning_model: Optional[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 max_run_duration is not None:
            pulumi.set(__self__, "max_run_duration", max_run_duration)
        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[bool]:
        return pulumi.get(self, "automatic_restart")

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

    @property
    @pulumi.getter(name="maxRunDuration")
    def max_run_duration(self) -> Optional['outputs.InstanceFromTemplateSchedulingMaxRunDuration']:
        return pulumi.get(self, "max_run_duration")

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

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

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

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

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


@pulumi.output_type
class InstanceFromTemplateSchedulingMaxRunDuration(dict):
    def __init__(__self__, *,
                 seconds: int,
                 nanos: Optional[int] = None):
        pulumi.set(__self__, "seconds", seconds)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)

    @property
    @pulumi.getter
    def seconds(self) -> int:
        return pulumi.get(self, "seconds")

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


@pulumi.output_type
class InstanceFromTemplateSchedulingNodeAffinity(dict):
    def __init__(__self__, *,
                 key: str,
                 operator: str,
                 values: Sequence[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

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

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

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


@pulumi.output_type
class InstanceFromTemplateScratchDisk(dict):
    def __init__(__self__, *,
                 interface: str):
        pulumi.set(__self__, "interface", interface)

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


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

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

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


@pulumi.output_type
class InstanceFromTemplateShieldedInstanceConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableIntegrityMonitoring":
            suggest = "enable_integrity_monitoring"
        elif key == "enableSecureBoot":
            suggest = "enable_secure_boot"
        elif key == "enableVtpm":
            suggest = "enable_vtpm"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceFromTemplateShieldedInstanceConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceFromTemplateShieldedInstanceConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceFromTemplateShieldedInstanceConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enable_integrity_monitoring: Optional[bool] = None,
                 enable_secure_boot: Optional[bool] = None,
                 enable_vtpm: Optional[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[bool]:
        return pulumi.get(self, "enable_integrity_monitoring")

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

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


@pulumi.output_type
class InstanceGroupManagerAllInstancesConfig(dict):
    def __init__(__self__, *,
                 labels: Optional[Mapping[str, str]] = None,
                 metadata: Optional[Mapping[str, str]] = None):
        """
        :param Mapping[str, str] labels: ), The label key-value pairs that you want to patch onto the instance.
        :param Mapping[str, 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[Mapping[str, str]]:
        """
        ), The label key-value pairs that you want to patch onto the instance.
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter
    def metadata(self) -> Optional[Mapping[str, 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")


@pulumi.output_type
class InstanceGroupManagerAutoHealingPolicies(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "healthCheck":
            suggest = "health_check"
        elif key == "initialDelaySec":
            suggest = "initial_delay_sec"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceGroupManagerAutoHealingPolicies. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceGroupManagerAutoHealingPolicies.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceGroupManagerAutoHealingPolicies.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 health_check: str,
                 initial_delay_sec: int):
        """
        :param str health_check: The health check resource that signals autohealing.
        :param 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) -> str:
        """
        The health check resource that signals autohealing.
        """
        return pulumi.get(self, "health_check")

    @property
    @pulumi.getter(name="initialDelaySec")
    def initial_delay_sec(self) -> 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")


@pulumi.output_type
class InstanceGroupManagerInstanceLifecyclePolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "forceUpdateOnRepair":
            suggest = "force_update_on_repair"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceGroupManagerInstanceLifecyclePolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceGroupManagerInstanceLifecyclePolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceGroupManagerInstanceLifecyclePolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 force_update_on_repair: Optional[str] = None):
        """
        :param str force_update_on_repair: ), Specifies whether to apply the group's latest configuration when repairing a VM. Valid options are: `YES`, `NO`. If `YES` and you updated the group's instance template or per-instance configurations after the VM was created, then these changes are applied when VM is repaired. If `NO` (default), then updates are applied in accordance with the group's update policy type.
        """
        if force_update_on_repair is not None:
            pulumi.set(__self__, "force_update_on_repair", force_update_on_repair)

    @property
    @pulumi.getter(name="forceUpdateOnRepair")
    def force_update_on_repair(self) -> Optional[str]:
        """
        ), Specifies whether to apply the group's latest configuration when repairing a VM. Valid options are: `YES`, `NO`. If `YES` and you updated the group's instance template or per-instance configurations after the VM was created, then these changes are applied when VM is repaired. If `NO` (default), then updates are applied in accordance with the group's update policy type.
        """
        return pulumi.get(self, "force_update_on_repair")


@pulumi.output_type
class InstanceGroupManagerNamedPort(dict):
    def __init__(__self__, *,
                 name: str,
                 port: int):
        """
        :param str name: The name of the port.
        :param int port: The port number.
               - - -
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the port.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number.
        - - -
        """
        return pulumi.get(self, "port")


@pulumi.output_type
class InstanceGroupManagerStatefulDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deviceName":
            suggest = "device_name"
        elif key == "deleteRule":
            suggest = "delete_rule"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceGroupManagerStatefulDisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceGroupManagerStatefulDisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceGroupManagerStatefulDisk.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 device_name: str,
                 delete_rule: Optional[str] = None):
        """
        :param str device_name: , The device name of the disk to be attached.
        :param 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) -> str:
        """
        , The device name of the disk to be attached.
        """
        return pulumi.get(self, "device_name")

    @property
    @pulumi.getter(name="deleteRule")
    def delete_rule(self) -> Optional[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")


@pulumi.output_type
class InstanceGroupManagerStatefulExternalIp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deleteRule":
            suggest = "delete_rule"
        elif key == "interfaceName":
            suggest = "interface_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceGroupManagerStatefulExternalIp. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceGroupManagerStatefulExternalIp.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceGroupManagerStatefulExternalIp.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 delete_rule: Optional[str] = None,
                 interface_name: Optional[str] = None):
        """
        :param str delete_rule: , A value that prescribes what should happen to the external ip when the VM instance is deleted. The available options are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`. `NEVER` - detach the ip when the VM is deleted, but do not delete the ip. `ON_PERMANENT_INSTANCE_DELETION` will delete the external ip when the VM is permanently deleted from the instance group.
        """
        if delete_rule is not None:
            pulumi.set(__self__, "delete_rule", delete_rule)
        if interface_name is not None:
            pulumi.set(__self__, "interface_name", interface_name)

    @property
    @pulumi.getter(name="deleteRule")
    def delete_rule(self) -> Optional[str]:
        """
        , A value that prescribes what should happen to the external ip when the VM instance is deleted. The available options are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`. `NEVER` - detach the ip when the VM is deleted, but do not delete the ip. `ON_PERMANENT_INSTANCE_DELETION` will delete the external ip when the VM is permanently deleted from the instance group.
        """
        return pulumi.get(self, "delete_rule")

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


@pulumi.output_type
class InstanceGroupManagerStatefulInternalIp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deleteRule":
            suggest = "delete_rule"
        elif key == "interfaceName":
            suggest = "interface_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceGroupManagerStatefulInternalIp. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceGroupManagerStatefulInternalIp.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceGroupManagerStatefulInternalIp.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 delete_rule: Optional[str] = None,
                 interface_name: Optional[str] = None):
        """
        :param str delete_rule: , A value that prescribes what should happen to the internal ip when the VM instance is deleted. The available options are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`. `NEVER` - detach the ip when the VM is deleted, but do not delete the ip. `ON_PERMANENT_INSTANCE_DELETION` will delete the internal ip when the VM is permanently deleted from the instance group.
        """
        if delete_rule is not None:
            pulumi.set(__self__, "delete_rule", delete_rule)
        if interface_name is not None:
            pulumi.set(__self__, "interface_name", interface_name)

    @property
    @pulumi.getter(name="deleteRule")
    def delete_rule(self) -> Optional[str]:
        """
        , A value that prescribes what should happen to the internal ip when the VM instance is deleted. The available options are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`. `NEVER` - detach the ip when the VM is deleted, but do not delete the ip. `ON_PERMANENT_INSTANCE_DELETION` will delete the internal ip when the VM is permanently deleted from the instance group.
        """
        return pulumi.get(self, "delete_rule")

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


@pulumi.output_type
class InstanceGroupManagerStatus(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allInstancesConfigs":
            suggest = "all_instances_configs"
        elif key == "isStable":
            suggest = "is_stable"
        elif key == "versionTargets":
            suggest = "version_targets"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceGroupManagerStatus. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceGroupManagerStatus.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceGroupManagerStatus.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 all_instances_configs: Optional[Sequence['outputs.InstanceGroupManagerStatusAllInstancesConfig']] = None,
                 is_stable: Optional[bool] = None,
                 statefuls: Optional[Sequence['outputs.InstanceGroupManagerStatusStateful']] = None,
                 version_targets: Optional[Sequence['outputs.InstanceGroupManagerStatusVersionTarget']] = None):
        """
        :param Sequence['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 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 Sequence['InstanceGroupManagerStatusStatefulArgs'] statefuls: Stateful status of the given Instance Group Manager.
        :param Sequence['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[Sequence['outputs.InstanceGroupManagerStatusAllInstancesConfig']]:
        """
        )
        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")

    @property
    @pulumi.getter(name="isStable")
    def is_stable(self) -> Optional[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")

    @property
    @pulumi.getter
    def statefuls(self) -> Optional[Sequence['outputs.InstanceGroupManagerStatusStateful']]:
        """
        Stateful status of the given Instance Group Manager.
        """
        return pulumi.get(self, "statefuls")

    @property
    @pulumi.getter(name="versionTargets")
    def version_targets(self) -> Optional[Sequence['outputs.InstanceGroupManagerStatusVersionTarget']]:
        """
        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")


@pulumi.output_type
class InstanceGroupManagerStatusAllInstancesConfig(dict):
    def __init__(__self__, *,
                 effective: Optional[bool] = None):
        if effective is not None:
            pulumi.set(__self__, "effective", effective)

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


@pulumi.output_type
class InstanceGroupManagerStatusStateful(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hasStatefulConfig":
            suggest = "has_stateful_config"
        elif key == "perInstanceConfigs":
            suggest = "per_instance_configs"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceGroupManagerStatusStateful. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceGroupManagerStatusStateful.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceGroupManagerStatusStateful.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 has_stateful_config: Optional[bool] = None,
                 per_instance_configs: Optional[Sequence['outputs.InstanceGroupManagerStatusStatefulPerInstanceConfig']] = None):
        """
        :param 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 Sequence['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[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")

    @property
    @pulumi.getter(name="perInstanceConfigs")
    def per_instance_configs(self) -> Optional[Sequence['outputs.InstanceGroupManagerStatusStatefulPerInstanceConfig']]:
        """
        Status of per-instance configs on the instance.
        """
        return pulumi.get(self, "per_instance_configs")


@pulumi.output_type
class InstanceGroupManagerStatusStatefulPerInstanceConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allEffective":
            suggest = "all_effective"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceGroupManagerStatusStatefulPerInstanceConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceGroupManagerStatusStatefulPerInstanceConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceGroupManagerStatusStatefulPerInstanceConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 all_effective: Optional[bool] = None):
        """
        :param 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[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")


@pulumi.output_type
class InstanceGroupManagerStatusVersionTarget(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isReached":
            suggest = "is_reached"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceGroupManagerStatusVersionTarget. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceGroupManagerStatusVersionTarget.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceGroupManagerStatusVersionTarget.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 is_reached: Optional[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[bool]:
        return pulumi.get(self, "is_reached")


@pulumi.output_type
class InstanceGroupManagerUpdatePolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "minimalAction":
            suggest = "minimal_action"
        elif key == "maxSurgeFixed":
            suggest = "max_surge_fixed"
        elif key == "maxSurgePercent":
            suggest = "max_surge_percent"
        elif key == "maxUnavailableFixed":
            suggest = "max_unavailable_fixed"
        elif key == "maxUnavailablePercent":
            suggest = "max_unavailable_percent"
        elif key == "minReadySec":
            suggest = "min_ready_sec"
        elif key == "mostDisruptiveAllowedAction":
            suggest = "most_disruptive_allowed_action"
        elif key == "replacementMethod":
            suggest = "replacement_method"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceGroupManagerUpdatePolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceGroupManagerUpdatePolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceGroupManagerUpdatePolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 minimal_action: str,
                 type: str,
                 max_surge_fixed: Optional[int] = None,
                 max_surge_percent: Optional[int] = None,
                 max_unavailable_fixed: Optional[int] = None,
                 max_unavailable_percent: Optional[int] = None,
                 min_ready_sec: Optional[int] = None,
                 most_disruptive_allowed_action: Optional[str] = None,
                 replacement_method: Optional[str] = None):
        """
        :param 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 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 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 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 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 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 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 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 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) -> 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")

    @property
    @pulumi.getter
    def type(self) -> 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")

    @property
    @pulumi.getter(name="maxSurgeFixed")
    def max_surge_fixed(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxSurgePercent")
    def max_surge_percent(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxUnavailableFixed")
    def max_unavailable_fixed(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxUnavailablePercent")
    def max_unavailable_percent(self) -> Optional[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")

    @property
    @pulumi.getter(name="minReadySec")
    def min_ready_sec(self) -> Optional[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")

    @property
    @pulumi.getter(name="mostDisruptiveAllowedAction")
    def most_disruptive_allowed_action(self) -> Optional[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")

    @property
    @pulumi.getter(name="replacementMethod")
    def replacement_method(self) -> Optional[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")


@pulumi.output_type
class InstanceGroupManagerVersion(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceTemplate":
            suggest = "instance_template"
        elif key == "targetSize":
            suggest = "target_size"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceGroupManagerVersion. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceGroupManagerVersion.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceGroupManagerVersion.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 instance_template: str,
                 name: Optional[str] = None,
                 target_size: Optional['outputs.InstanceGroupManagerVersionTargetSize'] = None):
        """
        :param str instance_template: The full URL to an instance template from which all new instances of this version will be created.
        :param str name: Version name.
        :param '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) -> 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")

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

    @property
    @pulumi.getter(name="targetSize")
    def target_size(self) -> Optional['outputs.InstanceGroupManagerVersionTargetSize']:
        """
        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")


@pulumi.output_type
class InstanceGroupManagerVersionTargetSize(dict):
    def __init__(__self__, *,
                 fixed: Optional[int] = None,
                 percent: Optional[int] = None):
        """
        :param int fixed: , The number of instances which are managed for this version. Conflicts with `percent`.
        :param 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[int]:
        """
        , The number of instances which are managed for this version. Conflicts with `percent`.
        """
        return pulumi.get(self, "fixed")

    @property
    @pulumi.getter
    def percent(self) -> Optional[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")


@pulumi.output_type
class InstanceGroupNamedPort(dict):
    def __init__(__self__, *,
                 name: str,
                 port: int):
        """
        :param str name: The name which the port will be mapped to.
        :param 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) -> str:
        """
        The name which the port will be mapped to.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to map the name to.
        """
        return pulumi.get(self, "port")


@pulumi.output_type
class InstanceGuestAccelerator(dict):
    def __init__(__self__, *,
                 count: int,
                 type: str):
        """
        :param int count: The number of the guest accelerator cards exposed to this instance.
        :param str type: The accelerator type resource to expose to this instance. E.g. `nvidia-tesla-k80`.
        """
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def count(self) -> int:
        """
        The number of the guest accelerator cards exposed to this instance.
        """
        return pulumi.get(self, "count")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The accelerator type resource to expose to this instance. E.g. `nvidia-tesla-k80`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class InstanceIAMBindingCondition(dict):
    def __init__(__self__, *,
                 expression: str,
                 title: str,
                 description: Optional[str] = None):
        """
        :param str expression: Textual representation of an expression in Common Expression Language syntax.
        :param str title: A title for the expression, i.e. a short string describing its purpose.
        :param 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) -> str:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[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")


@pulumi.output_type
class InstanceIAMMemberCondition(dict):
    def __init__(__self__, *,
                 expression: str,
                 title: str,
                 description: Optional[str] = None):
        """
        :param str expression: Textual representation of an expression in Common Expression Language syntax.
        :param str title: A title for the expression, i.e. a short string describing its purpose.
        :param 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) -> str:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[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")


@pulumi.output_type
class InstanceNetworkInterface(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessConfigs":
            suggest = "access_configs"
        elif key == "aliasIpRanges":
            suggest = "alias_ip_ranges"
        elif key == "ipv6AccessConfigs":
            suggest = "ipv6_access_configs"
        elif key == "ipv6AccessType":
            suggest = "ipv6_access_type"
        elif key == "networkIp":
            suggest = "network_ip"
        elif key == "nicType":
            suggest = "nic_type"
        elif key == "queueCount":
            suggest = "queue_count"
        elif key == "stackType":
            suggest = "stack_type"
        elif key == "subnetworkProject":
            suggest = "subnetwork_project"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceNetworkInterface. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceNetworkInterface.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceNetworkInterface.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 access_configs: Optional[Sequence['outputs.InstanceNetworkInterfaceAccessConfig']] = None,
                 alias_ip_ranges: Optional[Sequence['outputs.InstanceNetworkInterfaceAliasIpRange']] = None,
                 ipv6_access_configs: Optional[Sequence['outputs.InstanceNetworkInterfaceIpv6AccessConfig']] = None,
                 ipv6_access_type: Optional[str] = None,
                 name: Optional[str] = None,
                 network: Optional[str] = None,
                 network_ip: Optional[str] = None,
                 nic_type: Optional[str] = None,
                 queue_count: Optional[int] = None,
                 stack_type: Optional[str] = None,
                 subnetwork: Optional[str] = None,
                 subnetwork_project: Optional[str] = None):
        """
        :param Sequence['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 Sequence['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 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 str name: A unique name for the resource, required by GCE.
               Changing this forces a new resource to be created.
        :param 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 str network_ip: The private IP address to assign to the instance. If
               empty, the address will be automatically assigned.
        :param str nic_type: The type of vNIC to be used on this interface. Possible values: GVNIC, VIRTIO_NET.
        :param 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 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 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 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[Sequence['outputs.InstanceNetworkInterfaceAccessConfig']]:
        return pulumi.get(self, "access_configs")

    @property
    @pulumi.getter(name="aliasIpRanges")
    def alias_ip_ranges(self) -> Optional[Sequence['outputs.InstanceNetworkInterfaceAliasIpRange']]:
        """
        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")

    @property
    @pulumi.getter(name="ipv6AccessConfigs")
    def ipv6_access_configs(self) -> Optional[Sequence['outputs.InstanceNetworkInterfaceIpv6AccessConfig']]:
        """
        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")

    @property
    @pulumi.getter(name="ipv6AccessType")
    def ipv6_access_type(self) -> Optional[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")

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

    @property
    @pulumi.getter
    def network(self) -> Optional[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")

    @property
    @pulumi.getter(name="networkIp")
    def network_ip(self) -> Optional[str]:
        """
        The private IP address to assign to the instance. If
        empty, the address will be automatically assigned.
        """
        return pulumi.get(self, "network_ip")

    @property
    @pulumi.getter(name="nicType")
    def nic_type(self) -> Optional[str]:
        """
        The type of vNIC to be used on this interface. Possible values: GVNIC, VIRTIO_NET.
        """
        return pulumi.get(self, "nic_type")

    @property
    @pulumi.getter(name="queueCount")
    def queue_count(self) -> Optional[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")

    @property
    @pulumi.getter(name="stackType")
    def stack_type(self) -> Optional[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")

    @property
    @pulumi.getter
    def subnetwork(self) -> Optional[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")

    @property
    @pulumi.getter(name="subnetworkProject")
    def subnetwork_project(self) -> Optional[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")


@pulumi.output_type
class InstanceNetworkInterfaceAccessConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "natIp":
            suggest = "nat_ip"
        elif key == "networkTier":
            suggest = "network_tier"
        elif key == "publicPtrDomainName":
            suggest = "public_ptr_domain_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceNetworkInterfaceAccessConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceNetworkInterfaceAccessConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceNetworkInterfaceAccessConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 nat_ip: Optional[str] = None,
                 network_tier: Optional[str] = None,
                 public_ptr_domain_name: Optional[str] = None):
        """
        :param 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 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 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[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")

    @property
    @pulumi.getter(name="networkTier")
    def network_tier(self) -> Optional[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")

    @property
    @pulumi.getter(name="publicPtrDomainName")
    def public_ptr_domain_name(self) -> Optional[str]:
        """
        The domain name to be used when creating DNSv6
        records for the external IPv6 ranges..
        """
        return pulumi.get(self, "public_ptr_domain_name")


@pulumi.output_type
class InstanceNetworkInterfaceAliasIpRange(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipCidrRange":
            suggest = "ip_cidr_range"
        elif key == "subnetworkRangeName":
            suggest = "subnetwork_range_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceNetworkInterfaceAliasIpRange. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceNetworkInterfaceAliasIpRange.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceNetworkInterfaceAliasIpRange.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ip_cidr_range: str,
                 subnetwork_range_name: Optional[str] = None):
        """
        :param 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 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) -> 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")

    @property
    @pulumi.getter(name="subnetworkRangeName")
    def subnetwork_range_name(self) -> Optional[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")


@pulumi.output_type
class InstanceNetworkInterfaceIpv6AccessConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "networkTier":
            suggest = "network_tier"
        elif key == "externalIpv6":
            suggest = "external_ipv6"
        elif key == "externalIpv6PrefixLength":
            suggest = "external_ipv6_prefix_length"
        elif key == "publicPtrDomainName":
            suggest = "public_ptr_domain_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceNetworkInterfaceIpv6AccessConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceNetworkInterfaceIpv6AccessConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceNetworkInterfaceIpv6AccessConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 network_tier: str,
                 external_ipv6: Optional[str] = None,
                 external_ipv6_prefix_length: Optional[str] = None,
                 public_ptr_domain_name: Optional[str] = None):
        """
        :param str network_tier: The [networking tier][network-tier] used for configuring this instance.
               This field can take the following values: PREMIUM, FIXED_STANDARD or STANDARD. If this field is
               not specified, it is assumed to be PREMIUM.
               subnet has an external subnet. Only PREMIUM or STANDARD tier is valid for IPv6.
        :param str public_ptr_domain_name: The DNS domain name for the public PTR record.
               To set this field on an instance, you must be verified as the owner of the domain.
               See [the docs](https://cloud.google.com/compute/docs/instances/create-ptr-record) for how
               to become verified as a domain owner.
               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) -> str:
        """
        The [networking tier][network-tier] used for configuring this instance.
        This field can take the following values: PREMIUM, FIXED_STANDARD or STANDARD. If this field is
        not specified, it is assumed to be PREMIUM.
        subnet has an external subnet. Only PREMIUM or STANDARD tier is valid for IPv6.
        """
        return pulumi.get(self, "network_tier")

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

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

    @property
    @pulumi.getter(name="publicPtrDomainName")
    def public_ptr_domain_name(self) -> Optional[str]:
        """
        The DNS domain name for the public PTR record.
        To set this field on an instance, you must be verified as the owner of the domain.
        See [the docs](https://cloud.google.com/compute/docs/instances/create-ptr-record) for how
        to become verified as a domain owner.
        records for the external IPv6 ranges..
        """
        return pulumi.get(self, "public_ptr_domain_name")


@pulumi.output_type
class InstanceNetworkPerformanceConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "totalEgressBandwidthTier":
            suggest = "total_egress_bandwidth_tier"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceNetworkPerformanceConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceNetworkPerformanceConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceNetworkPerformanceConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 total_egress_bandwidth_tier: str):
        """
        :param 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) -> str:
        """
        The egress bandwidth tier to enable.
        Possible values: TIER_1, DEFAULT
        """
        return pulumi.get(self, "total_egress_bandwidth_tier")


@pulumi.output_type
class InstanceReservationAffinity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "specificReservation":
            suggest = "specific_reservation"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceReservationAffinity. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceReservationAffinity.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceReservationAffinity.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 type: str,
                 specific_reservation: Optional['outputs.InstanceReservationAffinitySpecificReservation'] = None):
        """
        :param str type: The type of reservation from which this instance can consume resources.
        :param '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) -> str:
        """
        The type of reservation from which this instance can consume resources.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="specificReservation")
    def specific_reservation(self) -> Optional['outputs.InstanceReservationAffinitySpecificReservation']:
        """
        Specifies the label selector for the reservation to use..
        Structure is documented below.
        """
        return pulumi.get(self, "specific_reservation")


@pulumi.output_type
class InstanceReservationAffinitySpecificReservation(dict):
    def __init__(__self__, *,
                 key: str,
                 values: Sequence[str]):
        """
        :param 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 Sequence[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) -> 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")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        Corresponds to the label values of a reservation resource.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class InstanceScheduling(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "automaticRestart":
            suggest = "automatic_restart"
        elif key == "instanceTerminationAction":
            suggest = "instance_termination_action"
        elif key == "maxRunDuration":
            suggest = "max_run_duration"
        elif key == "minNodeCpus":
            suggest = "min_node_cpus"
        elif key == "nodeAffinities":
            suggest = "node_affinities"
        elif key == "onHostMaintenance":
            suggest = "on_host_maintenance"
        elif key == "provisioningModel":
            suggest = "provisioning_model"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceScheduling. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceScheduling.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceScheduling.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 automatic_restart: Optional[bool] = None,
                 instance_termination_action: Optional[str] = None,
                 max_run_duration: Optional['outputs.InstanceSchedulingMaxRunDuration'] = None,
                 min_node_cpus: Optional[int] = None,
                 node_affinities: Optional[Sequence['outputs.InstanceSchedulingNodeAffinity']] = None,
                 on_host_maintenance: Optional[str] = None,
                 preemptible: Optional[bool] = None,
                 provisioning_model: Optional[str] = None):
        """
        :param bool automatic_restart: Specifies if the instance should be
               restarted if it was terminated by Compute Engine (not a user).
               Defaults to true.
        :param str instance_termination_action: Describe the type of termination action for VM. Can be `STOP` or `DELETE`.  Read more on [here](https://cloud.google.com/compute/docs/instances/create-use-spot)
        :param int min_node_cpus: The minimum number of virtual CPUs this instance will consume when running on a sole-tenant node.
        :param Sequence['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 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 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 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 max_run_duration is not None:
            pulumi.set(__self__, "max_run_duration", max_run_duration)
        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[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")

    @property
    @pulumi.getter(name="instanceTerminationAction")
    def instance_termination_action(self) -> Optional[str]:
        """
        Describe the type of termination action for 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")

    @property
    @pulumi.getter(name="maxRunDuration")
    def max_run_duration(self) -> Optional['outputs.InstanceSchedulingMaxRunDuration']:
        return pulumi.get(self, "max_run_duration")

    @property
    @pulumi.getter(name="minNodeCpus")
    def min_node_cpus(self) -> Optional[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")

    @property
    @pulumi.getter(name="nodeAffinities")
    def node_affinities(self) -> Optional[Sequence['outputs.InstanceSchedulingNodeAffinity']]:
        """
        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")

    @property
    @pulumi.getter(name="onHostMaintenance")
    def on_host_maintenance(self) -> Optional[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")

    @property
    @pulumi.getter
    def preemptible(self) -> Optional[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")

    @property
    @pulumi.getter(name="provisioningModel")
    def provisioning_model(self) -> Optional[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")


@pulumi.output_type
class InstanceSchedulingMaxRunDuration(dict):
    def __init__(__self__, *,
                 seconds: int,
                 nanos: Optional[int] = None):
        """
        :param int 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 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) -> int:
        """
        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")

    @property
    @pulumi.getter
    def nanos(self) -> Optional[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")


@pulumi.output_type
class InstanceSchedulingNodeAffinity(dict):
    def __init__(__self__, *,
                 key: str,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str key: The key for the node affinity label.
        :param str operator: The operator. Can be `IN` for node-affinities
               or `NOT_IN` for anti-affinities.
        :param Sequence[str] values: The values for the node affinity label.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The key for the node affinity label.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The operator. Can be `IN` for node-affinities
        or `NOT_IN` for anti-affinities.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        The values for the node affinity label.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class InstanceScratchDisk(dict):
    def __init__(__self__, *,
                 interface: str):
        """
        :param 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) -> str:
        """
        The disk interface to use for attaching this disk; either SCSI or NVME.
        """
        return pulumi.get(self, "interface")


@pulumi.output_type
class InstanceServiceAccount(dict):
    def __init__(__self__, *,
                 scopes: Sequence[str],
                 email: Optional[str] = None):
        """
        :param Sequence[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 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) -> Sequence[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")

    @property
    @pulumi.getter
    def email(self) -> Optional[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")


@pulumi.output_type
class InstanceShieldedInstanceConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableIntegrityMonitoring":
            suggest = "enable_integrity_monitoring"
        elif key == "enableSecureBoot":
            suggest = "enable_secure_boot"
        elif key == "enableVtpm":
            suggest = "enable_vtpm"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceShieldedInstanceConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceShieldedInstanceConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceShieldedInstanceConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enable_integrity_monitoring: Optional[bool] = None,
                 enable_secure_boot: Optional[bool] = None,
                 enable_vtpm: Optional[bool] = None):
        """
        :param 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 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 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[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")

    @property
    @pulumi.getter(name="enableSecureBoot")
    def enable_secure_boot(self) -> Optional[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")

    @property
    @pulumi.getter(name="enableVtpm")
    def enable_vtpm(self) -> Optional[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")


@pulumi.output_type
class InstanceTemplateAdvancedMachineFeatures(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableNestedVirtualization":
            suggest = "enable_nested_virtualization"
        elif key == "threadsPerCore":
            suggest = "threads_per_core"
        elif key == "visibleCoreCount":
            suggest = "visible_core_count"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceTemplateAdvancedMachineFeatures. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceTemplateAdvancedMachineFeatures.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceTemplateAdvancedMachineFeatures.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enable_nested_virtualization: Optional[bool] = None,
                 threads_per_core: Optional[int] = None,
                 visible_core_count: Optional[int] = None):
        """
        :param bool enable_nested_virtualization: Defines whether the instance should have nested virtualization enabled. Defaults to false.
        :param int threads_per_core: The number of threads per physical core. To disable [simultaneous multithreading (SMT)](https://cloud.google.com/compute/docs/instances/disabling-smt) set this to 1.
        :param int visible_core_count: ) The number of physical cores to expose to an instance. [visible cores info (VC)](https://cloud.google.com/compute/docs/instances/customize-visible-cores).
        """
        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)
        if visible_core_count is not None:
            pulumi.set(__self__, "visible_core_count", visible_core_count)

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

    @property
    @pulumi.getter(name="threadsPerCore")
    def threads_per_core(self) -> Optional[int]:
        """
        The 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")

    @property
    @pulumi.getter(name="visibleCoreCount")
    def visible_core_count(self) -> Optional[int]:
        """
        ) The number of physical cores to expose to an instance. [visible cores info (VC)](https://cloud.google.com/compute/docs/instances/customize-visible-cores).
        """
        return pulumi.get(self, "visible_core_count")


@pulumi.output_type
class InstanceTemplateConfidentialInstanceConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableConfidentialCompute":
            suggest = "enable_confidential_compute"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceTemplateConfidentialInstanceConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceTemplateConfidentialInstanceConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceTemplateConfidentialInstanceConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enable_confidential_compute: bool):
        """
        :param 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) -> 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")


@pulumi.output_type
class InstanceTemplateDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "autoDelete":
            suggest = "auto_delete"
        elif key == "deviceName":
            suggest = "device_name"
        elif key == "diskEncryptionKey":
            suggest = "disk_encryption_key"
        elif key == "diskName":
            suggest = "disk_name"
        elif key == "diskSizeGb":
            suggest = "disk_size_gb"
        elif key == "diskType":
            suggest = "disk_type"
        elif key == "resourcePolicies":
            suggest = "resource_policies"
        elif key == "sourceImage":
            suggest = "source_image"
        elif key == "sourceImageEncryptionKey":
            suggest = "source_image_encryption_key"
        elif key == "sourceSnapshot":
            suggest = "source_snapshot"
        elif key == "sourceSnapshotEncryptionKey":
            suggest = "source_snapshot_encryption_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceTemplateDisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceTemplateDisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceTemplateDisk.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 auto_delete: Optional[bool] = None,
                 boot: Optional[bool] = None,
                 device_name: Optional[str] = None,
                 disk_encryption_key: Optional['outputs.InstanceTemplateDiskDiskEncryptionKey'] = None,
                 disk_name: Optional[str] = None,
                 disk_size_gb: Optional[int] = None,
                 disk_type: Optional[str] = None,
                 interface: Optional[str] = None,
                 labels: Optional[Mapping[str, str]] = None,
                 mode: Optional[str] = None,
                 resource_policies: Optional[str] = None,
                 source: Optional[str] = None,
                 source_image: Optional[str] = None,
                 source_image_encryption_key: Optional['outputs.InstanceTemplateDiskSourceImageEncryptionKey'] = None,
                 source_snapshot: Optional[str] = None,
                 source_snapshot_encryption_key: Optional['outputs.InstanceTemplateDiskSourceSnapshotEncryptionKey'] = None,
                 type: Optional[str] = None):
        """
        :param bool auto_delete: Whether or not the disk should be auto-deleted.
               This defaults to true.
        :param bool boot: Indicates that this is a boot disk.
        :param 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 'InstanceTemplateDiskDiskEncryptionKeyArgs' disk_encryption_key: Encrypts or decrypts a disk using a customer-supplied encryption key.
        :param str disk_name: Name of the disk. When not provided, this defaults
               to the name of the instance.
        :param 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 str disk_type: The GCE disk type. Such as `"pd-ssd"`, `"local-ssd"`,
               `"pd-balanced"` or `"pd-standard"`.
        :param 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 Mapping[str, str] labels: A set of ket/value label pairs to assign to disk created from
               this template
        :param 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 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 str source: The name (**not self_link**)
               of the disk (such as those managed by `compute.Disk`) to attach.
               > **Note:** Either `source`, `source_image`, or `source_snapshot` 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 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`, `source_image`, or `source_snapshot` 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 'InstanceTemplateDiskSourceImageEncryptionKeyArgs' source_image_encryption_key: The customer-supplied encryption
               key of the source image. Required if the source image is protected by a
               customer-supplied encryption key.
        :param str source_snapshot: The source snapshot to create this disk.
               > **Note:** Either `source`, `source_image`, or `source_snapshot` 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 'InstanceTemplateDiskSourceSnapshotEncryptionKeyArgs' source_snapshot_encryption_key: The customer-supplied encryption
               key of the source snapshot. Structure
               documented below.
        :param str type: The type of GCE disk, can be either `"SCRATCH"` or
               `"PERSISTENT"`.
        """
        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 source_image_encryption_key is not None:
            pulumi.set(__self__, "source_image_encryption_key", source_image_encryption_key)
        if source_snapshot is not None:
            pulumi.set(__self__, "source_snapshot", source_snapshot)
        if source_snapshot_encryption_key is not None:
            pulumi.set(__self__, "source_snapshot_encryption_key", source_snapshot_encryption_key)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="autoDelete")
    def auto_delete(self) -> Optional[bool]:
        """
        Whether or not the disk should be auto-deleted.
        This defaults to true.
        """
        return pulumi.get(self, "auto_delete")

    @property
    @pulumi.getter
    def boot(self) -> Optional[bool]:
        """
        Indicates that this is a boot disk.
        """
        return pulumi.get(self, "boot")

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> Optional[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")

    @property
    @pulumi.getter(name="diskEncryptionKey")
    def disk_encryption_key(self) -> Optional['outputs.InstanceTemplateDiskDiskEncryptionKey']:
        """
        Encrypts or decrypts a disk using a customer-supplied encryption key.
        """
        return pulumi.get(self, "disk_encryption_key")

    @property
    @pulumi.getter(name="diskName")
    def disk_name(self) -> Optional[str]:
        """
        Name of the disk. When not provided, this defaults
        to the name of the instance.
        """
        return pulumi.get(self, "disk_name")

    @property
    @pulumi.getter(name="diskSizeGb")
    def disk_size_gb(self) -> Optional[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")

    @property
    @pulumi.getter(name="diskType")
    def disk_type(self) -> Optional[str]:
        """
        The GCE disk type. Such as `"pd-ssd"`, `"local-ssd"`,
        `"pd-balanced"` or `"pd-standard"`.
        """
        return pulumi.get(self, "disk_type")

    @property
    @pulumi.getter
    def interface(self) -> Optional[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")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, str]]:
        """
        A set of ket/value label pairs to assign to disk created from
        this template
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter
    def mode(self) -> Optional[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")

    @property
    @pulumi.getter(name="resourcePolicies")
    def resource_policies(self) -> Optional[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")

    @property
    @pulumi.getter
    def source(self) -> Optional[str]:
        """
        The name (**not self_link**)
        of the disk (such as those managed by `compute.Disk`) to attach.
        > **Note:** Either `source`, `source_image`, or `source_snapshot` 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")

    @property
    @pulumi.getter(name="sourceImage")
    def source_image(self) -> Optional[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`, `source_image`, or `source_snapshot` 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")

    @property
    @pulumi.getter(name="sourceImageEncryptionKey")
    def source_image_encryption_key(self) -> Optional['outputs.InstanceTemplateDiskSourceImageEncryptionKey']:
        """
        The customer-supplied encryption
        key of the source image. Required if the source image is protected by a
        customer-supplied encryption key.
        """
        return pulumi.get(self, "source_image_encryption_key")

    @property
    @pulumi.getter(name="sourceSnapshot")
    def source_snapshot(self) -> Optional[str]:
        """
        The source snapshot to create this disk.
        > **Note:** Either `source`, `source_image`, or `source_snapshot` 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_snapshot")

    @property
    @pulumi.getter(name="sourceSnapshotEncryptionKey")
    def source_snapshot_encryption_key(self) -> Optional['outputs.InstanceTemplateDiskSourceSnapshotEncryptionKey']:
        """
        The customer-supplied encryption
        key of the source snapshot. Structure
        documented below.
        """
        return pulumi.get(self, "source_snapshot_encryption_key")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        The type of GCE disk, can be either `"SCRATCH"` or
        `"PERSISTENT"`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class InstanceTemplateDiskDiskEncryptionKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kmsKeySelfLink":
            suggest = "kms_key_self_link"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceTemplateDiskDiskEncryptionKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceTemplateDiskDiskEncryptionKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceTemplateDiskDiskEncryptionKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kms_key_self_link: str):
        """
        :param 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) -> str:
        """
        The self link of the encryption key that is stored in Google Cloud KMS
        """
        return pulumi.get(self, "kms_key_self_link")


@pulumi.output_type
class InstanceTemplateDiskSourceImageEncryptionKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kmsKeySelfLink":
            suggest = "kms_key_self_link"
        elif key == "kmsKeyServiceAccount":
            suggest = "kms_key_service_account"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceTemplateDiskSourceImageEncryptionKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceTemplateDiskSourceImageEncryptionKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceTemplateDiskSourceImageEncryptionKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kms_key_self_link: str,
                 kms_key_service_account: Optional[str] = None):
        """
        :param str kms_key_self_link: The self link of the encryption key that is
               stored in Google Cloud KMS.
        :param str kms_key_service_account: The service account being used for the
               encryption request for the given KMS key. If absent, the Compute Engine
               default service account is used.
        """
        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)

    @property
    @pulumi.getter(name="kmsKeySelfLink")
    def kms_key_self_link(self) -> str:
        """
        The self link of the encryption key that is
        stored in Google Cloud KMS.
        """
        return pulumi.get(self, "kms_key_self_link")

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


@pulumi.output_type
class InstanceTemplateDiskSourceSnapshotEncryptionKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kmsKeySelfLink":
            suggest = "kms_key_self_link"
        elif key == "kmsKeyServiceAccount":
            suggest = "kms_key_service_account"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceTemplateDiskSourceSnapshotEncryptionKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceTemplateDiskSourceSnapshotEncryptionKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceTemplateDiskSourceSnapshotEncryptionKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kms_key_self_link: str,
                 kms_key_service_account: Optional[str] = None):
        """
        :param str kms_key_self_link: The self link of the encryption key that is
               stored in Google Cloud KMS.
        :param str kms_key_service_account: The service account being used for the
               encryption request for the given KMS key. If absent, the Compute Engine
               default service account is used.
        """
        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)

    @property
    @pulumi.getter(name="kmsKeySelfLink")
    def kms_key_self_link(self) -> str:
        """
        The self link of the encryption key that is
        stored in Google Cloud KMS.
        """
        return pulumi.get(self, "kms_key_self_link")

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


@pulumi.output_type
class InstanceTemplateGuestAccelerator(dict):
    def __init__(__self__, *,
                 count: int,
                 type: str):
        """
        :param int count: The number of the guest accelerator cards exposed to this instance.
        :param str type: The accelerator type resource to expose to this instance. E.g. `nvidia-tesla-k80`.
        """
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def count(self) -> int:
        """
        The number of the guest accelerator cards exposed to this instance.
        """
        return pulumi.get(self, "count")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The accelerator type resource to expose to this instance. E.g. `nvidia-tesla-k80`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class InstanceTemplateNetworkInterface(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessConfigs":
            suggest = "access_configs"
        elif key == "aliasIpRanges":
            suggest = "alias_ip_ranges"
        elif key == "ipv6AccessConfigs":
            suggest = "ipv6_access_configs"
        elif key == "ipv6AccessType":
            suggest = "ipv6_access_type"
        elif key == "networkIp":
            suggest = "network_ip"
        elif key == "nicType":
            suggest = "nic_type"
        elif key == "queueCount":
            suggest = "queue_count"
        elif key == "stackType":
            suggest = "stack_type"
        elif key == "subnetworkProject":
            suggest = "subnetwork_project"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceTemplateNetworkInterface. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceTemplateNetworkInterface.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceTemplateNetworkInterface.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 access_configs: Optional[Sequence['outputs.InstanceTemplateNetworkInterfaceAccessConfig']] = None,
                 alias_ip_ranges: Optional[Sequence['outputs.InstanceTemplateNetworkInterfaceAliasIpRange']] = None,
                 ipv6_access_configs: Optional[Sequence['outputs.InstanceTemplateNetworkInterfaceIpv6AccessConfig']] = None,
                 ipv6_access_type: Optional[str] = None,
                 name: Optional[str] = None,
                 network: Optional[str] = None,
                 network_ip: Optional[str] = None,
                 nic_type: Optional[str] = None,
                 queue_count: Optional[int] = None,
                 stack_type: Optional[str] = None,
                 subnetwork: Optional[str] = None,
                 subnetwork_project: Optional[str] = None):
        """
        :param Sequence['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 Sequence['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 Sequence['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 str name: The name of the instance template. If you leave
               this blank, the provider will auto-generate a unique name.
        :param 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 str network_ip: The private IP address to assign to the instance. If
               empty, the address will be automatically assigned.
        :param str nic_type: The type of vNIC to be used on this interface. Possible values: GVNIC, VIRTIO_NET.
        :param 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 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 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 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[Sequence['outputs.InstanceTemplateNetworkInterfaceAccessConfig']]:
        """
        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")

    @property
    @pulumi.getter(name="aliasIpRanges")
    def alias_ip_ranges(self) -> Optional[Sequence['outputs.InstanceTemplateNetworkInterfaceAliasIpRange']]:
        """
        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")

    @property
    @pulumi.getter(name="ipv6AccessConfigs")
    def ipv6_access_configs(self) -> Optional[Sequence['outputs.InstanceTemplateNetworkInterfaceIpv6AccessConfig']]:
        """
        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")

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

    @property
    @pulumi.getter
    def name(self) -> Optional[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")

    @property
    @pulumi.getter
    def network(self) -> Optional[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")

    @property
    @pulumi.getter(name="networkIp")
    def network_ip(self) -> Optional[str]:
        """
        The private IP address to assign to the instance. If
        empty, the address will be automatically assigned.
        """
        return pulumi.get(self, "network_ip")

    @property
    @pulumi.getter(name="nicType")
    def nic_type(self) -> Optional[str]:
        """
        The type of vNIC to be used on this interface. Possible values: GVNIC, VIRTIO_NET.
        """
        return pulumi.get(self, "nic_type")

    @property
    @pulumi.getter(name="queueCount")
    def queue_count(self) -> Optional[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")

    @property
    @pulumi.getter(name="stackType")
    def stack_type(self) -> Optional[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")

    @property
    @pulumi.getter
    def subnetwork(self) -> Optional[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")

    @property
    @pulumi.getter(name="subnetworkProject")
    def subnetwork_project(self) -> Optional[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")


@pulumi.output_type
class InstanceTemplateNetworkInterfaceAccessConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "natIp":
            suggest = "nat_ip"
        elif key == "networkTier":
            suggest = "network_tier"
        elif key == "publicPtrDomainName":
            suggest = "public_ptr_domain_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceTemplateNetworkInterfaceAccessConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceTemplateNetworkInterfaceAccessConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceTemplateNetworkInterfaceAccessConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 nat_ip: Optional[str] = None,
                 network_tier: Optional[str] = None,
                 public_ptr_domain_name: Optional[str] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter(name="networkTier")
    def network_tier(self) -> Optional[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")

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


@pulumi.output_type
class InstanceTemplateNetworkInterfaceAliasIpRange(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipCidrRange":
            suggest = "ip_cidr_range"
        elif key == "subnetworkRangeName":
            suggest = "subnetwork_range_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceTemplateNetworkInterfaceAliasIpRange. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceTemplateNetworkInterfaceAliasIpRange.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceTemplateNetworkInterfaceAliasIpRange.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ip_cidr_range: str,
                 subnetwork_range_name: Optional[str] = None):
        """
        :param 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 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) -> 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")

    @property
    @pulumi.getter(name="subnetworkRangeName")
    def subnetwork_range_name(self) -> Optional[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")


@pulumi.output_type
class InstanceTemplateNetworkInterfaceIpv6AccessConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "networkTier":
            suggest = "network_tier"
        elif key == "externalIpv6":
            suggest = "external_ipv6"
        elif key == "externalIpv6PrefixLength":
            suggest = "external_ipv6_prefix_length"
        elif key == "publicPtrDomainName":
            suggest = "public_ptr_domain_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceTemplateNetworkInterfaceIpv6AccessConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceTemplateNetworkInterfaceIpv6AccessConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceTemplateNetworkInterfaceIpv6AccessConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 network_tier: str,
                 external_ipv6: Optional[str] = None,
                 external_ipv6_prefix_length: Optional[str] = None,
                 public_ptr_domain_name: Optional[str] = None):
        """
        :param str network_tier: The [networking tier][network-tier] used for configuring
               this instance template. This field can take the following values: PREMIUM,
               STANDARD or FIXED_STANDARD. If this field is not specified, it is assumed to be PREMIUM.
               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) -> str:
        """
        The [networking tier][network-tier] used for configuring
        this instance template. This field can take the following values: PREMIUM,
        STANDARD or FIXED_STANDARD. If this field is not specified, it is assumed to be PREMIUM.
        subnet has an external subnet. Only PREMIUM and STANDARD tier is valid for IPv6.
        """
        return pulumi.get(self, "network_tier")

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

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

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


@pulumi.output_type
class InstanceTemplateNetworkPerformanceConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "totalEgressBandwidthTier":
            suggest = "total_egress_bandwidth_tier"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceTemplateNetworkPerformanceConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceTemplateNetworkPerformanceConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceTemplateNetworkPerformanceConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 total_egress_bandwidth_tier: str):
        """
        :param 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) -> str:
        """
        The egress bandwidth tier to enable. Possible values: TIER_1, DEFAULT
        """
        return pulumi.get(self, "total_egress_bandwidth_tier")


@pulumi.output_type
class InstanceTemplateReservationAffinity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "specificReservation":
            suggest = "specific_reservation"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceTemplateReservationAffinity. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceTemplateReservationAffinity.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceTemplateReservationAffinity.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 type: str,
                 specific_reservation: Optional['outputs.InstanceTemplateReservationAffinitySpecificReservation'] = None):
        """
        :param str type: The type of reservation from which this instance can consume resources.
        :param '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) -> str:
        """
        The type of reservation from which this instance can consume resources.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="specificReservation")
    def specific_reservation(self) -> Optional['outputs.InstanceTemplateReservationAffinitySpecificReservation']:
        """
        Specifies the label selector for the reservation to use..
        Structure is documented below.
        """
        return pulumi.get(self, "specific_reservation")


@pulumi.output_type
class InstanceTemplateReservationAffinitySpecificReservation(dict):
    def __init__(__self__, *,
                 key: str,
                 values: Sequence[str]):
        """
        :param 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 Sequence[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) -> 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")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        Corresponds to the label values of a reservation resource.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class InstanceTemplateScheduling(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "automaticRestart":
            suggest = "automatic_restart"
        elif key == "instanceTerminationAction":
            suggest = "instance_termination_action"
        elif key == "maxRunDuration":
            suggest = "max_run_duration"
        elif key == "minNodeCpus":
            suggest = "min_node_cpus"
        elif key == "nodeAffinities":
            suggest = "node_affinities"
        elif key == "onHostMaintenance":
            suggest = "on_host_maintenance"
        elif key == "provisioningModel":
            suggest = "provisioning_model"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceTemplateScheduling. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceTemplateScheduling.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceTemplateScheduling.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 automatic_restart: Optional[bool] = None,
                 instance_termination_action: Optional[str] = None,
                 max_run_duration: Optional['outputs.InstanceTemplateSchedulingMaxRunDuration'] = None,
                 min_node_cpus: Optional[int] = None,
                 node_affinities: Optional[Sequence['outputs.InstanceTemplateSchedulingNodeAffinity']] = None,
                 on_host_maintenance: Optional[str] = None,
                 preemptible: Optional[bool] = None,
                 provisioning_model: Optional[str] = None):
        """
        :param 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 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 'InstanceTemplateSchedulingMaxRunDurationArgs' max_run_duration: Beta - The duration of the instance. Instance will run and be terminated after then, the termination action could be defined in `instance_termination_action`. Only support `DELETE` `instance_termination_action` at this point. Structure is documented below.
        :param Sequence['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 str on_host_maintenance: Defines the maintenance behavior for this
               instance.
        :param 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 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 max_run_duration is not None:
            pulumi.set(__self__, "max_run_duration", max_run_duration)
        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[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")

    @property
    @pulumi.getter(name="instanceTerminationAction")
    def instance_termination_action(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxRunDuration")
    def max_run_duration(self) -> Optional['outputs.InstanceTemplateSchedulingMaxRunDuration']:
        """
        Beta - The duration of the instance. Instance will run and be terminated after then, the termination action could be defined in `instance_termination_action`. Only support `DELETE` `instance_termination_action` at this point. Structure is documented below.
        """
        return pulumi.get(self, "max_run_duration")

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

    @property
    @pulumi.getter(name="nodeAffinities")
    def node_affinities(self) -> Optional[Sequence['outputs.InstanceTemplateSchedulingNodeAffinity']]:
        """
        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")

    @property
    @pulumi.getter(name="onHostMaintenance")
    def on_host_maintenance(self) -> Optional[str]:
        """
        Defines the maintenance behavior for this
        instance.
        """
        return pulumi.get(self, "on_host_maintenance")

    @property
    @pulumi.getter
    def preemptible(self) -> Optional[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")

    @property
    @pulumi.getter(name="provisioningModel")
    def provisioning_model(self) -> Optional[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")


@pulumi.output_type
class InstanceTemplateSchedulingMaxRunDuration(dict):
    def __init__(__self__, *,
                 seconds: int,
                 nanos: Optional[int] = None):
        """
        :param int 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 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) -> int:
        """
        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")

    @property
    @pulumi.getter
    def nanos(self) -> Optional[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")


@pulumi.output_type
class InstanceTemplateSchedulingNodeAffinity(dict):
    def __init__(__self__, *,
                 key: str,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str key: The key for the node affinity label.
        :param str operator: The operator. Can be `IN` for node-affinities
               or `NOT_IN` for anti-affinities.
        :param Sequence[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) -> str:
        """
        The key for the node affinity label.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The operator. Can be `IN` for node-affinities
        or `NOT_IN` for anti-affinities.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        Corresponds to the label values of a reservation resource.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class InstanceTemplateServiceAccount(dict):
    def __init__(__self__, *,
                 scopes: Sequence[str],
                 email: Optional[str] = None):
        """
        :param Sequence[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 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) -> Sequence[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")

    @property
    @pulumi.getter
    def email(self) -> Optional[str]:
        """
        The service account e-mail address. If not given, the
        default Google Compute Engine service account is used.
        """
        return pulumi.get(self, "email")


@pulumi.output_type
class InstanceTemplateShieldedInstanceConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableIntegrityMonitoring":
            suggest = "enable_integrity_monitoring"
        elif key == "enableSecureBoot":
            suggest = "enable_secure_boot"
        elif key == "enableVtpm":
            suggest = "enable_vtpm"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceTemplateShieldedInstanceConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceTemplateShieldedInstanceConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceTemplateShieldedInstanceConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enable_integrity_monitoring: Optional[bool] = None,
                 enable_secure_boot: Optional[bool] = None,
                 enable_vtpm: Optional[bool] = None):
        """
        :param 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 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 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[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")

    @property
    @pulumi.getter(name="enableSecureBoot")
    def enable_secure_boot(self) -> Optional[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")

    @property
    @pulumi.getter(name="enableVtpm")
    def enable_vtpm(self) -> Optional[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")


@pulumi.output_type
class InterconnectAttachmentPrivateInterconnectInfo(dict):
    def __init__(__self__, *,
                 tag8021q: Optional[int] = None):
        """
        :param int tag8021q: 802.1q encapsulation tag to be used for traffic between
               Google and the customer, going to and from this network and region.
        """
        if tag8021q is not None:
            pulumi.set(__self__, "tag8021q", tag8021q)

    @property
    @pulumi.getter
    def tag8021q(self) -> Optional[int]:
        """
        802.1q encapsulation tag to be used for traffic between
        Google and the customer, going to and from this network and region.
        """
        return pulumi.get(self, "tag8021q")


@pulumi.output_type
class MachineImageIamBindingCondition(dict):
    def __init__(__self__, *,
                 expression: str,
                 title: str,
                 description: Optional[str] = None):
        """
        :param str expression: Textual representation of an expression in Common Expression Language syntax.
        :param str title: A title for the expression, i.e. a short string describing its purpose.
        :param 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) -> str:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[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")


@pulumi.output_type
class MachineImageIamMemberCondition(dict):
    def __init__(__self__, *,
                 expression: str,
                 title: str,
                 description: Optional[str] = None):
        """
        :param str expression: Textual representation of an expression in Common Expression Language syntax.
        :param str title: A title for the expression, i.e. a short string describing its purpose.
        :param 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) -> str:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[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")


@pulumi.output_type
class MachineImageMachineImageEncryptionKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kmsKeyName":
            suggest = "kms_key_name"
        elif key == "kmsKeyServiceAccount":
            suggest = "kms_key_service_account"
        elif key == "rawKey":
            suggest = "raw_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MachineImageMachineImageEncryptionKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MachineImageMachineImageEncryptionKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MachineImageMachineImageEncryptionKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kms_key_name: Optional[str] = None,
                 kms_key_service_account: Optional[str] = None,
                 raw_key: Optional[str] = None,
                 sha256: Optional[str] = None):
        """
        :param str kms_key_name: The name of the encryption key that is stored in Google Cloud KMS.
        :param 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 str raw_key: Specifies a 256-bit customer-supplied encryption key, encoded in
               RFC 4648 base64 to either encrypt or decrypt this resource.
        :param 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[str]:
        """
        The name of the encryption key that is stored in Google Cloud KMS.
        """
        return pulumi.get(self, "kms_key_name")

    @property
    @pulumi.getter(name="kmsKeyServiceAccount")
    def kms_key_service_account(self) -> Optional[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")

    @property
    @pulumi.getter(name="rawKey")
    def raw_key(self) -> Optional[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")

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


@pulumi.output_type
class ManagedSslCertificateManaged(dict):
    def __init__(__self__, *,
                 domains: Sequence[str]):
        """
        :param Sequence[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) -> Sequence[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")


@pulumi.output_type
class MangedSslCertificateManaged(dict):
    def __init__(__self__, *,
                 domains: Sequence[str]):
        """
        :param Sequence[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) -> Sequence[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")


@pulumi.output_type
class NetworkFirewallPolicyRuleMatch(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "layer4Configs":
            suggest = "layer4_configs"
        elif key == "destIpRanges":
            suggest = "dest_ip_ranges"
        elif key == "srcIpRanges":
            suggest = "src_ip_ranges"
        elif key == "srcSecureTags":
            suggest = "src_secure_tags"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NetworkFirewallPolicyRuleMatch. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NetworkFirewallPolicyRuleMatch.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NetworkFirewallPolicyRuleMatch.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 layer4_configs: Sequence['outputs.NetworkFirewallPolicyRuleMatchLayer4Config'],
                 dest_ip_ranges: Optional[Sequence[str]] = None,
                 src_ip_ranges: Optional[Sequence[str]] = None,
                 src_secure_tags: Optional[Sequence['outputs.NetworkFirewallPolicyRuleMatchSrcSecureTag']] = None):
        """
        :param Sequence['NetworkFirewallPolicyRuleMatchLayer4ConfigArgs'] layer4_configs: Pairs of IP protocols and ports that the rule should match.
        :param Sequence[str] dest_ip_ranges: CIDR IP address range. Maximum number of destination CIDR IP ranges allowed is 5000.
        :param Sequence[str] src_ip_ranges: CIDR IP address range. Maximum number of source CIDR IP ranges allowed is 5000.
        :param Sequence['NetworkFirewallPolicyRuleMatchSrcSecureTagArgs'] src_secure_tags: List of secure tag values, which should be matched at the source of the traffic. For INGRESS rule, if all the <code>srcSecureTag</code> are INEFFECTIVE, and there is no <code>srcIpRange</code>, this rule will be ignored. Maximum number of source tag values 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)
        if src_secure_tags is not None:
            pulumi.set(__self__, "src_secure_tags", src_secure_tags)

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

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

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

    @property
    @pulumi.getter(name="srcSecureTags")
    def src_secure_tags(self) -> Optional[Sequence['outputs.NetworkFirewallPolicyRuleMatchSrcSecureTag']]:
        """
        List of secure tag values, which should be matched at the source of the traffic. For INGRESS rule, if all the <code>srcSecureTag</code> are INEFFECTIVE, and there is no <code>srcIpRange</code>, this rule will be ignored. Maximum number of source tag values allowed is 256.
        """
        return pulumi.get(self, "src_secure_tags")


@pulumi.output_type
class NetworkFirewallPolicyRuleMatchLayer4Config(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipProtocol":
            suggest = "ip_protocol"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NetworkFirewallPolicyRuleMatchLayer4Config. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NetworkFirewallPolicyRuleMatchLayer4Config.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NetworkFirewallPolicyRuleMatchLayer4Config.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ip_protocol: str,
                 ports: Optional[Sequence[str]] = None):
        """
        :param 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 Sequence[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) -> 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")

    @property
    @pulumi.getter
    def ports(self) -> Optional[Sequence[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")


@pulumi.output_type
class NetworkFirewallPolicyRuleMatchSrcSecureTag(dict):
    def __init__(__self__, *,
                 name: str,
                 state: Optional[str] = None):
        """
        :param str name: Name of the secure tag, created with TagManager's TagValue API. @pattern tagValues/[0-9]+
        :param str state: [Output Only] State of the secure tag, either `EFFECTIVE` or `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted or its network is deleted.
        """
        pulumi.set(__self__, "name", name)
        if state is not None:
            pulumi.set(__self__, "state", state)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the secure tag, created with TagManager's TagValue API. @pattern tagValues/[0-9]+
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def state(self) -> Optional[str]:
        """
        [Output Only] State of the secure tag, either `EFFECTIVE` or `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted or its network is deleted.
        """
        return pulumi.get(self, "state")


@pulumi.output_type
class NetworkFirewallPolicyRuleTargetSecureTag(dict):
    def __init__(__self__, *,
                 name: str,
                 state: Optional[str] = None):
        """
        :param str name: Name of the secure tag, created with TagManager's TagValue API. @pattern tagValues/[0-9]+
        :param str state: [Output Only] State of the secure tag, either `EFFECTIVE` or `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted or its network is deleted.
        """
        pulumi.set(__self__, "name", name)
        if state is not None:
            pulumi.set(__self__, "state", state)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the secure tag, created with TagManager's TagValue API. @pattern tagValues/[0-9]+
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def state(self) -> Optional[str]:
        """
        [Output Only] State of the secure tag, either `EFFECTIVE` or `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted or its network is deleted.
        """
        return pulumi.get(self, "state")


@pulumi.output_type
class NodeGroupAutoscalingPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxNodes":
            suggest = "max_nodes"
        elif key == "minNodes":
            suggest = "min_nodes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeGroupAutoscalingPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeGroupAutoscalingPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeGroupAutoscalingPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 max_nodes: Optional[int] = None,
                 min_nodes: Optional[int] = None,
                 mode: Optional[str] = None):
        """
        :param 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 int min_nodes: Minimum size of the node group. Must be less
               than or equal to max-nodes. The default value is 0.
        :param 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[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")

    @property
    @pulumi.getter(name="minNodes")
    def min_nodes(self) -> Optional[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")

    @property
    @pulumi.getter
    def mode(self) -> Optional[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")


@pulumi.output_type
class NodeGroupMaintenanceWindow(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "startTime":
            suggest = "start_time"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeGroupMaintenanceWindow. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeGroupMaintenanceWindow.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeGroupMaintenanceWindow.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 start_time: str):
        """
        :param 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) -> 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")


@pulumi.output_type
class NodeGroupShareSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "shareType":
            suggest = "share_type"
        elif key == "projectMaps":
            suggest = "project_maps"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeGroupShareSettings. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeGroupShareSettings.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeGroupShareSettings.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 share_type: str,
                 project_maps: Optional[Sequence['outputs.NodeGroupShareSettingsProjectMap']] = None):
        """
        :param str share_type: Node group sharing type.
               Possible values are `ORGANIZATION`, `SPECIFIC_PROJECTS`, and `LOCAL`.
        :param Sequence['NodeGroupShareSettingsProjectMapArgs'] project_maps: A map of project id and project config. This is only valid when shareType's value is SPECIFIC_PROJECTS.
               Structure is documented below.
        """
        pulumi.set(__self__, "share_type", share_type)
        if project_maps is not None:
            pulumi.set(__self__, "project_maps", project_maps)

    @property
    @pulumi.getter(name="shareType")
    def share_type(self) -> str:
        """
        Node group sharing type.
        Possible values are `ORGANIZATION`, `SPECIFIC_PROJECTS`, and `LOCAL`.
        """
        return pulumi.get(self, "share_type")

    @property
    @pulumi.getter(name="projectMaps")
    def project_maps(self) -> Optional[Sequence['outputs.NodeGroupShareSettingsProjectMap']]:
        """
        A map of project id and project config. This is only valid when shareType's value is SPECIFIC_PROJECTS.
        Structure is documented below.
        """
        return pulumi.get(self, "project_maps")


@pulumi.output_type
class NodeGroupShareSettingsProjectMap(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "projectId":
            suggest = "project_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeGroupShareSettingsProjectMap. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeGroupShareSettingsProjectMap.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeGroupShareSettingsProjectMap.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 id: str,
                 project_id: str):
        """
        :param str id: The identifier for this object. Format specified above.
        :param str project_id: The project id/number should be the same as the key of this project config in the project map.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "project_id", project_id)

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

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> str:
        """
        The project id/number should be the same as the key of this project config in the project map.
        """
        return pulumi.get(self, "project_id")


@pulumi.output_type
class NodeTemplateNodeTypeFlexibility(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "localSsd":
            suggest = "local_ssd"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeTemplateNodeTypeFlexibility. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeTemplateNodeTypeFlexibility.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeTemplateNodeTypeFlexibility.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cpus: Optional[str] = None,
                 local_ssd: Optional[str] = None,
                 memory: Optional[str] = None):
        """
        :param str cpus: Number of virtual CPUs to use.
        :param str local_ssd: Use local SSD
        :param 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[str]:
        """
        Number of virtual CPUs to use.
        """
        return pulumi.get(self, "cpus")

    @property
    @pulumi.getter(name="localSsd")
    def local_ssd(self) -> Optional[str]:
        """
        Use local SSD
        """
        return pulumi.get(self, "local_ssd")

    @property
    @pulumi.getter
    def memory(self) -> Optional[str]:
        """
        Physical memory available to the node, defined in MB.
        """
        return pulumi.get(self, "memory")


@pulumi.output_type
class NodeTemplateServerBinding(dict):
    def __init__(__self__, *,
                 type: str):
        """
        :param 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) -> 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")


@pulumi.output_type
class OrganizationSecurityPolicyRuleMatch(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "versionedExpr":
            suggest = "versioned_expr"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OrganizationSecurityPolicyRuleMatch. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OrganizationSecurityPolicyRuleMatch.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OrganizationSecurityPolicyRuleMatch.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 config: 'outputs.OrganizationSecurityPolicyRuleMatchConfig',
                 description: Optional[str] = None,
                 versioned_expr: Optional[str] = None):
        """
        :param 'OrganizationSecurityPolicyRuleMatchConfigArgs' config: The configuration options for matching the rule.
               Structure is documented below.
        :param str description: A description of the rule.
        :param 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) -> 'outputs.OrganizationSecurityPolicyRuleMatchConfig':
        """
        The configuration options for matching the rule.
        Structure is documented below.
        """
        return pulumi.get(self, "config")

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

    @property
    @pulumi.getter(name="versionedExpr")
    def versioned_expr(self) -> Optional[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")


@pulumi.output_type
class OrganizationSecurityPolicyRuleMatchConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "layer4Configs":
            suggest = "layer4_configs"
        elif key == "destIpRanges":
            suggest = "dest_ip_ranges"
        elif key == "srcIpRanges":
            suggest = "src_ip_ranges"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OrganizationSecurityPolicyRuleMatchConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OrganizationSecurityPolicyRuleMatchConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OrganizationSecurityPolicyRuleMatchConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 layer4_configs: Sequence['outputs.OrganizationSecurityPolicyRuleMatchConfigLayer4Config'],
                 dest_ip_ranges: Optional[Sequence[str]] = None,
                 src_ip_ranges: Optional[Sequence[str]] = None):
        """
        :param Sequence['OrganizationSecurityPolicyRuleMatchConfigLayer4ConfigArgs'] layer4_configs: Pairs of IP protocols and ports that the rule should match.
               Structure is documented below.
        :param Sequence[str] dest_ip_ranges: Destination IP address range in CIDR format. Required for
               EGRESS rules.
        :param Sequence[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) -> Sequence['outputs.OrganizationSecurityPolicyRuleMatchConfigLayer4Config']:
        """
        Pairs of IP protocols and ports that the rule should match.
        Structure is documented below.
        """
        return pulumi.get(self, "layer4_configs")

    @property
    @pulumi.getter(name="destIpRanges")
    def dest_ip_ranges(self) -> Optional[Sequence[str]]:
        """
        Destination IP address range in CIDR format. Required for
        EGRESS rules.
        """
        return pulumi.get(self, "dest_ip_ranges")

    @property
    @pulumi.getter(name="srcIpRanges")
    def src_ip_ranges(self) -> Optional[Sequence[str]]:
        """
        Source IP address range in CIDR format. Required for
        INGRESS rules.
        """
        return pulumi.get(self, "src_ip_ranges")


@pulumi.output_type
class OrganizationSecurityPolicyRuleMatchConfigLayer4Config(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipProtocol":
            suggest = "ip_protocol"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in OrganizationSecurityPolicyRuleMatchConfigLayer4Config. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        OrganizationSecurityPolicyRuleMatchConfigLayer4Config.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        OrganizationSecurityPolicyRuleMatchConfigLayer4Config.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ip_protocol: str,
                 ports: Optional[Sequence[str]] = None):
        """
        :param 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 Sequence[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) -> 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")

    @property
    @pulumi.getter
    def ports(self) -> Optional[Sequence[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")


@pulumi.output_type
class PacketMirroringCollectorIlb(dict):
    def __init__(__self__, *,
                 url: str):
        """
        :param str url: The URL of the forwarding rule.
        """
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        The URL of the forwarding rule.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class PacketMirroringFilter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cidrRanges":
            suggest = "cidr_ranges"
        elif key == "ipProtocols":
            suggest = "ip_protocols"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PacketMirroringFilter. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PacketMirroringFilter.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PacketMirroringFilter.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cidr_ranges: Optional[Sequence[str]] = None,
                 direction: Optional[str] = None,
                 ip_protocols: Optional[Sequence[str]] = None):
        """
        :param Sequence[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 str direction: Direction of traffic to mirror.
               Default value is `BOTH`.
               Possible values are `INGRESS`, `EGRESS`, and `BOTH`.
        :param Sequence[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[Sequence[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")

    @property
    @pulumi.getter
    def direction(self) -> Optional[str]:
        """
        Direction of traffic to mirror.
        Default value is `BOTH`.
        Possible values are `INGRESS`, `EGRESS`, and `BOTH`.
        """
        return pulumi.get(self, "direction")

    @property
    @pulumi.getter(name="ipProtocols")
    def ip_protocols(self) -> Optional[Sequence[str]]:
        """
        Possible IP protocols including tcp, udp, icmp and esp
        """
        return pulumi.get(self, "ip_protocols")


@pulumi.output_type
class PacketMirroringMirroredResources(dict):
    def __init__(__self__, *,
                 instances: Optional[Sequence['outputs.PacketMirroringMirroredResourcesInstance']] = None,
                 subnetworks: Optional[Sequence['outputs.PacketMirroringMirroredResourcesSubnetwork']] = None,
                 tags: Optional[Sequence[str]] = None):
        """
        :param Sequence['PacketMirroringMirroredResourcesInstanceArgs'] instances: All the listed instances will be mirrored.  Specify at most 50.
               Structure is documented below.
        :param Sequence['PacketMirroringMirroredResourcesSubnetworkArgs'] subnetworks: All instances in one of these subnetworks will be mirrored.
               Structure is documented below.
        :param Sequence[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[Sequence['outputs.PacketMirroringMirroredResourcesInstance']]:
        """
        All the listed instances will be mirrored.  Specify at most 50.
        Structure is documented below.
        """
        return pulumi.get(self, "instances")

    @property
    @pulumi.getter
    def subnetworks(self) -> Optional[Sequence['outputs.PacketMirroringMirroredResourcesSubnetwork']]:
        """
        All instances in one of these subnetworks will be mirrored.
        Structure is documented below.
        """
        return pulumi.get(self, "subnetworks")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Sequence[str]]:
        """
        All instances with these tags will be mirrored.
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class PacketMirroringMirroredResourcesInstance(dict):
    def __init__(__self__, *,
                 url: str):
        """
        :param str url: The URL of the instances where this rule should be active.
        """
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        The URL of the instances where this rule should be active.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class PacketMirroringMirroredResourcesSubnetwork(dict):
    def __init__(__self__, *,
                 url: str):
        """
        :param str url: The URL of the subnetwork where this rule should be active.
        """
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        The URL of the subnetwork where this rule should be active.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class PacketMirroringNetwork(dict):
    def __init__(__self__, *,
                 url: str):
        """
        :param str url: The full self_link URL of the network where this rule is active.
        """
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        The full self_link URL of the network where this rule is active.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class PerInstanceConfigPreservedState(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "externalIps":
            suggest = "external_ips"
        elif key == "internalIps":
            suggest = "internal_ips"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PerInstanceConfigPreservedState. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PerInstanceConfigPreservedState.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PerInstanceConfigPreservedState.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 disks: Optional[Sequence['outputs.PerInstanceConfigPreservedStateDisk']] = None,
                 external_ips: Optional[Sequence['outputs.PerInstanceConfigPreservedStateExternalIp']] = None,
                 internal_ips: Optional[Sequence['outputs.PerInstanceConfigPreservedStateInternalIp']] = None,
                 metadata: Optional[Mapping[str, str]] = None):
        """
        :param Sequence['PerInstanceConfigPreservedStateDiskArgs'] disks: Stateful disks for the instance.
               Structure is documented below.
        :param Mapping[str, 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 external_ips is not None:
            pulumi.set(__self__, "external_ips", external_ips)
        if internal_ips is not None:
            pulumi.set(__self__, "internal_ips", internal_ips)
        if metadata is not None:
            pulumi.set(__self__, "metadata", metadata)

    @property
    @pulumi.getter
    def disks(self) -> Optional[Sequence['outputs.PerInstanceConfigPreservedStateDisk']]:
        """
        Stateful disks for the instance.
        Structure is documented below.
        """
        return pulumi.get(self, "disks")

    @property
    @pulumi.getter(name="externalIps")
    def external_ips(self) -> Optional[Sequence['outputs.PerInstanceConfigPreservedStateExternalIp']]:
        return pulumi.get(self, "external_ips")

    @property
    @pulumi.getter(name="internalIps")
    def internal_ips(self) -> Optional[Sequence['outputs.PerInstanceConfigPreservedStateInternalIp']]:
        return pulumi.get(self, "internal_ips")

    @property
    @pulumi.getter
    def metadata(self) -> Optional[Mapping[str, str]]:
        """
        Preserved metadata defined for this instance. This is a list of key->value pairs.
        """
        return pulumi.get(self, "metadata")


@pulumi.output_type
class PerInstanceConfigPreservedStateDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deviceName":
            suggest = "device_name"
        elif key == "deleteRule":
            suggest = "delete_rule"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PerInstanceConfigPreservedStateDisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PerInstanceConfigPreservedStateDisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PerInstanceConfigPreservedStateDisk.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 device_name: str,
                 source: str,
                 delete_rule: Optional[str] = None,
                 mode: Optional[str] = None):
        """
        :param str device_name: A unique device name that is reflected into the /dev/ tree of a Linux operating system running within the instance.
        :param 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 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 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) -> 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")

    @property
    @pulumi.getter
    def source(self) -> 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")

    @property
    @pulumi.getter(name="deleteRule")
    def delete_rule(self) -> Optional[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")

    @property
    @pulumi.getter
    def mode(self) -> Optional[str]:
        """
        The mode of the disk.
        Default value is `READ_WRITE`.
        Possible values are `READ_ONLY` and `READ_WRITE`.
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class PerInstanceConfigPreservedStateExternalIp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "interfaceName":
            suggest = "interface_name"
        elif key == "autoDelete":
            suggest = "auto_delete"
        elif key == "ipAddress":
            suggest = "ip_address"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PerInstanceConfigPreservedStateExternalIp. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PerInstanceConfigPreservedStateExternalIp.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PerInstanceConfigPreservedStateExternalIp.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 interface_name: str,
                 auto_delete: Optional[str] = None,
                 ip_address: Optional['outputs.PerInstanceConfigPreservedStateExternalIpIpAddress'] = None):
        """
        :param str interface_name: The identifier for this object. Format specified above.
        :param str auto_delete: These stateful IPs will never be released during autohealing, update or VM instance recreate operations. This flag is used to configure if the IP reservation should be deleted after it is no longer used by the group, e.g. when the given instance or the whole group is deleted.
               Default value is `NEVER`.
               Possible values are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`.
        :param 'PerInstanceConfigPreservedStateExternalIpIpAddressArgs' ip_address: Ip address representation
               Structure is documented below.
        """
        pulumi.set(__self__, "interface_name", interface_name)
        if auto_delete is not None:
            pulumi.set(__self__, "auto_delete", auto_delete)
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)

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

    @property
    @pulumi.getter(name="autoDelete")
    def auto_delete(self) -> Optional[str]:
        """
        These stateful IPs will never be released during autohealing, update or VM instance recreate operations. This flag is used to configure if the IP reservation should be deleted after it is no longer used by the group, e.g. when the given instance or the whole group is deleted.
        Default value is `NEVER`.
        Possible values are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`.
        """
        return pulumi.get(self, "auto_delete")

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> Optional['outputs.PerInstanceConfigPreservedStateExternalIpIpAddress']:
        """
        Ip address representation
        Structure is documented below.
        """
        return pulumi.get(self, "ip_address")


@pulumi.output_type
class PerInstanceConfigPreservedStateExternalIpIpAddress(dict):
    def __init__(__self__, *,
                 address: Optional[str] = None):
        """
        :param str address: The URL of the reservation for this IP address.
        """
        if address is not None:
            pulumi.set(__self__, "address", address)

    @property
    @pulumi.getter
    def address(self) -> Optional[str]:
        """
        The URL of the reservation for this IP address.
        """
        return pulumi.get(self, "address")


@pulumi.output_type
class PerInstanceConfigPreservedStateInternalIp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "interfaceName":
            suggest = "interface_name"
        elif key == "autoDelete":
            suggest = "auto_delete"
        elif key == "ipAddress":
            suggest = "ip_address"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PerInstanceConfigPreservedStateInternalIp. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PerInstanceConfigPreservedStateInternalIp.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PerInstanceConfigPreservedStateInternalIp.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 interface_name: str,
                 auto_delete: Optional[str] = None,
                 ip_address: Optional['outputs.PerInstanceConfigPreservedStateInternalIpIpAddress'] = None):
        """
        :param str interface_name: The identifier for this object. Format specified above.
        :param str auto_delete: These stateful IPs will never be released during autohealing, update or VM instance recreate operations. This flag is used to configure if the IP reservation should be deleted after it is no longer used by the group, e.g. when the given instance or the whole group is deleted.
               Default value is `NEVER`.
               Possible values are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`.
        :param 'PerInstanceConfigPreservedStateInternalIpIpAddressArgs' ip_address: Ip address representation
               Structure is documented below.
        """
        pulumi.set(__self__, "interface_name", interface_name)
        if auto_delete is not None:
            pulumi.set(__self__, "auto_delete", auto_delete)
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)

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

    @property
    @pulumi.getter(name="autoDelete")
    def auto_delete(self) -> Optional[str]:
        """
        These stateful IPs will never be released during autohealing, update or VM instance recreate operations. This flag is used to configure if the IP reservation should be deleted after it is no longer used by the group, e.g. when the given instance or the whole group is deleted.
        Default value is `NEVER`.
        Possible values are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`.
        """
        return pulumi.get(self, "auto_delete")

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> Optional['outputs.PerInstanceConfigPreservedStateInternalIpIpAddress']:
        """
        Ip address representation
        Structure is documented below.
        """
        return pulumi.get(self, "ip_address")


@pulumi.output_type
class PerInstanceConfigPreservedStateInternalIpIpAddress(dict):
    def __init__(__self__, *,
                 address: Optional[str] = None):
        """
        :param str address: The URL of the reservation for this IP address.
        """
        if address is not None:
            pulumi.set(__self__, "address", address)

    @property
    @pulumi.getter
    def address(self) -> Optional[str]:
        """
        The URL of the reservation for this IP address.
        """
        return pulumi.get(self, "address")


@pulumi.output_type
class RegionAutoscalerAutoscalingPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxReplicas":
            suggest = "max_replicas"
        elif key == "minReplicas":
            suggest = "min_replicas"
        elif key == "cooldownPeriod":
            suggest = "cooldown_period"
        elif key == "cpuUtilization":
            suggest = "cpu_utilization"
        elif key == "loadBalancingUtilization":
            suggest = "load_balancing_utilization"
        elif key == "scaleDownControl":
            suggest = "scale_down_control"
        elif key == "scaleInControl":
            suggest = "scale_in_control"
        elif key == "scalingSchedules":
            suggest = "scaling_schedules"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionAutoscalerAutoscalingPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionAutoscalerAutoscalingPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionAutoscalerAutoscalingPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 max_replicas: int,
                 min_replicas: int,
                 cooldown_period: Optional[int] = None,
                 cpu_utilization: Optional['outputs.RegionAutoscalerAutoscalingPolicyCpuUtilization'] = None,
                 load_balancing_utilization: Optional['outputs.RegionAutoscalerAutoscalingPolicyLoadBalancingUtilization'] = None,
                 metrics: Optional[Sequence['outputs.RegionAutoscalerAutoscalingPolicyMetric']] = None,
                 mode: Optional[str] = None,
                 scale_down_control: Optional['outputs.RegionAutoscalerAutoscalingPolicyScaleDownControl'] = None,
                 scale_in_control: Optional['outputs.RegionAutoscalerAutoscalingPolicyScaleInControl'] = None,
                 scaling_schedules: Optional[Sequence['outputs.RegionAutoscalerAutoscalingPolicyScalingSchedule']] = None):
        """
        :param 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 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 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 '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 'RegionAutoscalerAutoscalingPolicyLoadBalancingUtilizationArgs' load_balancing_utilization: Configuration parameters of autoscaling based on a load balancer.
               Structure is documented below.
        :param Sequence['RegionAutoscalerAutoscalingPolicyMetricArgs'] metrics: Configuration parameters of autoscaling based on a custom metric.
               Structure is documented below.
        :param str mode: Defines operating mode for this policy.
               Default value is `ON`.
               Possible values are `OFF`, `ONLY_UP`, and `ON`.
        :param '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 '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 Sequence['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) -> 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")

    @property
    @pulumi.getter(name="minReplicas")
    def min_replicas(self) -> 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")

    @property
    @pulumi.getter(name="cooldownPeriod")
    def cooldown_period(self) -> Optional[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")

    @property
    @pulumi.getter(name="cpuUtilization")
    def cpu_utilization(self) -> Optional['outputs.RegionAutoscalerAutoscalingPolicyCpuUtilization']:
        """
        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")

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

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

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

    @property
    @pulumi.getter(name="scaleDownControl")
    def scale_down_control(self) -> Optional['outputs.RegionAutoscalerAutoscalingPolicyScaleDownControl']:
        """
        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")

    @property
    @pulumi.getter(name="scaleInControl")
    def scale_in_control(self) -> Optional['outputs.RegionAutoscalerAutoscalingPolicyScaleInControl']:
        """
        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")

    @property
    @pulumi.getter(name="scalingSchedules")
    def scaling_schedules(self) -> Optional[Sequence['outputs.RegionAutoscalerAutoscalingPolicyScalingSchedule']]:
        """
        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")


@pulumi.output_type
class RegionAutoscalerAutoscalingPolicyCpuUtilization(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "predictiveMethod":
            suggest = "predictive_method"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionAutoscalerAutoscalingPolicyCpuUtilization. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionAutoscalerAutoscalingPolicyCpuUtilization.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionAutoscalerAutoscalingPolicyCpuUtilization.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 target: float,
                 predictive_method: Optional[str] = None):
        """
        :param float target: The target CPU utilization that the autoscaler should maintain.
               Must be a float value in the range (0, 1]. If not specified, the
               default is 0.6.
               If the CPU level is below the target utilization, the autoscaler
               scales down the number of instances until it reaches the minimum
               number of instances you specified or until the average CPU of
               your instances reaches the target utilization.
               If the average CPU is above the target utilization, the autoscaler
               scales up until it reaches the maximum number of instances you
               specified or until the average utilization reaches the target
               utilization.
        :param 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) -> float:
        """
        The target CPU utilization that the autoscaler should maintain.
        Must be a float value in the range (0, 1]. If not specified, the
        default is 0.6.
        If the CPU level is below the target utilization, the autoscaler
        scales down the number of instances until it reaches the minimum
        number of instances you specified or until the average CPU of
        your instances reaches the target utilization.
        If the average CPU is above the target utilization, the autoscaler
        scales up until it reaches the maximum number of instances you
        specified or until the average utilization reaches the target
        utilization.
        """
        return pulumi.get(self, "target")

    @property
    @pulumi.getter(name="predictiveMethod")
    def predictive_method(self) -> Optional[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")


@pulumi.output_type
class RegionAutoscalerAutoscalingPolicyLoadBalancingUtilization(dict):
    def __init__(__self__, *,
                 target: float):
        """
        :param 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) -> 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")


@pulumi.output_type
class RegionAutoscalerAutoscalingPolicyMetric(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "singleInstanceAssignment":
            suggest = "single_instance_assignment"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionAutoscalerAutoscalingPolicyMetric. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionAutoscalerAutoscalingPolicyMetric.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionAutoscalerAutoscalingPolicyMetric.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 filter: Optional[str] = None,
                 single_instance_assignment: Optional[float] = None,
                 target: Optional[float] = None,
                 type: Optional[str] = None):
        """
        :param str name: The identifier (type) of the Stackdriver Monitoring metric.
               The metric cannot have negative values.
               The metric must have a value type of INT64 or DOUBLE.
        :param 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 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 float target: The target value of the metric that autoscaler should
               maintain. This must be a positive value. A utilization
               metric scales number of virtual machines handling requests
               to increase or decrease proportionally to the metric.
               For example, a good metric to use as a utilizationTarget is
               www.googleapis.com/compute/instance/network/received_bytes_count.
               The autoscaler will work to keep this value constant for each
               of the instances.
        :param 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) -> str:
        """
        The identifier (type) of the Stackdriver Monitoring metric.
        The metric cannot have negative values.
        The metric must have a value type of INT64 or DOUBLE.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def filter(self) -> Optional[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")

    @property
    @pulumi.getter(name="singleInstanceAssignment")
    def single_instance_assignment(self) -> Optional[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")

    @property
    @pulumi.getter
    def target(self) -> Optional[float]:
        """
        The target value of the metric that autoscaler should
        maintain. This must be a positive value. A utilization
        metric scales number of virtual machines handling requests
        to increase or decrease proportionally to the metric.
        For example, a good metric to use as a utilizationTarget is
        www.googleapis.com/compute/instance/network/received_bytes_count.
        The autoscaler will work to keep this value constant for each
        of the instances.
        """
        return pulumi.get(self, "target")

    @property
    @pulumi.getter
    def type(self) -> Optional[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")


@pulumi.output_type
class RegionAutoscalerAutoscalingPolicyScaleDownControl(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxScaledDownReplicas":
            suggest = "max_scaled_down_replicas"
        elif key == "timeWindowSec":
            suggest = "time_window_sec"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionAutoscalerAutoscalingPolicyScaleDownControl. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionAutoscalerAutoscalingPolicyScaleDownControl.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionAutoscalerAutoscalingPolicyScaleDownControl.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 max_scaled_down_replicas: Optional['outputs.RegionAutoscalerAutoscalingPolicyScaleDownControlMaxScaledDownReplicas'] = None,
                 time_window_sec: Optional[int] = None):
        """
        :param 'RegionAutoscalerAutoscalingPolicyScaleDownControlMaxScaledDownReplicasArgs' max_scaled_down_replicas: A nested object resource
               Structure is documented below.
        :param 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['outputs.RegionAutoscalerAutoscalingPolicyScaleDownControlMaxScaledDownReplicas']:
        """
        A nested object resource
        Structure is documented below.
        """
        return pulumi.get(self, "max_scaled_down_replicas")

    @property
    @pulumi.getter(name="timeWindowSec")
    def time_window_sec(self) -> Optional[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")


@pulumi.output_type
class RegionAutoscalerAutoscalingPolicyScaleDownControlMaxScaledDownReplicas(dict):
    def __init__(__self__, *,
                 fixed: Optional[int] = None,
                 percent: Optional[int] = None):
        """
        :param int fixed: Specifies a fixed number of VM instances. This must be a positive
               integer.
        :param 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[int]:
        """
        Specifies a fixed number of VM instances. This must be a positive
        integer.
        """
        return pulumi.get(self, "fixed")

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


@pulumi.output_type
class RegionAutoscalerAutoscalingPolicyScaleInControl(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxScaledInReplicas":
            suggest = "max_scaled_in_replicas"
        elif key == "timeWindowSec":
            suggest = "time_window_sec"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionAutoscalerAutoscalingPolicyScaleInControl. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionAutoscalerAutoscalingPolicyScaleInControl.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionAutoscalerAutoscalingPolicyScaleInControl.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 max_scaled_in_replicas: Optional['outputs.RegionAutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicas'] = None,
                 time_window_sec: Optional[int] = None):
        """
        :param 'RegionAutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicasArgs' max_scaled_in_replicas: A nested object resource
               Structure is documented below.
        :param 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['outputs.RegionAutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicas']:
        """
        A nested object resource
        Structure is documented below.
        """
        return pulumi.get(self, "max_scaled_in_replicas")

    @property
    @pulumi.getter(name="timeWindowSec")
    def time_window_sec(self) -> Optional[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")


@pulumi.output_type
class RegionAutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicas(dict):
    def __init__(__self__, *,
                 fixed: Optional[int] = None,
                 percent: Optional[int] = None):
        """
        :param int fixed: Specifies a fixed number of VM instances. This must be a positive
               integer.
        :param 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[int]:
        """
        Specifies a fixed number of VM instances. This must be a positive
        integer.
        """
        return pulumi.get(self, "fixed")

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


@pulumi.output_type
class RegionAutoscalerAutoscalingPolicyScalingSchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "durationSec":
            suggest = "duration_sec"
        elif key == "minRequiredReplicas":
            suggest = "min_required_replicas"
        elif key == "timeZone":
            suggest = "time_zone"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionAutoscalerAutoscalingPolicyScalingSchedule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionAutoscalerAutoscalingPolicyScalingSchedule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionAutoscalerAutoscalingPolicyScalingSchedule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 duration_sec: int,
                 min_required_replicas: int,
                 name: str,
                 schedule: str,
                 description: Optional[str] = None,
                 disabled: Optional[bool] = None,
                 time_zone: Optional[str] = None):
        """
        :param 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 int min_required_replicas: Minimum number of VM instances that autoscaler will recommend in time intervals starting according to schedule.
        :param str name: The identifier for this object. Format specified above.
        :param 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 str description: An optional description of this resource.
        :param 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 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) -> 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")

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

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

    @property
    @pulumi.getter
    def schedule(self) -> 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")

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

    @property
    @pulumi.getter
    def disabled(self) -> Optional[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")

    @property
    @pulumi.getter(name="timeZone")
    def time_zone(self) -> Optional[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")


@pulumi.output_type
class RegionBackendServiceBackend(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "balancingMode":
            suggest = "balancing_mode"
        elif key == "capacityScaler":
            suggest = "capacity_scaler"
        elif key == "maxConnections":
            suggest = "max_connections"
        elif key == "maxConnectionsPerEndpoint":
            suggest = "max_connections_per_endpoint"
        elif key == "maxConnectionsPerInstance":
            suggest = "max_connections_per_instance"
        elif key == "maxRate":
            suggest = "max_rate"
        elif key == "maxRatePerEndpoint":
            suggest = "max_rate_per_endpoint"
        elif key == "maxRatePerInstance":
            suggest = "max_rate_per_instance"
        elif key == "maxUtilization":
            suggest = "max_utilization"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionBackendServiceBackend. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionBackendServiceBackend.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionBackendServiceBackend.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 group: str,
                 balancing_mode: Optional[str] = None,
                 capacity_scaler: Optional[float] = None,
                 description: Optional[str] = None,
                 failover: Optional[bool] = None,
                 max_connections: Optional[int] = None,
                 max_connections_per_endpoint: Optional[int] = None,
                 max_connections_per_instance: Optional[int] = None,
                 max_rate: Optional[int] = None,
                 max_rate_per_endpoint: Optional[float] = None,
                 max_rate_per_instance: Optional[float] = None,
                 max_utilization: Optional[float] = None):
        """
        :param 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 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 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 str description: An optional description of this resource.
               Provide this property when you create the resource.
        :param bool failover: This field designates whether this is a failover backend. More
               than one failover backend can be configured for a given RegionBackendService.
        :param int max_connections: The max number of simultaneous connections for the group. Can
               be used with either CONNECTION or UTILIZATION balancing modes.
               Cannot be set for INTERNAL backend services.
               For CONNECTION mode, either maxConnections or one
               of maxConnectionsPerInstance or maxConnectionsPerEndpoint,
               as appropriate for group type, must be set.
        :param 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 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 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 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 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 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) -> 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")

    @property
    @pulumi.getter(name="balancingMode")
    def balancing_mode(self) -> Optional[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")

    @property
    @pulumi.getter(name="capacityScaler")
    def capacity_scaler(self) -> Optional[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")

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

    @property
    @pulumi.getter
    def failover(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxConnections")
    def max_connections(self) -> Optional[int]:
        """
        The max number of simultaneous connections for the group. Can
        be used with either CONNECTION or UTILIZATION balancing modes.
        Cannot be set for INTERNAL backend services.
        For CONNECTION mode, either maxConnections or one
        of maxConnectionsPerInstance or maxConnectionsPerEndpoint,
        as appropriate for group type, must be set.
        """
        return pulumi.get(self, "max_connections")

    @property
    @pulumi.getter(name="maxConnectionsPerEndpoint")
    def max_connections_per_endpoint(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxConnectionsPerInstance")
    def max_connections_per_instance(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxRate")
    def max_rate(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxRatePerEndpoint")
    def max_rate_per_endpoint(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxRatePerInstance")
    def max_rate_per_instance(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxUtilization")
    def max_utilization(self) -> Optional[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")


@pulumi.output_type
class RegionBackendServiceCdnPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cacheKeyPolicy":
            suggest = "cache_key_policy"
        elif key == "cacheMode":
            suggest = "cache_mode"
        elif key == "clientTtl":
            suggest = "client_ttl"
        elif key == "defaultTtl":
            suggest = "default_ttl"
        elif key == "maxTtl":
            suggest = "max_ttl"
        elif key == "negativeCaching":
            suggest = "negative_caching"
        elif key == "negativeCachingPolicies":
            suggest = "negative_caching_policies"
        elif key == "serveWhileStale":
            suggest = "serve_while_stale"
        elif key == "signedUrlCacheMaxAgeSec":
            suggest = "signed_url_cache_max_age_sec"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionBackendServiceCdnPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionBackendServiceCdnPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionBackendServiceCdnPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cache_key_policy: Optional['outputs.RegionBackendServiceCdnPolicyCacheKeyPolicy'] = None,
                 cache_mode: Optional[str] = None,
                 client_ttl: Optional[int] = None,
                 default_ttl: Optional[int] = None,
                 max_ttl: Optional[int] = None,
                 negative_caching: Optional[bool] = None,
                 negative_caching_policies: Optional[Sequence['outputs.RegionBackendServiceCdnPolicyNegativeCachingPolicy']] = None,
                 serve_while_stale: Optional[int] = None,
                 signed_url_cache_max_age_sec: Optional[int] = None):
        """
        :param 'RegionBackendServiceCdnPolicyCacheKeyPolicyArgs' cache_key_policy: The CacheKeyPolicy for this CdnPolicy.
               Structure is documented below.
        :param 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 int client_ttl: Specifies the maximum allowed TTL for cached content served by this origin.
        :param 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 int max_ttl: Specifies the maximum allowed TTL for cached content served by this origin.
        :param 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 Sequence['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 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 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['outputs.RegionBackendServiceCdnPolicyCacheKeyPolicy']:
        """
        The CacheKeyPolicy for this CdnPolicy.
        Structure is documented below.
        """
        return pulumi.get(self, "cache_key_policy")

    @property
    @pulumi.getter(name="cacheMode")
    def cache_mode(self) -> Optional[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")

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

    @property
    @pulumi.getter(name="defaultTtl")
    def default_ttl(self) -> Optional[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")

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

    @property
    @pulumi.getter(name="negativeCaching")
    def negative_caching(self) -> Optional[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")

    @property
    @pulumi.getter(name="negativeCachingPolicies")
    def negative_caching_policies(self) -> Optional[Sequence['outputs.RegionBackendServiceCdnPolicyNegativeCachingPolicy']]:
        """
        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")

    @property
    @pulumi.getter(name="serveWhileStale")
    def serve_while_stale(self) -> Optional[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")

    @property
    @pulumi.getter(name="signedUrlCacheMaxAgeSec")
    def signed_url_cache_max_age_sec(self) -> Optional[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")


@pulumi.output_type
class RegionBackendServiceCdnPolicyCacheKeyPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "includeHost":
            suggest = "include_host"
        elif key == "includeNamedCookies":
            suggest = "include_named_cookies"
        elif key == "includeProtocol":
            suggest = "include_protocol"
        elif key == "includeQueryString":
            suggest = "include_query_string"
        elif key == "queryStringBlacklists":
            suggest = "query_string_blacklists"
        elif key == "queryStringWhitelists":
            suggest = "query_string_whitelists"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionBackendServiceCdnPolicyCacheKeyPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionBackendServiceCdnPolicyCacheKeyPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionBackendServiceCdnPolicyCacheKeyPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 include_host: Optional[bool] = None,
                 include_named_cookies: Optional[Sequence[str]] = None,
                 include_protocol: Optional[bool] = None,
                 include_query_string: Optional[bool] = None,
                 query_string_blacklists: Optional[Sequence[str]] = None,
                 query_string_whitelists: Optional[Sequence[str]] = None):
        """
        :param bool include_host: If true requests to different hosts will be cached separately.
        :param Sequence[str] include_named_cookies: Names of cookies to include in cache keys.
        :param bool include_protocol: If true, http and https requests will be cached separately.
        :param 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 Sequence[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 Sequence[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[bool]:
        """
        If true requests to different hosts will be cached separately.
        """
        return pulumi.get(self, "include_host")

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

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

    @property
    @pulumi.getter(name="includeQueryString")
    def include_query_string(self) -> Optional[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")

    @property
    @pulumi.getter(name="queryStringBlacklists")
    def query_string_blacklists(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter(name="queryStringWhitelists")
    def query_string_whitelists(self) -> Optional[Sequence[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")


@pulumi.output_type
class RegionBackendServiceCdnPolicyNegativeCachingPolicy(dict):
    def __init__(__self__, *,
                 code: Optional[int] = None,
                 ttl: Optional[int] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter
    def ttl(self) -> Optional[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")


@pulumi.output_type
class RegionBackendServiceCircuitBreakers(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "connectTimeout":
            suggest = "connect_timeout"
        elif key == "maxConnections":
            suggest = "max_connections"
        elif key == "maxPendingRequests":
            suggest = "max_pending_requests"
        elif key == "maxRequests":
            suggest = "max_requests"
        elif key == "maxRequestsPerConnection":
            suggest = "max_requests_per_connection"
        elif key == "maxRetries":
            suggest = "max_retries"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionBackendServiceCircuitBreakers. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionBackendServiceCircuitBreakers.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionBackendServiceCircuitBreakers.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 connect_timeout: Optional['outputs.RegionBackendServiceCircuitBreakersConnectTimeout'] = None,
                 max_connections: Optional[int] = None,
                 max_pending_requests: Optional[int] = None,
                 max_requests: Optional[int] = None,
                 max_requests_per_connection: Optional[int] = None,
                 max_retries: Optional[int] = None):
        """
        :param 'RegionBackendServiceCircuitBreakersConnectTimeoutArgs' connect_timeout: The timeout for new network connections to hosts.
               Structure is documented below.
        :param int max_connections: The maximum number of connections to the backend cluster.
               Defaults to 1024.
        :param int max_pending_requests: The maximum number of pending requests to the backend cluster.
               Defaults to 1024.
        :param int max_requests: The maximum number of parallel requests to the backend cluster.
               Defaults to 1024.
        :param 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 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['outputs.RegionBackendServiceCircuitBreakersConnectTimeout']:
        """
        The timeout for new network connections to hosts.
        Structure is documented below.
        """
        return pulumi.get(self, "connect_timeout")

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

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

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

    @property
    @pulumi.getter(name="maxRequestsPerConnection")
    def max_requests_per_connection(self) -> Optional[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")

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


@pulumi.output_type
class RegionBackendServiceCircuitBreakersConnectTimeout(dict):
    def __init__(__self__, *,
                 seconds: int,
                 nanos: Optional[int] = None):
        """
        :param int seconds: Span of time at a resolution of a second.
               Must be from 0 to 315,576,000,000 inclusive.
        :param 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) -> 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")

    @property
    @pulumi.getter
    def nanos(self) -> Optional[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")


@pulumi.output_type
class RegionBackendServiceConnectionTrackingPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "connectionPersistenceOnUnhealthyBackends":
            suggest = "connection_persistence_on_unhealthy_backends"
        elif key == "idleTimeoutSec":
            suggest = "idle_timeout_sec"
        elif key == "trackingMode":
            suggest = "tracking_mode"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionBackendServiceConnectionTrackingPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionBackendServiceConnectionTrackingPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionBackendServiceConnectionTrackingPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 connection_persistence_on_unhealthy_backends: Optional[str] = None,
                 idle_timeout_sec: Optional[int] = None,
                 tracking_mode: Optional[str] = None):
        """
        :param 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 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 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[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")

    @property
    @pulumi.getter(name="idleTimeoutSec")
    def idle_timeout_sec(self) -> Optional[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")

    @property
    @pulumi.getter(name="trackingMode")
    def tracking_mode(self) -> Optional[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")


@pulumi.output_type
class RegionBackendServiceConsistentHash(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "httpCookie":
            suggest = "http_cookie"
        elif key == "httpHeaderName":
            suggest = "http_header_name"
        elif key == "minimumRingSize":
            suggest = "minimum_ring_size"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionBackendServiceConsistentHash. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionBackendServiceConsistentHash.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionBackendServiceConsistentHash.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 http_cookie: Optional['outputs.RegionBackendServiceConsistentHashHttpCookie'] = None,
                 http_header_name: Optional[str] = None,
                 minimum_ring_size: Optional[int] = None):
        """
        :param '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 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 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['outputs.RegionBackendServiceConsistentHashHttpCookie']:
        """
        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")

    @property
    @pulumi.getter(name="httpHeaderName")
    def http_header_name(self) -> Optional[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")

    @property
    @pulumi.getter(name="minimumRingSize")
    def minimum_ring_size(self) -> Optional[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")


@pulumi.output_type
class RegionBackendServiceConsistentHashHttpCookie(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None,
                 path: Optional[str] = None,
                 ttl: Optional['outputs.RegionBackendServiceConsistentHashHttpCookieTtl'] = None):
        """
        :param str name: Name of the cookie.
        :param str path: Path to set for the cookie.
        :param 'RegionBackendServiceConsistentHashHttpCookieTtlArgs' ttl: Lifetime of the cookie.
               Structure is documented below.
        """
        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[str]:
        """
        Name of the cookie.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def ttl(self) -> Optional['outputs.RegionBackendServiceConsistentHashHttpCookieTtl']:
        """
        Lifetime of the cookie.
        Structure is documented below.
        """
        return pulumi.get(self, "ttl")


@pulumi.output_type
class RegionBackendServiceConsistentHashHttpCookieTtl(dict):
    def __init__(__self__, *,
                 seconds: int,
                 nanos: Optional[int] = None):
        """
        :param int seconds: Span of time at a resolution of a second.
               Must be from 0 to 315,576,000,000 inclusive.
        :param 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) -> 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")

    @property
    @pulumi.getter
    def nanos(self) -> Optional[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")


@pulumi.output_type
class RegionBackendServiceFailoverPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "disableConnectionDrainOnFailover":
            suggest = "disable_connection_drain_on_failover"
        elif key == "dropTrafficIfUnhealthy":
            suggest = "drop_traffic_if_unhealthy"
        elif key == "failoverRatio":
            suggest = "failover_ratio"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionBackendServiceFailoverPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionBackendServiceFailoverPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionBackendServiceFailoverPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 disable_connection_drain_on_failover: Optional[bool] = None,
                 drop_traffic_if_unhealthy: Optional[bool] = None,
                 failover_ratio: Optional[float] = None):
        """
        :param 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 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 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[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")

    @property
    @pulumi.getter(name="dropTrafficIfUnhealthy")
    def drop_traffic_if_unhealthy(self) -> Optional[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")

    @property
    @pulumi.getter(name="failoverRatio")
    def failover_ratio(self) -> Optional[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")


@pulumi.output_type
class RegionBackendServiceIamBindingCondition(dict):
    def __init__(__self__, *,
                 expression: str,
                 title: str,
                 description: Optional[str] = None):
        """
        :param str expression: Textual representation of an expression in Common Expression Language syntax.
        :param str title: A title for the expression, i.e. a short string describing its purpose.
        :param 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) -> str:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[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")


@pulumi.output_type
class RegionBackendServiceIamMemberCondition(dict):
    def __init__(__self__, *,
                 expression: str,
                 title: str,
                 description: Optional[str] = None):
        """
        :param str expression: Textual representation of an expression in Common Expression Language syntax.
        :param str title: A title for the expression, i.e. a short string describing its purpose.
        :param 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) -> str:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[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")


@pulumi.output_type
class RegionBackendServiceIap(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "oauth2ClientId":
            suggest = "oauth2_client_id"
        elif key == "oauth2ClientSecret":
            suggest = "oauth2_client_secret"
        elif key == "oauth2ClientSecretSha256":
            suggest = "oauth2_client_secret_sha256"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionBackendServiceIap. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionBackendServiceIap.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionBackendServiceIap.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 oauth2_client_id: str,
                 oauth2_client_secret: str,
                 oauth2_client_secret_sha256: Optional[str] = None):
        """
        :param str oauth2_client_id: OAuth2 Client ID for IAP
        :param str oauth2_client_secret: OAuth2 Client Secret for IAP
               **Note**: This property is sensitive and will not be displayed in the plan.
        :param 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) -> str:
        """
        OAuth2 Client ID for IAP
        """
        return pulumi.get(self, "oauth2_client_id")

    @property
    @pulumi.getter(name="oauth2ClientSecret")
    def oauth2_client_secret(self) -> 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")

    @property
    @pulumi.getter(name="oauth2ClientSecretSha256")
    def oauth2_client_secret_sha256(self) -> Optional[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")


@pulumi.output_type
class RegionBackendServiceLogConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sampleRate":
            suggest = "sample_rate"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionBackendServiceLogConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionBackendServiceLogConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionBackendServiceLogConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enable: Optional[bool] = None,
                 sample_rate: Optional[float] = None):
        """
        :param bool enable: Whether to enable logging for the load balancer traffic served by this backend service.
        :param 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[bool]:
        """
        Whether to enable logging for the load balancer traffic served by this backend service.
        """
        return pulumi.get(self, "enable")

    @property
    @pulumi.getter(name="sampleRate")
    def sample_rate(self) -> Optional[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")


@pulumi.output_type
class RegionBackendServiceOutlierDetection(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "baseEjectionTime":
            suggest = "base_ejection_time"
        elif key == "consecutiveErrors":
            suggest = "consecutive_errors"
        elif key == "consecutiveGatewayFailure":
            suggest = "consecutive_gateway_failure"
        elif key == "enforcingConsecutiveErrors":
            suggest = "enforcing_consecutive_errors"
        elif key == "enforcingConsecutiveGatewayFailure":
            suggest = "enforcing_consecutive_gateway_failure"
        elif key == "enforcingSuccessRate":
            suggest = "enforcing_success_rate"
        elif key == "maxEjectionPercent":
            suggest = "max_ejection_percent"
        elif key == "successRateMinimumHosts":
            suggest = "success_rate_minimum_hosts"
        elif key == "successRateRequestVolume":
            suggest = "success_rate_request_volume"
        elif key == "successRateStdevFactor":
            suggest = "success_rate_stdev_factor"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionBackendServiceOutlierDetection. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionBackendServiceOutlierDetection.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionBackendServiceOutlierDetection.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 base_ejection_time: Optional['outputs.RegionBackendServiceOutlierDetectionBaseEjectionTime'] = None,
                 consecutive_errors: Optional[int] = None,
                 consecutive_gateway_failure: Optional[int] = None,
                 enforcing_consecutive_errors: Optional[int] = None,
                 enforcing_consecutive_gateway_failure: Optional[int] = None,
                 enforcing_success_rate: Optional[int] = None,
                 interval: Optional['outputs.RegionBackendServiceOutlierDetectionInterval'] = None,
                 max_ejection_percent: Optional[int] = None,
                 success_rate_minimum_hosts: Optional[int] = None,
                 success_rate_request_volume: Optional[int] = None,
                 success_rate_stdev_factor: Optional[int] = None):
        """
        :param '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 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 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 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 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 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 '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 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 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 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 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['outputs.RegionBackendServiceOutlierDetectionBaseEjectionTime']:
        """
        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")

    @property
    @pulumi.getter(name="consecutiveErrors")
    def consecutive_errors(self) -> Optional[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")

    @property
    @pulumi.getter(name="consecutiveGatewayFailure")
    def consecutive_gateway_failure(self) -> Optional[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")

    @property
    @pulumi.getter(name="enforcingConsecutiveErrors")
    def enforcing_consecutive_errors(self) -> Optional[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")

    @property
    @pulumi.getter(name="enforcingConsecutiveGatewayFailure")
    def enforcing_consecutive_gateway_failure(self) -> Optional[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")

    @property
    @pulumi.getter(name="enforcingSuccessRate")
    def enforcing_success_rate(self) -> Optional[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")

    @property
    @pulumi.getter
    def interval(self) -> Optional['outputs.RegionBackendServiceOutlierDetectionInterval']:
        """
        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")

    @property
    @pulumi.getter(name="maxEjectionPercent")
    def max_ejection_percent(self) -> Optional[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")

    @property
    @pulumi.getter(name="successRateMinimumHosts")
    def success_rate_minimum_hosts(self) -> Optional[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")

    @property
    @pulumi.getter(name="successRateRequestVolume")
    def success_rate_request_volume(self) -> Optional[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")

    @property
    @pulumi.getter(name="successRateStdevFactor")
    def success_rate_stdev_factor(self) -> Optional[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")


@pulumi.output_type
class RegionBackendServiceOutlierDetectionBaseEjectionTime(dict):
    def __init__(__self__, *,
                 seconds: int,
                 nanos: Optional[int] = None):
        """
        :param int seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
               inclusive.
        :param 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) -> 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")

    @property
    @pulumi.getter
    def nanos(self) -> Optional[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")


@pulumi.output_type
class RegionBackendServiceOutlierDetectionInterval(dict):
    def __init__(__self__, *,
                 seconds: int,
                 nanos: Optional[int] = None):
        """
        :param int seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000
               inclusive.
        :param 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) -> 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")

    @property
    @pulumi.getter
    def nanos(self) -> Optional[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")


@pulumi.output_type
class RegionBackendServiceSubsetting(dict):
    def __init__(__self__, *,
                 policy: str):
        """
        :param str policy: The algorithm used for subsetting.
               Possible values are `CONSISTENT_HASH_SUBSETTING`.
        """
        pulumi.set(__self__, "policy", policy)

    @property
    @pulumi.getter
    def policy(self) -> str:
        """
        The algorithm used for subsetting.
        Possible values are `CONSISTENT_HASH_SUBSETTING`.
        """
        return pulumi.get(self, "policy")


@pulumi.output_type
class RegionDiskDiskEncryptionKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kmsKeyName":
            suggest = "kms_key_name"
        elif key == "rawKey":
            suggest = "raw_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionDiskDiskEncryptionKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionDiskDiskEncryptionKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionDiskDiskEncryptionKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kms_key_name: Optional[str] = None,
                 raw_key: Optional[str] = None,
                 sha256: Optional[str] = None):
        """
        :param str kms_key_name: The name of the encryption key that is stored in Google Cloud KMS.
        :param 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 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[str]:
        """
        The name of the encryption key that is stored in Google Cloud KMS.
        """
        return pulumi.get(self, "kms_key_name")

    @property
    @pulumi.getter(name="rawKey")
    def raw_key(self) -> Optional[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")

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


@pulumi.output_type
class RegionDiskIamBindingCondition(dict):
    def __init__(__self__, *,
                 expression: str,
                 title: str,
                 description: Optional[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) -> str:
        return pulumi.get(self, "expression")

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

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


@pulumi.output_type
class RegionDiskIamMemberCondition(dict):
    def __init__(__self__, *,
                 expression: str,
                 title: str,
                 description: Optional[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) -> str:
        return pulumi.get(self, "expression")

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

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


@pulumi.output_type
class RegionDiskSourceSnapshotEncryptionKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kmsKeyName":
            suggest = "kms_key_name"
        elif key == "rawKey":
            suggest = "raw_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionDiskSourceSnapshotEncryptionKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionDiskSourceSnapshotEncryptionKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionDiskSourceSnapshotEncryptionKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kms_key_name: Optional[str] = None,
                 raw_key: Optional[str] = None,
                 sha256: Optional[str] = None):
        """
        :param str kms_key_name: The name of the encryption key that is stored in Google Cloud KMS.
        :param str raw_key: Specifies a 256-bit customer-supplied encryption key, encoded in
               RFC 4648 base64 to either encrypt or decrypt this resource.
        :param 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[str]:
        """
        The name of the encryption key that is stored in Google Cloud KMS.
        """
        return pulumi.get(self, "kms_key_name")

    @property
    @pulumi.getter(name="rawKey")
    def raw_key(self) -> Optional[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")

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


@pulumi.output_type
class RegionHealthCheckGrpcHealthCheck(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "grpcServiceName":
            suggest = "grpc_service_name"
        elif key == "portName":
            suggest = "port_name"
        elif key == "portSpecification":
            suggest = "port_specification"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionHealthCheckGrpcHealthCheck. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionHealthCheckGrpcHealthCheck.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionHealthCheckGrpcHealthCheck.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 grpc_service_name: Optional[str] = None,
                 port: Optional[int] = None,
                 port_name: Optional[str] = None,
                 port_specification: Optional[str] = None):
        """
        :param 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 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 str port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param str port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
        """
        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[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")

    @property
    @pulumi.getter
    def port(self) -> Optional[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")

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> Optional[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")

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[str]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        """
        return pulumi.get(self, "port_specification")


@pulumi.output_type
class RegionHealthCheckHttp2HealthCheck(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "portName":
            suggest = "port_name"
        elif key == "portSpecification":
            suggest = "port_specification"
        elif key == "proxyHeader":
            suggest = "proxy_header"
        elif key == "requestPath":
            suggest = "request_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionHealthCheckHttp2HealthCheck. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionHealthCheckHttp2HealthCheck.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionHealthCheckHttp2HealthCheck.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 host: Optional[str] = None,
                 port: Optional[int] = None,
                 port_name: Optional[str] = None,
                 port_specification: Optional[str] = None,
                 proxy_header: Optional[str] = None,
                 request_path: Optional[str] = None,
                 response: Optional[str] = None):
        """
        :param str host: The value of the host header in the HTTP health check request.
               If left empty (default value), the public IP on behalf of which this health
               check is performed will be used.
               (Optional)
               The value of the host header in the HTTPS health check request.
               If left empty (default value), the public IP on behalf of which this health
               check is performed will be used.
               (Optional)
               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 int port: The TCP port number for the HTTP health check request.
               The default value is 80.
               (Optional)
               The TCP port number for the HTTPS health check request.
               The default value is 443.
               (Optional)
               The TCP port number for the TCP health check request.
               The default value is 80.
               (Optional)
               The TCP port number for the SSL health check request.
               The default value is 443.
               (Optional)
               The TCP port number for the HTTP2 health check request.
               The default value is 443.
               (Optional)
               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 str port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
               (Optional)
               Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
               (Optional)
               Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
               (Optional)
               Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
               (Optional)
               Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
               (Optional)
               Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param str port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
               (Optional)
               Specifies how port is selected for health checking, can be one of the
               following values:
               (Optional)
               Specifies how port is selected for health checking, can be one of the
               following values:
               (Optional)
               Specifies how port is selected for health checking, can be one of the
               following values:
               (Optional)
               Specifies how port is selected for health checking, can be one of the
               following values:
               (Optional)
               Specifies how port is selected for health checking, can be one of the
               following values:
        :param 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`.
               (Optional)
               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`.
               (Optional)
               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`.
               (Optional)
               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`.
               (Optional)
               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 str request_path: The request path of the HTTP health check request.
               The default value is /.
               (Optional)
               The request path of the HTTPS health check request.
               The default value is /.
               (Optional)
               The request path of the HTTP2 health check request.
               The default value is /.
        :param 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.
               (Optional)
               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.
               (Optional)
               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.
               (Optional)
               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.
               (Optional)
               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[str]:
        """
        The value of the host header in the HTTP health check request.
        If left empty (default value), the public IP on behalf of which this health
        check is performed will be used.
        (Optional)
        The value of the host header in the HTTPS health check request.
        If left empty (default value), the public IP on behalf of which this health
        check is performed will be used.
        (Optional)
        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")

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        The TCP port number for the HTTP health check request.
        The default value is 80.
        (Optional)
        The TCP port number for the HTTPS health check request.
        The default value is 443.
        (Optional)
        The TCP port number for the TCP health check request.
        The default value is 80.
        (Optional)
        The TCP port number for the SSL health check request.
        The default value is 443.
        (Optional)
        The TCP port number for the HTTP2 health check request.
        The default value is 443.
        (Optional)
        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")

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

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[str]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        (Optional)
        Specifies how port is selected for health checking, can be one of the
        following values:
        (Optional)
        Specifies how port is selected for health checking, can be one of the
        following values:
        (Optional)
        Specifies how port is selected for health checking, can be one of the
        following values:
        (Optional)
        Specifies how port is selected for health checking, can be one of the
        following values:
        (Optional)
        Specifies how port is selected for health checking, can be one of the
        following values:
        """
        return pulumi.get(self, "port_specification")

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> Optional[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`.
        (Optional)
        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`.
        (Optional)
        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`.
        (Optional)
        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`.
        (Optional)
        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")

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

    @property
    @pulumi.getter
    def response(self) -> Optional[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.
        (Optional)
        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.
        (Optional)
        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.
        (Optional)
        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.
        (Optional)
        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")


@pulumi.output_type
class RegionHealthCheckHttpHealthCheck(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "portName":
            suggest = "port_name"
        elif key == "portSpecification":
            suggest = "port_specification"
        elif key == "proxyHeader":
            suggest = "proxy_header"
        elif key == "requestPath":
            suggest = "request_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionHealthCheckHttpHealthCheck. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionHealthCheckHttpHealthCheck.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionHealthCheckHttpHealthCheck.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 host: Optional[str] = None,
                 port: Optional[int] = None,
                 port_name: Optional[str] = None,
                 port_specification: Optional[str] = None,
                 proxy_header: Optional[str] = None,
                 request_path: Optional[str] = None,
                 response: Optional[str] = None):
        """
        :param str host: The value of the host header in the HTTP health check request.
               If left empty (default value), the public IP on behalf of which this health
               check is performed will be used.
        :param int port: The TCP port number for the HTTP health check request.
               The default value is 80.
        :param str port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param str port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
        :param 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 str request_path: The request path of the HTTP health check request.
               The default value is /.
        :param 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[str]:
        """
        The value of the host header in the HTTP 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")

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        The TCP port number for the HTTP health check request.
        The default value is 80.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> Optional[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")

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[str]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        """
        return pulumi.get(self, "port_specification")

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> Optional[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")

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

    @property
    @pulumi.getter
    def response(self) -> Optional[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")


@pulumi.output_type
class RegionHealthCheckHttpsHealthCheck(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "portName":
            suggest = "port_name"
        elif key == "portSpecification":
            suggest = "port_specification"
        elif key == "proxyHeader":
            suggest = "proxy_header"
        elif key == "requestPath":
            suggest = "request_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionHealthCheckHttpsHealthCheck. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionHealthCheckHttpsHealthCheck.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionHealthCheckHttpsHealthCheck.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 host: Optional[str] = None,
                 port: Optional[int] = None,
                 port_name: Optional[str] = None,
                 port_specification: Optional[str] = None,
                 proxy_header: Optional[str] = None,
                 request_path: Optional[str] = None,
                 response: Optional[str] = None):
        """
        :param str host: The value of the host header in the HTTPS health check request.
               If left empty (default value), the public IP on behalf of which this health
               check is performed will be used.
        :param int port: The TCP port number for the HTTPS health check request.
               The default value is 443.
        :param str port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param str port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
        :param 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 str request_path: The request path of the HTTPS health check request.
               The default value is /.
        :param 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[str]:
        """
        The value of the host header in the HTTPS 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")

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        The TCP port number for the HTTPS health check request.
        The default value is 443.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> Optional[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")

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[str]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        """
        return pulumi.get(self, "port_specification")

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> Optional[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")

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

    @property
    @pulumi.getter
    def response(self) -> Optional[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")


@pulumi.output_type
class RegionHealthCheckLogConfig(dict):
    def __init__(__self__, *,
                 enable: Optional[bool] = None):
        """
        :param 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[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")


@pulumi.output_type
class RegionHealthCheckSslHealthCheck(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "portName":
            suggest = "port_name"
        elif key == "portSpecification":
            suggest = "port_specification"
        elif key == "proxyHeader":
            suggest = "proxy_header"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionHealthCheckSslHealthCheck. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionHealthCheckSslHealthCheck.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionHealthCheckSslHealthCheck.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 port: Optional[int] = None,
                 port_name: Optional[str] = None,
                 port_specification: Optional[str] = None,
                 proxy_header: Optional[str] = None,
                 request: Optional[str] = None,
                 response: Optional[str] = None):
        """
        :param int port: The TCP port number for the HTTP2 health check request.
               The default value is 443.
        :param str port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param str port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
        :param 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 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 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[int]:
        """
        The TCP port number for the HTTP2 health check request.
        The default value is 443.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> Optional[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")

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[str]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        """
        return pulumi.get(self, "port_specification")

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> Optional[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")

    @property
    @pulumi.getter
    def request(self) -> Optional[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")

    @property
    @pulumi.getter
    def response(self) -> Optional[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")


@pulumi.output_type
class RegionHealthCheckTcpHealthCheck(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "portName":
            suggest = "port_name"
        elif key == "portSpecification":
            suggest = "port_specification"
        elif key == "proxyHeader":
            suggest = "proxy_header"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionHealthCheckTcpHealthCheck. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionHealthCheckTcpHealthCheck.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionHealthCheckTcpHealthCheck.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 port: Optional[int] = None,
                 port_name: Optional[str] = None,
                 port_specification: Optional[str] = None,
                 proxy_header: Optional[str] = None,
                 request: Optional[str] = None,
                 response: Optional[str] = None):
        """
        :param int port: The TCP port number for the TCP health check request.
               The default value is 80.
        :param str port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and
               port_name are defined, port takes precedence.
        :param str port_specification: Specifies how port is selected for health checking, can be one of the
               following values:
        :param 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 str request: The application data to send once the TCP 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 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[int]:
        """
        The TCP port number for the TCP health check request.
        The default value is 80.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> Optional[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")

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> Optional[str]:
        """
        Specifies how port is selected for health checking, can be one of the
        following values:
        """
        return pulumi.get(self, "port_specification")

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> Optional[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")

    @property
    @pulumi.getter
    def request(self) -> Optional[str]:
        """
        The application data to send once the TCP 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")

    @property
    @pulumi.getter
    def response(self) -> Optional[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")


@pulumi.output_type
class RegionInstanceGroupManagerAllInstancesConfig(dict):
    def __init__(__self__, *,
                 labels: Optional[Mapping[str, str]] = None,
                 metadata: Optional[Mapping[str, str]] = None):
        """
        :param Mapping[str, str] labels: ), The label key-value pairs that you want to patch onto the instance.
        :param Mapping[str, 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[Mapping[str, str]]:
        """
        ), The label key-value pairs that you want to patch onto the instance.
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter
    def metadata(self) -> Optional[Mapping[str, 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")


@pulumi.output_type
class RegionInstanceGroupManagerAutoHealingPolicies(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "healthCheck":
            suggest = "health_check"
        elif key == "initialDelaySec":
            suggest = "initial_delay_sec"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionInstanceGroupManagerAutoHealingPolicies. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionInstanceGroupManagerAutoHealingPolicies.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionInstanceGroupManagerAutoHealingPolicies.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 health_check: str,
                 initial_delay_sec: int):
        """
        :param str health_check: The health check resource that signals autohealing.
        :param 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) -> str:
        """
        The health check resource that signals autohealing.
        """
        return pulumi.get(self, "health_check")

    @property
    @pulumi.getter(name="initialDelaySec")
    def initial_delay_sec(self) -> 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")


@pulumi.output_type
class RegionInstanceGroupManagerInstanceLifecyclePolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "forceUpdateOnRepair":
            suggest = "force_update_on_repair"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionInstanceGroupManagerInstanceLifecyclePolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionInstanceGroupManagerInstanceLifecyclePolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionInstanceGroupManagerInstanceLifecyclePolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 force_update_on_repair: Optional[str] = None):
        """
        :param str force_update_on_repair: ), Specifies whether to apply the group's latest configuration when repairing a VM. Valid options are: YES, NO. If YES and you updated the group's instance template or per-instance configurations after the VM was created, then these changes are applied when VM is repaired. If NO (default), then updates are applied in accordance with the group's update policy type.
               - - -
        """
        if force_update_on_repair is not None:
            pulumi.set(__self__, "force_update_on_repair", force_update_on_repair)

    @property
    @pulumi.getter(name="forceUpdateOnRepair")
    def force_update_on_repair(self) -> Optional[str]:
        """
        ), Specifies whether to apply the group's latest configuration when repairing a VM. Valid options are: YES, NO. If YES and you updated the group's instance template or per-instance configurations after the VM was created, then these changes are applied when VM is repaired. If NO (default), then updates are applied in accordance with the group's update policy type.
        - - -
        """
        return pulumi.get(self, "force_update_on_repair")


@pulumi.output_type
class RegionInstanceGroupManagerNamedPort(dict):
    def __init__(__self__, *,
                 name: str,
                 port: int):
        """
        :param str name: The name of the port.
        :param int port: The port number.
               - - -
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the port.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number.
        - - -
        """
        return pulumi.get(self, "port")


@pulumi.output_type
class RegionInstanceGroupManagerStatefulDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deviceName":
            suggest = "device_name"
        elif key == "deleteRule":
            suggest = "delete_rule"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionInstanceGroupManagerStatefulDisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionInstanceGroupManagerStatefulDisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionInstanceGroupManagerStatefulDisk.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 device_name: str,
                 delete_rule: Optional[str] = None):
        """
        :param str device_name: , The device name of the disk to be attached.
        :param 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) -> str:
        """
        , The device name of the disk to be attached.
        """
        return pulumi.get(self, "device_name")

    @property
    @pulumi.getter(name="deleteRule")
    def delete_rule(self) -> Optional[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")


@pulumi.output_type
class RegionInstanceGroupManagerStatefulExternalIp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deleteRule":
            suggest = "delete_rule"
        elif key == "interfaceName":
            suggest = "interface_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionInstanceGroupManagerStatefulExternalIp. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionInstanceGroupManagerStatefulExternalIp.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionInstanceGroupManagerStatefulExternalIp.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 delete_rule: Optional[str] = None,
                 interface_name: Optional[str] = None):
        """
        :param str delete_rule: , A value that prescribes what should happen to the external ip when the VM instance is deleted. The available options are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`. `NEVER` - detach the ip when the VM is deleted, but do not delete the ip. `ON_PERMANENT_INSTANCE_DELETION` will delete the external ip when the VM is permanently deleted from the instance group.
        """
        if delete_rule is not None:
            pulumi.set(__self__, "delete_rule", delete_rule)
        if interface_name is not None:
            pulumi.set(__self__, "interface_name", interface_name)

    @property
    @pulumi.getter(name="deleteRule")
    def delete_rule(self) -> Optional[str]:
        """
        , A value that prescribes what should happen to the external ip when the VM instance is deleted. The available options are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`. `NEVER` - detach the ip when the VM is deleted, but do not delete the ip. `ON_PERMANENT_INSTANCE_DELETION` will delete the external ip when the VM is permanently deleted from the instance group.
        """
        return pulumi.get(self, "delete_rule")

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


@pulumi.output_type
class RegionInstanceGroupManagerStatefulInternalIp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deleteRule":
            suggest = "delete_rule"
        elif key == "interfaceName":
            suggest = "interface_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionInstanceGroupManagerStatefulInternalIp. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionInstanceGroupManagerStatefulInternalIp.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionInstanceGroupManagerStatefulInternalIp.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 delete_rule: Optional[str] = None,
                 interface_name: Optional[str] = None):
        """
        :param str delete_rule: , A value that prescribes what should happen to the internal ip when the VM instance is deleted. The available options are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`. `NEVER` - detach the ip when the VM is deleted, but do not delete the ip. `ON_PERMANENT_INSTANCE_DELETION` will delete the internal ip when the VM is permanently deleted from the instance group.
        """
        if delete_rule is not None:
            pulumi.set(__self__, "delete_rule", delete_rule)
        if interface_name is not None:
            pulumi.set(__self__, "interface_name", interface_name)

    @property
    @pulumi.getter(name="deleteRule")
    def delete_rule(self) -> Optional[str]:
        """
        , A value that prescribes what should happen to the internal ip when the VM instance is deleted. The available options are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`. `NEVER` - detach the ip when the VM is deleted, but do not delete the ip. `ON_PERMANENT_INSTANCE_DELETION` will delete the internal ip when the VM is permanently deleted from the instance group.
        """
        return pulumi.get(self, "delete_rule")

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


@pulumi.output_type
class RegionInstanceGroupManagerStatus(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allInstancesConfigs":
            suggest = "all_instances_configs"
        elif key == "isStable":
            suggest = "is_stable"
        elif key == "versionTargets":
            suggest = "version_targets"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionInstanceGroupManagerStatus. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionInstanceGroupManagerStatus.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionInstanceGroupManagerStatus.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 all_instances_configs: Optional[Sequence['outputs.RegionInstanceGroupManagerStatusAllInstancesConfig']] = None,
                 is_stable: Optional[bool] = None,
                 statefuls: Optional[Sequence['outputs.RegionInstanceGroupManagerStatusStateful']] = None,
                 version_targets: Optional[Sequence['outputs.RegionInstanceGroupManagerStatusVersionTarget']] = None):
        """
        :param Sequence['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 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 Sequence['RegionInstanceGroupManagerStatusStatefulArgs'] statefuls: Stateful status of the given Instance Group Manager.
        :param Sequence['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[Sequence['outputs.RegionInstanceGroupManagerStatusAllInstancesConfig']]:
        """
        )
        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")

    @property
    @pulumi.getter(name="isStable")
    def is_stable(self) -> Optional[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")

    @property
    @pulumi.getter
    def statefuls(self) -> Optional[Sequence['outputs.RegionInstanceGroupManagerStatusStateful']]:
        """
        Stateful status of the given Instance Group Manager.
        """
        return pulumi.get(self, "statefuls")

    @property
    @pulumi.getter(name="versionTargets")
    def version_targets(self) -> Optional[Sequence['outputs.RegionInstanceGroupManagerStatusVersionTarget']]:
        """
        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")


@pulumi.output_type
class RegionInstanceGroupManagerStatusAllInstancesConfig(dict):
    def __init__(__self__, *,
                 effective: Optional[bool] = None):
        if effective is not None:
            pulumi.set(__self__, "effective", effective)

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


@pulumi.output_type
class RegionInstanceGroupManagerStatusStateful(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hasStatefulConfig":
            suggest = "has_stateful_config"
        elif key == "perInstanceConfigs":
            suggest = "per_instance_configs"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionInstanceGroupManagerStatusStateful. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionInstanceGroupManagerStatusStateful.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionInstanceGroupManagerStatusStateful.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 has_stateful_config: Optional[bool] = None,
                 per_instance_configs: Optional[Sequence['outputs.RegionInstanceGroupManagerStatusStatefulPerInstanceConfig']] = None):
        """
        :param 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 Sequence['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[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")

    @property
    @pulumi.getter(name="perInstanceConfigs")
    def per_instance_configs(self) -> Optional[Sequence['outputs.RegionInstanceGroupManagerStatusStatefulPerInstanceConfig']]:
        """
        Status of per-instance configs on the instance.
        """
        return pulumi.get(self, "per_instance_configs")


@pulumi.output_type
class RegionInstanceGroupManagerStatusStatefulPerInstanceConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allEffective":
            suggest = "all_effective"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionInstanceGroupManagerStatusStatefulPerInstanceConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionInstanceGroupManagerStatusStatefulPerInstanceConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionInstanceGroupManagerStatusStatefulPerInstanceConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 all_effective: Optional[bool] = None):
        """
        :param 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[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")


@pulumi.output_type
class RegionInstanceGroupManagerStatusVersionTarget(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isReached":
            suggest = "is_reached"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionInstanceGroupManagerStatusVersionTarget. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionInstanceGroupManagerStatusVersionTarget.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionInstanceGroupManagerStatusVersionTarget.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 is_reached: Optional[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[bool]:
        return pulumi.get(self, "is_reached")


@pulumi.output_type
class RegionInstanceGroupManagerUpdatePolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "minimalAction":
            suggest = "minimal_action"
        elif key == "instanceRedistributionType":
            suggest = "instance_redistribution_type"
        elif key == "maxSurgeFixed":
            suggest = "max_surge_fixed"
        elif key == "maxSurgePercent":
            suggest = "max_surge_percent"
        elif key == "maxUnavailableFixed":
            suggest = "max_unavailable_fixed"
        elif key == "maxUnavailablePercent":
            suggest = "max_unavailable_percent"
        elif key == "minReadySec":
            suggest = "min_ready_sec"
        elif key == "mostDisruptiveAllowedAction":
            suggest = "most_disruptive_allowed_action"
        elif key == "replacementMethod":
            suggest = "replacement_method"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionInstanceGroupManagerUpdatePolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionInstanceGroupManagerUpdatePolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionInstanceGroupManagerUpdatePolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 minimal_action: str,
                 type: str,
                 instance_redistribution_type: Optional[str] = None,
                 max_surge_fixed: Optional[int] = None,
                 max_surge_percent: Optional[int] = None,
                 max_unavailable_fixed: Optional[int] = None,
                 max_unavailable_percent: Optional[int] = None,
                 min_ready_sec: Optional[int] = None,
                 most_disruptive_allowed_action: Optional[str] = None,
                 replacement_method: Optional[str] = None):
        """
        :param 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 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 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 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 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 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 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 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 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 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) -> 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")

    @property
    @pulumi.getter
    def type(self) -> 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")

    @property
    @pulumi.getter(name="instanceRedistributionType")
    def instance_redistribution_type(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxSurgeFixed")
    def max_surge_fixed(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxSurgePercent")
    def max_surge_percent(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxUnavailableFixed")
    def max_unavailable_fixed(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxUnavailablePercent")
    def max_unavailable_percent(self) -> Optional[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")

    @property
    @pulumi.getter(name="minReadySec")
    def min_ready_sec(self) -> Optional[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")

    @property
    @pulumi.getter(name="mostDisruptiveAllowedAction")
    def most_disruptive_allowed_action(self) -> Optional[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")

    @property
    @pulumi.getter(name="replacementMethod")
    def replacement_method(self) -> Optional[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")


@pulumi.output_type
class RegionInstanceGroupManagerVersion(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceTemplate":
            suggest = "instance_template"
        elif key == "targetSize":
            suggest = "target_size"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionInstanceGroupManagerVersion. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionInstanceGroupManagerVersion.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionInstanceGroupManagerVersion.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 instance_template: str,
                 name: Optional[str] = None,
                 target_size: Optional['outputs.RegionInstanceGroupManagerVersionTargetSize'] = None):
        """
        :param str instance_template: The full URL to an instance template from which all new instances of this version will be created.
        :param str name: Version name.
        :param '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) -> 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")

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

    @property
    @pulumi.getter(name="targetSize")
    def target_size(self) -> Optional['outputs.RegionInstanceGroupManagerVersionTargetSize']:
        """
        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")


@pulumi.output_type
class RegionInstanceGroupManagerVersionTargetSize(dict):
    def __init__(__self__, *,
                 fixed: Optional[int] = None,
                 percent: Optional[int] = None):
        """
        :param int fixed: , The number of instances which are managed for this version. Conflicts with `percent`.
        :param 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[int]:
        """
        , The number of instances which are managed for this version. Conflicts with `percent`.
        """
        return pulumi.get(self, "fixed")

    @property
    @pulumi.getter
    def percent(self) -> Optional[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")


@pulumi.output_type
class RegionNetworkEndpointGroupAppEngine(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "urlMask":
            suggest = "url_mask"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionNetworkEndpointGroupAppEngine. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionNetworkEndpointGroupAppEngine.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionNetworkEndpointGroupAppEngine.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 service: Optional[str] = None,
                 url_mask: Optional[str] = None,
                 version: Optional[str] = None):
        """
        :param str service: Optional serving service.
               The service name must be 1-63 characters long, and comply with RFC1035.
               Example value: "default", "my-service".
        :param str url_mask: A template to parse service and version fields from a request URL.
               URL mask allows for routing to multiple App Engine services without
               having to create multiple Network Endpoint Groups and backend services.
               For example, the request URLs "foo1-dot-appname.appspot.com/v1" and
               "foo1-dot-appname.appspot.com/v2" can be backed by the same Serverless NEG with
               URL mask "-dot-appname.appspot.com/". The URL mask will parse
               them to { service = "foo1", version = "v1" } and { service = "foo1", version = "v2" } respectively.
        :param str version: Optional serving version.
               The version must be 1-63 characters long, and comply with RFC1035.
               Example value: "v1", "v2".
        """
        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[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")

    @property
    @pulumi.getter(name="urlMask")
    def url_mask(self) -> Optional[str]:
        """
        A template to parse service and version fields from a request URL.
        URL mask allows for routing to multiple App Engine services without
        having to create multiple Network Endpoint Groups and backend services.
        For example, the request URLs "foo1-dot-appname.appspot.com/v1" and
        "foo1-dot-appname.appspot.com/v2" can be backed by the same Serverless NEG with
        URL mask "-dot-appname.appspot.com/". The URL mask will parse
        them to { service = "foo1", version = "v1" } and { service = "foo1", version = "v2" } respectively.
        """
        return pulumi.get(self, "url_mask")

    @property
    @pulumi.getter
    def version(self) -> Optional[str]:
        """
        Optional serving version.
        The version must be 1-63 characters long, and comply with RFC1035.
        Example value: "v1", "v2".
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class RegionNetworkEndpointGroupCloudFunction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "urlMask":
            suggest = "url_mask"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionNetworkEndpointGroupCloudFunction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionNetworkEndpointGroupCloudFunction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionNetworkEndpointGroupCloudFunction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 function: Optional[str] = None,
                 url_mask: Optional[str] = None):
        """
        :param 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 str url_mask: A template to parse function field from a request URL. URL mask allows
               for routing to multiple Cloud Functions without having to create
               multiple Network Endpoint Groups and backend services.
               For example, request URLs "mydomain.com/function1" and "mydomain.com/function2"
               can be backed by the same Serverless NEG with URL mask "/". The URL mask
               will parse them to { function = "function1" } and { function = "function2" } respectively.
        """
        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[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")

    @property
    @pulumi.getter(name="urlMask")
    def url_mask(self) -> Optional[str]:
        """
        A template to parse function field from a request URL. URL mask allows
        for routing to multiple Cloud Functions without having to create
        multiple Network Endpoint Groups and backend services.
        For example, request URLs "mydomain.com/function1" and "mydomain.com/function2"
        can be backed by the same Serverless NEG with URL mask "/". The URL mask
        will parse them to { function = "function1" } and { function = "function2" } respectively.
        """
        return pulumi.get(self, "url_mask")


@pulumi.output_type
class RegionNetworkEndpointGroupCloudRun(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "urlMask":
            suggest = "url_mask"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionNetworkEndpointGroupCloudRun. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionNetworkEndpointGroupCloudRun.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionNetworkEndpointGroupCloudRun.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 service: Optional[str] = None,
                 tag: Optional[str] = None,
                 url_mask: Optional[str] = None):
        """
        :param str service: Cloud Run service is the main resource of Cloud Run.
               The service must be 1-63 characters long, and comply with RFC1035.
               Example value: "run-service".
        :param 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 str url_mask: A template to parse service and tag fields from a request URL.
               URL mask allows for routing to multiple Run services without having
               to create multiple network endpoint groups and backend services.
               For example, request URLs "foo1.domain.com/bar1" and "foo1.domain.com/bar2"
               an be backed by the same Serverless Network Endpoint Group (NEG) with
               URL mask ".domain.com/". The URL mask will parse them to { service="bar1", tag="foo1" }
               and { service="bar2", tag="foo2" } respectively.
        """
        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[str]:
        """
        Cloud Run service is the main resource of Cloud Run.
        The service must be 1-63 characters long, and comply with RFC1035.
        Example value: "run-service".
        """
        return pulumi.get(self, "service")

    @property
    @pulumi.getter
    def tag(self) -> Optional[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")

    @property
    @pulumi.getter(name="urlMask")
    def url_mask(self) -> Optional[str]:
        """
        A template to parse service and tag fields from a request URL.
        URL mask allows for routing to multiple Run services without having
        to create multiple network endpoint groups and backend services.
        For example, request URLs "foo1.domain.com/bar1" and "foo1.domain.com/bar2"
        an be backed by the same Serverless Network Endpoint Group (NEG) with
        URL mask ".domain.com/". The URL mask will parse them to { service="bar1", tag="foo1" }
        and { service="bar2", tag="foo2" } respectively.
        """
        return pulumi.get(self, "url_mask")


@pulumi.output_type
class RegionNetworkEndpointGroupServerlessDeployment(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "urlMask":
            suggest = "url_mask"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionNetworkEndpointGroupServerlessDeployment. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionNetworkEndpointGroupServerlessDeployment.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionNetworkEndpointGroupServerlessDeployment.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 platform: str,
                 resource: Optional[str] = None,
                 url_mask: Optional[str] = None,
                 version: Optional[str] = None):
        """
        :param str platform: The platform of the NEG backend target(s). Possible values:
               API Gateway: apigateway.googleapis.com
        :param 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 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 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) -> str:
        """
        The platform of the NEG backend target(s). Possible values:
        API Gateway: apigateway.googleapis.com
        """
        return pulumi.get(self, "platform")

    @property
    @pulumi.getter
    def resource(self) -> Optional[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")

    @property
    @pulumi.getter(name="urlMask")
    def url_mask(self) -> Optional[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")

    @property
    @pulumi.getter
    def version(self) -> Optional[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")


@pulumi.output_type
class RegionNetworkFirewallPolicyRuleMatch(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "layer4Configs":
            suggest = "layer4_configs"
        elif key == "destIpRanges":
            suggest = "dest_ip_ranges"
        elif key == "srcIpRanges":
            suggest = "src_ip_ranges"
        elif key == "srcSecureTags":
            suggest = "src_secure_tags"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionNetworkFirewallPolicyRuleMatch. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionNetworkFirewallPolicyRuleMatch.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionNetworkFirewallPolicyRuleMatch.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 layer4_configs: Sequence['outputs.RegionNetworkFirewallPolicyRuleMatchLayer4Config'],
                 dest_ip_ranges: Optional[Sequence[str]] = None,
                 src_ip_ranges: Optional[Sequence[str]] = None,
                 src_secure_tags: Optional[Sequence['outputs.RegionNetworkFirewallPolicyRuleMatchSrcSecureTag']] = None):
        """
        :param Sequence['RegionNetworkFirewallPolicyRuleMatchLayer4ConfigArgs'] layer4_configs: Pairs of IP protocols and ports that the rule should match.
        :param Sequence[str] dest_ip_ranges: CIDR IP address range. Maximum number of destination CIDR IP ranges allowed is 5000.
        :param Sequence[str] src_ip_ranges: CIDR IP address range. Maximum number of source CIDR IP ranges allowed is 5000.
        :param Sequence['RegionNetworkFirewallPolicyRuleMatchSrcSecureTagArgs'] src_secure_tags: List of secure tag values, which should be matched at the source of the traffic. For INGRESS rule, if all the <code>srcSecureTag</code> are INEFFECTIVE, and there is no <code>srcIpRange</code>, this rule will be ignored. Maximum number of source tag values 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)
        if src_secure_tags is not None:
            pulumi.set(__self__, "src_secure_tags", src_secure_tags)

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

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

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

    @property
    @pulumi.getter(name="srcSecureTags")
    def src_secure_tags(self) -> Optional[Sequence['outputs.RegionNetworkFirewallPolicyRuleMatchSrcSecureTag']]:
        """
        List of secure tag values, which should be matched at the source of the traffic. For INGRESS rule, if all the <code>srcSecureTag</code> are INEFFECTIVE, and there is no <code>srcIpRange</code>, this rule will be ignored. Maximum number of source tag values allowed is 256.
        """
        return pulumi.get(self, "src_secure_tags")


@pulumi.output_type
class RegionNetworkFirewallPolicyRuleMatchLayer4Config(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipProtocol":
            suggest = "ip_protocol"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionNetworkFirewallPolicyRuleMatchLayer4Config. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionNetworkFirewallPolicyRuleMatchLayer4Config.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionNetworkFirewallPolicyRuleMatchLayer4Config.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ip_protocol: str,
                 ports: Optional[Sequence[str]] = None):
        """
        :param 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 Sequence[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) -> 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")

    @property
    @pulumi.getter
    def ports(self) -> Optional[Sequence[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")


@pulumi.output_type
class RegionNetworkFirewallPolicyRuleMatchSrcSecureTag(dict):
    def __init__(__self__, *,
                 name: str,
                 state: Optional[str] = None):
        """
        :param str name: Name of the secure tag, created with TagManager's TagValue API. @pattern tagValues/[0-9]+
        :param str state: [Output Only] State of the secure tag, either `EFFECTIVE` or `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted or its network is deleted.
        """
        pulumi.set(__self__, "name", name)
        if state is not None:
            pulumi.set(__self__, "state", state)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the secure tag, created with TagManager's TagValue API. @pattern tagValues/[0-9]+
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def state(self) -> Optional[str]:
        """
        [Output Only] State of the secure tag, either `EFFECTIVE` or `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted or its network is deleted.
        """
        return pulumi.get(self, "state")


@pulumi.output_type
class RegionNetworkFirewallPolicyRuleTargetSecureTag(dict):
    def __init__(__self__, *,
                 name: str,
                 state: Optional[str] = None):
        """
        :param str name: Name of the secure tag, created with TagManager's TagValue API. @pattern tagValues/[0-9]+
        :param str state: [Output Only] State of the secure tag, either `EFFECTIVE` or `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted or its network is deleted.
        """
        pulumi.set(__self__, "name", name)
        if state is not None:
            pulumi.set(__self__, "state", state)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the secure tag, created with TagManager's TagValue API. @pattern tagValues/[0-9]+
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def state(self) -> Optional[str]:
        """
        [Output Only] State of the secure tag, either `EFFECTIVE` or `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted or its network is deleted.
        """
        return pulumi.get(self, "state")


@pulumi.output_type
class RegionPerInstanceConfigPreservedState(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "externalIps":
            suggest = "external_ips"
        elif key == "internalIps":
            suggest = "internal_ips"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionPerInstanceConfigPreservedState. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionPerInstanceConfigPreservedState.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionPerInstanceConfigPreservedState.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 disks: Optional[Sequence['outputs.RegionPerInstanceConfigPreservedStateDisk']] = None,
                 external_ips: Optional[Sequence['outputs.RegionPerInstanceConfigPreservedStateExternalIp']] = None,
                 internal_ips: Optional[Sequence['outputs.RegionPerInstanceConfigPreservedStateInternalIp']] = None,
                 metadata: Optional[Mapping[str, str]] = None):
        """
        :param Sequence['RegionPerInstanceConfigPreservedStateDiskArgs'] disks: Stateful disks for the instance.
               Structure is documented below.
        :param Mapping[str, 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 external_ips is not None:
            pulumi.set(__self__, "external_ips", external_ips)
        if internal_ips is not None:
            pulumi.set(__self__, "internal_ips", internal_ips)
        if metadata is not None:
            pulumi.set(__self__, "metadata", metadata)

    @property
    @pulumi.getter
    def disks(self) -> Optional[Sequence['outputs.RegionPerInstanceConfigPreservedStateDisk']]:
        """
        Stateful disks for the instance.
        Structure is documented below.
        """
        return pulumi.get(self, "disks")

    @property
    @pulumi.getter(name="externalIps")
    def external_ips(self) -> Optional[Sequence['outputs.RegionPerInstanceConfigPreservedStateExternalIp']]:
        return pulumi.get(self, "external_ips")

    @property
    @pulumi.getter(name="internalIps")
    def internal_ips(self) -> Optional[Sequence['outputs.RegionPerInstanceConfigPreservedStateInternalIp']]:
        return pulumi.get(self, "internal_ips")

    @property
    @pulumi.getter
    def metadata(self) -> Optional[Mapping[str, str]]:
        """
        Preserved metadata defined for this instance. This is a list of key->value pairs.
        """
        return pulumi.get(self, "metadata")


@pulumi.output_type
class RegionPerInstanceConfigPreservedStateDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deviceName":
            suggest = "device_name"
        elif key == "deleteRule":
            suggest = "delete_rule"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionPerInstanceConfigPreservedStateDisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionPerInstanceConfigPreservedStateDisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionPerInstanceConfigPreservedStateDisk.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 device_name: str,
                 source: str,
                 delete_rule: Optional[str] = None,
                 mode: Optional[str] = None):
        """
        :param str device_name: A unique device name that is reflected into the /dev/ tree of a Linux operating system running within the instance.
        :param 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 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 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) -> 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")

    @property
    @pulumi.getter
    def source(self) -> 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")

    @property
    @pulumi.getter(name="deleteRule")
    def delete_rule(self) -> Optional[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")

    @property
    @pulumi.getter
    def mode(self) -> Optional[str]:
        """
        The mode of the disk.
        Default value is `READ_WRITE`.
        Possible values are `READ_ONLY` and `READ_WRITE`.
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class RegionPerInstanceConfigPreservedStateExternalIp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "interfaceName":
            suggest = "interface_name"
        elif key == "autoDelete":
            suggest = "auto_delete"
        elif key == "ipAddress":
            suggest = "ip_address"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionPerInstanceConfigPreservedStateExternalIp. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionPerInstanceConfigPreservedStateExternalIp.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionPerInstanceConfigPreservedStateExternalIp.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 interface_name: str,
                 auto_delete: Optional[str] = None,
                 ip_address: Optional['outputs.RegionPerInstanceConfigPreservedStateExternalIpIpAddress'] = None):
        """
        :param str interface_name: The identifier for this object. Format specified above.
        :param str auto_delete: These stateful IPs will never be released during autohealing, update or VM instance recreate operations. This flag is used to configure if the IP reservation should be deleted after it is no longer used by the group, e.g. when the given instance or the whole group is deleted.
               Default value is `NEVER`.
               Possible values are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`.
        :param 'RegionPerInstanceConfigPreservedStateExternalIpIpAddressArgs' ip_address: Ip address representation
               Structure is documented below.
        """
        pulumi.set(__self__, "interface_name", interface_name)
        if auto_delete is not None:
            pulumi.set(__self__, "auto_delete", auto_delete)
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)

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

    @property
    @pulumi.getter(name="autoDelete")
    def auto_delete(self) -> Optional[str]:
        """
        These stateful IPs will never be released during autohealing, update or VM instance recreate operations. This flag is used to configure if the IP reservation should be deleted after it is no longer used by the group, e.g. when the given instance or the whole group is deleted.
        Default value is `NEVER`.
        Possible values are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`.
        """
        return pulumi.get(self, "auto_delete")

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> Optional['outputs.RegionPerInstanceConfigPreservedStateExternalIpIpAddress']:
        """
        Ip address representation
        Structure is documented below.
        """
        return pulumi.get(self, "ip_address")


@pulumi.output_type
class RegionPerInstanceConfigPreservedStateExternalIpIpAddress(dict):
    def __init__(__self__, *,
                 address: Optional[str] = None):
        """
        :param str address: The URL of the reservation for this IP address.
        """
        if address is not None:
            pulumi.set(__self__, "address", address)

    @property
    @pulumi.getter
    def address(self) -> Optional[str]:
        """
        The URL of the reservation for this IP address.
        """
        return pulumi.get(self, "address")


@pulumi.output_type
class RegionPerInstanceConfigPreservedStateInternalIp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "interfaceName":
            suggest = "interface_name"
        elif key == "autoDelete":
            suggest = "auto_delete"
        elif key == "ipAddress":
            suggest = "ip_address"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionPerInstanceConfigPreservedStateInternalIp. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionPerInstanceConfigPreservedStateInternalIp.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionPerInstanceConfigPreservedStateInternalIp.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 interface_name: str,
                 auto_delete: Optional[str] = None,
                 ip_address: Optional['outputs.RegionPerInstanceConfigPreservedStateInternalIpIpAddress'] = None):
        """
        :param str interface_name: The identifier for this object. Format specified above.
        :param str auto_delete: These stateful IPs will never be released during autohealing, update or VM instance recreate operations. This flag is used to configure if the IP reservation should be deleted after it is no longer used by the group, e.g. when the given instance or the whole group is deleted.
               Default value is `NEVER`.
               Possible values are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`.
        :param 'RegionPerInstanceConfigPreservedStateInternalIpIpAddressArgs' ip_address: Ip address representation
               Structure is documented below.
        """
        pulumi.set(__self__, "interface_name", interface_name)
        if auto_delete is not None:
            pulumi.set(__self__, "auto_delete", auto_delete)
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)

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

    @property
    @pulumi.getter(name="autoDelete")
    def auto_delete(self) -> Optional[str]:
        """
        These stateful IPs will never be released during autohealing, update or VM instance recreate operations. This flag is used to configure if the IP reservation should be deleted after it is no longer used by the group, e.g. when the given instance or the whole group is deleted.
        Default value is `NEVER`.
        Possible values are `NEVER` and `ON_PERMANENT_INSTANCE_DELETION`.
        """
        return pulumi.get(self, "auto_delete")

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> Optional['outputs.RegionPerInstanceConfigPreservedStateInternalIpIpAddress']:
        """
        Ip address representation
        Structure is documented below.
        """
        return pulumi.get(self, "ip_address")


@pulumi.output_type
class RegionPerInstanceConfigPreservedStateInternalIpIpAddress(dict):
    def __init__(__self__, *,
                 address: Optional[str] = None):
        """
        :param str address: The URL of the reservation for this IP address.
        """
        if address is not None:
            pulumi.set(__self__, "address", address)

    @property
    @pulumi.getter
    def address(self) -> Optional[str]:
        """
        The URL of the reservation for this IP address.
        """
        return pulumi.get(self, "address")


@pulumi.output_type
class RegionUrlMapDefaultRouteAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "corsPolicy":
            suggest = "cors_policy"
        elif key == "faultInjectionPolicy":
            suggest = "fault_injection_policy"
        elif key == "requestMirrorPolicy":
            suggest = "request_mirror_policy"
        elif key == "retryPolicy":
            suggest = "retry_policy"
        elif key == "urlRewrite":
            suggest = "url_rewrite"
        elif key == "weightedBackendServices":
            suggest = "weighted_backend_services"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapDefaultRouteAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapDefaultRouteAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapDefaultRouteAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cors_policy: Optional['outputs.RegionUrlMapDefaultRouteActionCorsPolicy'] = None,
                 fault_injection_policy: Optional['outputs.RegionUrlMapDefaultRouteActionFaultInjectionPolicy'] = None,
                 request_mirror_policy: Optional['outputs.RegionUrlMapDefaultRouteActionRequestMirrorPolicy'] = None,
                 retry_policy: Optional['outputs.RegionUrlMapDefaultRouteActionRetryPolicy'] = None,
                 timeout: Optional['outputs.RegionUrlMapDefaultRouteActionTimeout'] = None,
                 url_rewrite: Optional['outputs.RegionUrlMapDefaultRouteActionUrlRewrite'] = None,
                 weighted_backend_services: Optional[Sequence['outputs.RegionUrlMapDefaultRouteActionWeightedBackendService']] = None):
        """
        :param 'RegionUrlMapDefaultRouteActionCorsPolicyArgs' 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 'RegionUrlMapDefaultRouteActionFaultInjectionPolicyArgs' 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 a load balancer on a percentage of requests before sending those requests to the backend service.
               Similarly requests from clients can be aborted by the load balancer for a percentage of requests.
               timeout and retryPolicy is ignored by clients that are configured with a faultInjectionPolicy if: 1. The traffic is generated by fault injection AND 2. The fault injection is not a delay fault injection.
               Fault injection is not supported with the global external HTTP(S) load balancer (classic). To see which load balancers support fault injection, see Load balancing: [Routing and traffic management features](https://cloud.google.com/load-balancing/docs/features#routing-traffic-management).
               Structure is documented below.
        :param 'RegionUrlMapDefaultRouteActionRequestMirrorPolicyArgs' request_mirror_policy: Specifies the policy on how requests intended for the route's backends are shadowed to a separate mirrored backend service.
               The load balancer does not wait for responses from the shadow service. Before sending traffic to the shadow service, the host / authority header is suffixed with -shadow.
               Not supported when the URL map is bound to a target gRPC proxy that has the validateForProxyless field set to true.
               Structure is documented below.
        :param 'RegionUrlMapDefaultRouteActionRetryPolicyArgs' retry_policy: Specifies the retry policy associated with this route.
               Structure is documented below.
        :param 'RegionUrlMapDefaultRouteActionTimeoutArgs' timeout: Specifies the timeout for the selected route. Timeout is computed from the time the request has been fully processed (known as end-of-stream) up until the response has been processed. Timeout includes all retries.
               If not specified, this field uses the largest timeout among all backend services associated with the route.
               Not supported when the URL map is bound to a target gRPC proxy that has validateForProxyless field set to true.
               Structure is documented below.
        :param 'RegionUrlMapDefaultRouteActionUrlRewriteArgs' url_rewrite: The spec to modify the URL of the request, before forwarding the request to the matched service.
               urlRewrite is the only action supported in UrlMaps for external HTTP(S) load balancers.
               Not supported when the URL map is bound to a target gRPC proxy that has the validateForProxyless field set to true.
               Structure is documented below.
        :param Sequence['RegionUrlMapDefaultRouteActionWeightedBackendServiceArgs'] 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-zero number.
               After a backend service is identified and before forwarding the request to the backend service, advanced routing actions such as 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['outputs.RegionUrlMapDefaultRouteActionCorsPolicy']:
        """
        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")

    @property
    @pulumi.getter(name="faultInjectionPolicy")
    def fault_injection_policy(self) -> Optional['outputs.RegionUrlMapDefaultRouteActionFaultInjectionPolicy']:
        """
        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 a load balancer on a percentage of requests before sending those requests to the backend service.
        Similarly requests from clients can be aborted by the load balancer for a percentage of requests.
        timeout and retryPolicy is ignored by clients that are configured with a faultInjectionPolicy if: 1. The traffic is generated by fault injection AND 2. The fault injection is not a delay fault injection.
        Fault injection is not supported with the global external HTTP(S) load balancer (classic). To see which load balancers support fault injection, see Load balancing: [Routing and traffic management features](https://cloud.google.com/load-balancing/docs/features#routing-traffic-management).
        Structure is documented below.
        """
        return pulumi.get(self, "fault_injection_policy")

    @property
    @pulumi.getter(name="requestMirrorPolicy")
    def request_mirror_policy(self) -> Optional['outputs.RegionUrlMapDefaultRouteActionRequestMirrorPolicy']:
        """
        Specifies the policy on how requests intended for the route's backends are shadowed to a separate mirrored backend service.
        The load balancer does not wait for responses from the shadow service. Before sending traffic to the shadow service, the host / authority header is suffixed with -shadow.
        Not supported when the URL map is bound to a target gRPC proxy that has the validateForProxyless field set to true.
        Structure is documented below.
        """
        return pulumi.get(self, "request_mirror_policy")

    @property
    @pulumi.getter(name="retryPolicy")
    def retry_policy(self) -> Optional['outputs.RegionUrlMapDefaultRouteActionRetryPolicy']:
        """
        Specifies the retry policy associated with this route.
        Structure is documented below.
        """
        return pulumi.get(self, "retry_policy")

    @property
    @pulumi.getter
    def timeout(self) -> Optional['outputs.RegionUrlMapDefaultRouteActionTimeout']:
        """
        Specifies the timeout for the selected route. Timeout is computed from the time the request has been fully processed (known as end-of-stream) up until the response has been processed. Timeout includes all retries.
        If not specified, this field uses the largest timeout among all backend services associated with the route.
        Not supported when the URL map is bound to a target gRPC proxy that has validateForProxyless field set to true.
        Structure is documented below.
        """
        return pulumi.get(self, "timeout")

    @property
    @pulumi.getter(name="urlRewrite")
    def url_rewrite(self) -> Optional['outputs.RegionUrlMapDefaultRouteActionUrlRewrite']:
        """
        The spec to modify the URL of the request, before forwarding the request to the matched service.
        urlRewrite is the only action supported in UrlMaps for external HTTP(S) load balancers.
        Not supported when the URL map is bound to a target gRPC proxy that has the validateForProxyless field set to true.
        Structure is documented below.
        """
        return pulumi.get(self, "url_rewrite")

    @property
    @pulumi.getter(name="weightedBackendServices")
    def weighted_backend_services(self) -> Optional[Sequence['outputs.RegionUrlMapDefaultRouteActionWeightedBackendService']]:
        """
        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-zero number.
        After a backend service is identified and before forwarding the request to the backend service, advanced routing actions such as 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")


@pulumi.output_type
class RegionUrlMapDefaultRouteActionCorsPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowCredentials":
            suggest = "allow_credentials"
        elif key == "allowHeaders":
            suggest = "allow_headers"
        elif key == "allowMethods":
            suggest = "allow_methods"
        elif key == "allowOriginRegexes":
            suggest = "allow_origin_regexes"
        elif key == "allowOrigins":
            suggest = "allow_origins"
        elif key == "exposeHeaders":
            suggest = "expose_headers"
        elif key == "maxAge":
            suggest = "max_age"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapDefaultRouteActionCorsPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapDefaultRouteActionCorsPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapDefaultRouteActionCorsPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 allow_credentials: Optional[bool] = None,
                 allow_headers: Optional[Sequence[str]] = None,
                 allow_methods: Optional[Sequence[str]] = None,
                 allow_origin_regexes: Optional[Sequence[str]] = None,
                 allow_origins: Optional[Sequence[str]] = None,
                 disabled: Optional[bool] = None,
                 expose_headers: Optional[Sequence[str]] = None,
                 max_age: Optional[int] = None):
        """
        :param bool allow_credentials: In response to a preflight request, setting this to true indicates that the actual request can include user credentials. This field translates to the Access-Control-Allow-Credentials header.
               Default is false.
        :param Sequence[str] allow_headers: Specifies the content for the Access-Control-Allow-Headers header.
        :param Sequence[str] allow_methods: Specifies the content for the Access-Control-Allow-Methods header.
        :param Sequence[str] allow_origin_regexes: Specifies the regualar 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 Sequence[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 bool disabled: If true, the setting specifies the CORS policy is disabled. The default value of false, which indicates that the CORS policy is in effect.
        :param Sequence[str] expose_headers: Specifies the content for the Access-Control-Expose-Headers header.
        :param 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[bool]:
        """
        In response to a preflight request, setting this to true indicates that the actual request can include user credentials. This field translates to the Access-Control-Allow-Credentials header.
        Default is false.
        """
        return pulumi.get(self, "allow_credentials")

    @property
    @pulumi.getter(name="allowHeaders")
    def allow_headers(self) -> Optional[Sequence[str]]:
        """
        Specifies the content for the Access-Control-Allow-Headers header.
        """
        return pulumi.get(self, "allow_headers")

    @property
    @pulumi.getter(name="allowMethods")
    def allow_methods(self) -> Optional[Sequence[str]]:
        """
        Specifies the content for the Access-Control-Allow-Methods header.
        """
        return pulumi.get(self, "allow_methods")

    @property
    @pulumi.getter(name="allowOriginRegexes")
    def allow_origin_regexes(self) -> Optional[Sequence[str]]:
        """
        Specifies the regualar 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")

    @property
    @pulumi.getter(name="allowOrigins")
    def allow_origins(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter
    def disabled(self) -> Optional[bool]:
        """
        If true, the setting specifies the CORS policy is disabled. The default value of false, which indicates that the CORS policy is in effect.
        """
        return pulumi.get(self, "disabled")

    @property
    @pulumi.getter(name="exposeHeaders")
    def expose_headers(self) -> Optional[Sequence[str]]:
        """
        Specifies the content for the Access-Control-Expose-Headers header.
        """
        return pulumi.get(self, "expose_headers")

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[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")


@pulumi.output_type
class RegionUrlMapDefaultRouteActionFaultInjectionPolicy(dict):
    def __init__(__self__, *,
                 abort: Optional['outputs.RegionUrlMapDefaultRouteActionFaultInjectionPolicyAbort'] = None,
                 delay: Optional['outputs.RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelay'] = None):
        """
        :param 'RegionUrlMapDefaultRouteActionFaultInjectionPolicyAbortArgs' abort: The specification for how client requests are aborted as part of fault injection.
               Structure is documented below.
        :param 'RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayArgs' 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['outputs.RegionUrlMapDefaultRouteActionFaultInjectionPolicyAbort']:
        """
        The specification for how client requests are aborted as part of fault injection.
        Structure is documented below.
        """
        return pulumi.get(self, "abort")

    @property
    @pulumi.getter
    def delay(self) -> Optional['outputs.RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelay']:
        """
        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")


@pulumi.output_type
class RegionUrlMapDefaultRouteActionFaultInjectionPolicyAbort(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "httpStatus":
            suggest = "http_status"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapDefaultRouteActionFaultInjectionPolicyAbort. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapDefaultRouteActionFaultInjectionPolicyAbort.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapDefaultRouteActionFaultInjectionPolicyAbort.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 http_status: Optional[int] = None,
                 percentage: Optional[float] = None):
        """
        :param int http_status: The HTTP status code used to abort the request.
               The value must be between 200 and 599 inclusive.
        :param 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[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")

    @property
    @pulumi.getter
    def percentage(self) -> Optional[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")


@pulumi.output_type
class RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelay(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fixedDelay":
            suggest = "fixed_delay"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelay. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelay.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelay.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 fixed_delay: Optional['outputs.RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelay'] = None,
                 percentage: Optional[float] = None):
        """
        :param 'RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs' fixed_delay: Specifies the value of the fixed delay interval.
               Structure is documented below.
        :param 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['outputs.RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelay']:
        """
        Specifies the value of the fixed delay interval.
        Structure is documented below.
        """
        return pulumi.get(self, "fixed_delay")

    @property
    @pulumi.getter
    def percentage(self) -> Optional[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")


@pulumi.output_type
class RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelay(dict):
    def __init__(__self__, *,
                 nanos: Optional[int] = None,
                 seconds: Optional[str] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter
    def seconds(self) -> Optional[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")


@pulumi.output_type
class RegionUrlMapDefaultRouteActionRequestMirrorPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backendService":
            suggest = "backend_service"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapDefaultRouteActionRequestMirrorPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapDefaultRouteActionRequestMirrorPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapDefaultRouteActionRequestMirrorPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 backend_service: Optional[str] = None):
        """
        :param str backend_service: The full or partial URL to the RegionBackendService resource being mirrored to.
               The backend service configured for a mirroring policy must reference backends that are of the same type as the original backend service matched in the URL map.
               Serverless NEG backends are not currently supported as a mirrored backend service.
        """
        if backend_service is not None:
            pulumi.set(__self__, "backend_service", backend_service)

    @property
    @pulumi.getter(name="backendService")
    def backend_service(self) -> Optional[str]:
        """
        The full or partial URL to the RegionBackendService resource being mirrored to.
        The backend service configured for a mirroring policy must reference backends that are of the same type as the original backend service matched in the URL map.
        Serverless NEG backends are not currently supported as a mirrored backend service.
        """
        return pulumi.get(self, "backend_service")


@pulumi.output_type
class RegionUrlMapDefaultRouteActionRetryPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "numRetries":
            suggest = "num_retries"
        elif key == "perTryTimeout":
            suggest = "per_try_timeout"
        elif key == "retryConditions":
            suggest = "retry_conditions"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapDefaultRouteActionRetryPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapDefaultRouteActionRetryPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapDefaultRouteActionRetryPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 num_retries: Optional[int] = None,
                 per_try_timeout: Optional['outputs.RegionUrlMapDefaultRouteActionRetryPolicyPerTryTimeout'] = None,
                 retry_conditions: Optional[Sequence[str]] = None):
        """
        :param int num_retries: Specifies the allowed number retries. This number must be > 0. If not specified, defaults to 1.
        :param 'RegionUrlMapDefaultRouteActionRetryPolicyPerTryTimeoutArgs' 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 Sequence[str] retry_conditions: Specifies one or more conditions when this retry policy applies.
               Valid values are listed below. Only the following codes are supported when the URL map is bound to target gRPC proxy that has validateForProxyless field set to true: cancelled, deadline-exceeded, internal, resource-exhausted, unavailable.
               - 5xx : retry is attempted if the instance or endpoint responds with any 5xx response code, or if the instance or endpoint does not respond at all. For 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 : a retry is attempted on failures connecting to the instance or endpoint. For example, connection timeouts.
               - retriable-4xx : a retry is attempted if the instance or endpoint responds with a 4xx response code. The only error that you can retry is error code 409.
               - refused-stream : a retry is attempted if the instance or endpoint resets the stream with a REFUSED_STREAM error code. This reset type indicates that it is safe to retry.
               - cancelled : a retry is attempted if the gRPC status code in the response header is set to cancelled.
               - deadline-exceeded : a retry is attempted if the gRPC status code in the response header is set to deadline-exceeded.
               - internal :  a retry is attempted if the gRPC status code in the response header is set to internal.
               - resource-exhausted : a retry is attempted if the gRPC status code in the response header is set to resource-exhausted.
               - unavailable : a retry is attempted 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[int]:
        """
        Specifies the allowed number retries. This number must be > 0. If not specified, defaults to 1.
        """
        return pulumi.get(self, "num_retries")

    @property
    @pulumi.getter(name="perTryTimeout")
    def per_try_timeout(self) -> Optional['outputs.RegionUrlMapDefaultRouteActionRetryPolicyPerTryTimeout']:
        """
        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")

    @property
    @pulumi.getter(name="retryConditions")
    def retry_conditions(self) -> Optional[Sequence[str]]:
        """
        Specifies one or more conditions when this retry policy applies.
        Valid values are listed below. Only the following codes are supported when the URL map is bound to target gRPC proxy that has validateForProxyless field set to true: cancelled, deadline-exceeded, internal, resource-exhausted, unavailable.
        - 5xx : retry is attempted if the instance or endpoint responds with any 5xx response code, or if the instance or endpoint does not respond at all. For 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 : a retry is attempted on failures connecting to the instance or endpoint. For example, connection timeouts.
        - retriable-4xx : a retry is attempted if the instance or endpoint responds with a 4xx response code. The only error that you can retry is error code 409.
        - refused-stream : a retry is attempted if the instance or endpoint resets the stream with a REFUSED_STREAM error code. This reset type indicates that it is safe to retry.
        - cancelled : a retry is attempted if the gRPC status code in the response header is set to cancelled.
        - deadline-exceeded : a retry is attempted if the gRPC status code in the response header is set to deadline-exceeded.
        - internal :  a retry is attempted if the gRPC status code in the response header is set to internal.
        - resource-exhausted : a retry is attempted if the gRPC status code in the response header is set to resource-exhausted.
        - unavailable : a retry is attempted if the gRPC status code in the response header is set to unavailable.
        """
        return pulumi.get(self, "retry_conditions")


@pulumi.output_type
class RegionUrlMapDefaultRouteActionRetryPolicyPerTryTimeout(dict):
    def __init__(__self__, *,
                 nanos: Optional[int] = None,
                 seconds: Optional[str] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter
    def seconds(self) -> Optional[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")


@pulumi.output_type
class RegionUrlMapDefaultRouteActionTimeout(dict):
    def __init__(__self__, *,
                 nanos: Optional[int] = None,
                 seconds: Optional[str] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter
    def seconds(self) -> Optional[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")


@pulumi.output_type
class RegionUrlMapDefaultRouteActionUrlRewrite(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hostRewrite":
            suggest = "host_rewrite"
        elif key == "pathPrefixRewrite":
            suggest = "path_prefix_rewrite"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapDefaultRouteActionUrlRewrite. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapDefaultRouteActionUrlRewrite.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapDefaultRouteActionUrlRewrite.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 host_rewrite: Optional[str] = None,
                 path_prefix_rewrite: Optional[str] = None):
        """
        :param str host_rewrite: Before forwarding the request to the selected service, the request's host header is replaced with contents of hostRewrite.
               The value must be from 1 to 255 characters.
        :param str path_prefix_rewrite: Before forwarding the request to the selected backend service, the matching portion of the request's path is replaced by pathPrefixRewrite.
               The value must be from 1 to 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[str]:
        """
        Before forwarding the request to the selected service, the request's host header is replaced with contents of hostRewrite.
        The value must be from 1 to 255 characters.
        """
        return pulumi.get(self, "host_rewrite")

    @property
    @pulumi.getter(name="pathPrefixRewrite")
    def path_prefix_rewrite(self) -> Optional[str]:
        """
        Before forwarding the request to the selected backend service, the matching portion of the request's path is replaced by pathPrefixRewrite.
        The value must be from 1 to 1024 characters.
        """
        return pulumi.get(self, "path_prefix_rewrite")


@pulumi.output_type
class RegionUrlMapDefaultRouteActionWeightedBackendService(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backendService":
            suggest = "backend_service"
        elif key == "headerAction":
            suggest = "header_action"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapDefaultRouteActionWeightedBackendService. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapDefaultRouteActionWeightedBackendService.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapDefaultRouteActionWeightedBackendService.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 backend_service: Optional[str] = None,
                 header_action: Optional['outputs.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderAction'] = None,
                 weight: Optional[int] = None):
        """
        :param str backend_service: The full or partial URL to the default BackendService resource. Before forwarding the request to backendService, the load balancer applies any relevant headerActions specified as part of this backendServiceWeight.
        :param 'RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionArgs' 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.
               headerAction is not supported for load balancers that have their loadBalancingScheme set to EXTERNAL.
               Not supported when the URL map is bound to a target gRPC proxy that has validateForProxyless field set to true.
               Structure is documented below.
        :param int weight: Specifies the fraction of traffic sent to a backend service, 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 backend service, subsequent requests are sent to the same backend service as determined by the backend service's session affinity policy.
               The value must be from 0 to 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[str]:
        """
        The full or partial URL to the default BackendService resource. Before forwarding the request to backendService, the load balancer applies any relevant headerActions specified as part of this backendServiceWeight.
        """
        return pulumi.get(self, "backend_service")

    @property
    @pulumi.getter(name="headerAction")
    def header_action(self) -> Optional['outputs.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderAction']:
        """
        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.
        headerAction is not supported for load balancers that have their loadBalancingScheme set to EXTERNAL.
        Not supported when the URL map is bound to a target gRPC proxy that has validateForProxyless field set to true.
        Structure is documented below.
        """
        return pulumi.get(self, "header_action")

    @property
    @pulumi.getter
    def weight(self) -> Optional[int]:
        """
        Specifies the fraction of traffic sent to a backend service, 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 backend service, subsequent requests are sent to the same backend service as determined by the backend service's session affinity policy.
        The value must be from 0 to 1000.
        """
        return pulumi.get(self, "weight")


@pulumi.output_type
class RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "requestHeadersToAdds":
            suggest = "request_headers_to_adds"
        elif key == "requestHeadersToRemoves":
            suggest = "request_headers_to_removes"
        elif key == "responseHeadersToAdds":
            suggest = "response_headers_to_adds"
        elif key == "responseHeadersToRemoves":
            suggest = "response_headers_to_removes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 request_headers_to_adds: Optional[Sequence['outputs.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd']] = None,
                 request_headers_to_removes: Optional[Sequence[str]] = None,
                 response_headers_to_adds: Optional[Sequence['outputs.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd']] = None,
                 response_headers_to_removes: Optional[Sequence[str]] = None):
        """
        :param Sequence['RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs'] request_headers_to_adds: Headers to add to a matching request before forwarding the request to the backendService.
               Structure is documented below.
        :param Sequence[str] request_headers_to_removes: A list of header names for headers that need to be removed from the request before forwarding the request to the backendService.
        :param Sequence['RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs'] response_headers_to_adds: Headers to add the response before sending the response back to the client.
               Structure is documented below.
        :param Sequence[str] response_headers_to_removes: A list of header names for headers that need to be removed from the response before 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[Sequence['outputs.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd']]:
        """
        Headers to add to a matching request before forwarding the request to the backendService.
        Structure is documented below.
        """
        return pulumi.get(self, "request_headers_to_adds")

    @property
    @pulumi.getter(name="requestHeadersToRemoves")
    def request_headers_to_removes(self) -> Optional[Sequence[str]]:
        """
        A list of header names for headers that need to be removed from the request before forwarding the request to the backendService.
        """
        return pulumi.get(self, "request_headers_to_removes")

    @property
    @pulumi.getter(name="responseHeadersToAdds")
    def response_headers_to_adds(self) -> Optional[Sequence['outputs.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd']]:
        """
        Headers to add the response before sending the response back to the client.
        Structure is documented below.
        """
        return pulumi.get(self, "response_headers_to_adds")

    @property
    @pulumi.getter(name="responseHeadersToRemoves")
    def response_headers_to_removes(self) -> Optional[Sequence[str]]:
        """
        A list of header names for headers that need to be removed from the response before sending the response back to the client.
        """
        return pulumi.get(self, "response_headers_to_removes")


@pulumi.output_type
class RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: Optional[str] = None,
                 header_value: Optional[str] = None,
                 replace: Optional[bool] = None):
        """
        :param str header_name: The name of the header.
        :param str header_value: The value of the header to add.
        :param 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.
               The default value is false.
        """
        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[str]:
        """
        The name of the header.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> Optional[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @property
    @pulumi.getter
    def replace(self) -> Optional[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.
        The default value is false.
        """
        return pulumi.get(self, "replace")


@pulumi.output_type
class RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: Optional[str] = None,
                 header_value: Optional[str] = None,
                 replace: Optional[bool] = None):
        """
        :param str header_name: The name of the header.
        :param str header_value: The value of the header to add.
        :param 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.
               The default value is false.
        """
        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[str]:
        """
        The name of the header.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> Optional[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @property
    @pulumi.getter
    def replace(self) -> Optional[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.
        The default value is false.
        """
        return pulumi.get(self, "replace")


@pulumi.output_type
class RegionUrlMapDefaultUrlRedirect(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "stripQuery":
            suggest = "strip_query"
        elif key == "hostRedirect":
            suggest = "host_redirect"
        elif key == "httpsRedirect":
            suggest = "https_redirect"
        elif key == "pathRedirect":
            suggest = "path_redirect"
        elif key == "prefixRedirect":
            suggest = "prefix_redirect"
        elif key == "redirectResponseCode":
            suggest = "redirect_response_code"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapDefaultUrlRedirect. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapDefaultUrlRedirect.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapDefaultUrlRedirect.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 strip_query: bool,
                 host_redirect: Optional[str] = None,
                 https_redirect: Optional[bool] = None,
                 path_redirect: Optional[str] = None,
                 prefix_redirect: Optional[str] = None,
                 redirect_response_code: Optional[str] = None):
        """
        :param 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 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 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 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 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 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) -> 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")

    @property
    @pulumi.getter(name="hostRedirect")
    def host_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="httpsRedirect")
    def https_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="pathRedirect")
    def path_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="prefixRedirect")
    def prefix_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="redirectResponseCode")
    def redirect_response_code(self) -> Optional[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")


@pulumi.output_type
class RegionUrlMapHostRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "pathMatcher":
            suggest = "path_matcher"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapHostRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapHostRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapHostRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 hosts: Sequence[str],
                 path_matcher: str,
                 description: Optional[str] = None):
        """
        :param Sequence[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 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 str description: An optional description of this HostRule. Provide this property
               when you create the resource.
        """
        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) -> Sequence[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")

    @property
    @pulumi.getter(name="pathMatcher")
    def path_matcher(self) -> 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")

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


@pulumi.output_type
class RegionUrlMapPathMatcher(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultService":
            suggest = "default_service"
        elif key == "defaultUrlRedirect":
            suggest = "default_url_redirect"
        elif key == "pathRules":
            suggest = "path_rules"
        elif key == "routeRules":
            suggest = "route_rules"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcher. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcher.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcher.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 default_service: Optional[str] = None,
                 default_url_redirect: Optional['outputs.RegionUrlMapPathMatcherDefaultUrlRedirect'] = None,
                 description: Optional[str] = None,
                 path_rules: Optional[Sequence['outputs.RegionUrlMapPathMatcherPathRule']] = None,
                 route_rules: Optional[Sequence['outputs.RegionUrlMapPathMatcherRouteRule']] = None):
        """
        :param str name: The name to which this PathMatcher is referred by the HostRule.
        :param 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 '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 str description: An optional description of this resource.
        :param Sequence['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 Sequence['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) -> str:
        """
        The name to which this PathMatcher is referred by the HostRule.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="defaultService")
    def default_service(self) -> Optional[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")

    @property
    @pulumi.getter(name="defaultUrlRedirect")
    def default_url_redirect(self) -> Optional['outputs.RegionUrlMapPathMatcherDefaultUrlRedirect']:
        """
        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")

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

    @property
    @pulumi.getter(name="pathRules")
    def path_rules(self) -> Optional[Sequence['outputs.RegionUrlMapPathMatcherPathRule']]:
        """
        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")

    @property
    @pulumi.getter(name="routeRules")
    def route_rules(self) -> Optional[Sequence['outputs.RegionUrlMapPathMatcherRouteRule']]:
        """
        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")


@pulumi.output_type
class RegionUrlMapPathMatcherDefaultUrlRedirect(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "stripQuery":
            suggest = "strip_query"
        elif key == "hostRedirect":
            suggest = "host_redirect"
        elif key == "httpsRedirect":
            suggest = "https_redirect"
        elif key == "pathRedirect":
            suggest = "path_redirect"
        elif key == "prefixRedirect":
            suggest = "prefix_redirect"
        elif key == "redirectResponseCode":
            suggest = "redirect_response_code"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherDefaultUrlRedirect. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherDefaultUrlRedirect.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherDefaultUrlRedirect.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 strip_query: bool,
                 host_redirect: Optional[str] = None,
                 https_redirect: Optional[bool] = None,
                 path_redirect: Optional[str] = None,
                 prefix_redirect: Optional[str] = None,
                 redirect_response_code: Optional[str] = None):
        """
        :param 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 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 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 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 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 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) -> 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")

    @property
    @pulumi.getter(name="hostRedirect")
    def host_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="httpsRedirect")
    def https_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="pathRedirect")
    def path_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="prefixRedirect")
    def prefix_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="redirectResponseCode")
    def redirect_response_code(self) -> Optional[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")


@pulumi.output_type
class RegionUrlMapPathMatcherPathRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "routeAction":
            suggest = "route_action"
        elif key == "urlRedirect":
            suggest = "url_redirect"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherPathRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherPathRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherPathRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 paths: Sequence[str],
                 route_action: Optional['outputs.RegionUrlMapPathMatcherPathRuleRouteAction'] = None,
                 service: Optional[str] = None,
                 url_redirect: Optional['outputs.RegionUrlMapPathMatcherPathRuleUrlRedirect'] = None):
        """
        :param Sequence[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 '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 str service: The region backend service resource to which traffic is
               directed if this rule is matched. If routeAction is additionally specified,
               advanced routing actions like URL Rewrites, etc. take effect prior to sending
               the request to the backend. However, if service is specified, routeAction cannot
               contain any weightedBackendService s. Conversely, if routeAction specifies any
               weightedBackendServices, service must not be specified. Only one of urlRedirect,
               service or routeAction.weightedBackendService must be set.
        :param '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) -> Sequence[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")

    @property
    @pulumi.getter(name="routeAction")
    def route_action(self) -> Optional['outputs.RegionUrlMapPathMatcherPathRuleRouteAction']:
        """
        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")

    @property
    @pulumi.getter
    def service(self) -> Optional[str]:
        """
        The region backend service resource to which traffic is
        directed if this rule is matched. If routeAction is additionally specified,
        advanced routing actions like URL Rewrites, etc. take effect prior to sending
        the request to the backend. However, if service is specified, routeAction cannot
        contain any weightedBackendService s. Conversely, if routeAction specifies any
        weightedBackendServices, service must not be specified. Only one of urlRedirect,
        service or routeAction.weightedBackendService must be set.
        """
        return pulumi.get(self, "service")

    @property
    @pulumi.getter(name="urlRedirect")
    def url_redirect(self) -> Optional['outputs.RegionUrlMapPathMatcherPathRuleUrlRedirect']:
        """
        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")


@pulumi.output_type
class RegionUrlMapPathMatcherPathRuleRouteAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "corsPolicy":
            suggest = "cors_policy"
        elif key == "faultInjectionPolicy":
            suggest = "fault_injection_policy"
        elif key == "requestMirrorPolicy":
            suggest = "request_mirror_policy"
        elif key == "retryPolicy":
            suggest = "retry_policy"
        elif key == "urlRewrite":
            suggest = "url_rewrite"
        elif key == "weightedBackendServices":
            suggest = "weighted_backend_services"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherPathRuleRouteAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherPathRuleRouteAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherPathRuleRouteAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cors_policy: Optional['outputs.RegionUrlMapPathMatcherPathRuleRouteActionCorsPolicy'] = None,
                 fault_injection_policy: Optional['outputs.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicy'] = None,
                 request_mirror_policy: Optional['outputs.RegionUrlMapPathMatcherPathRuleRouteActionRequestMirrorPolicy'] = None,
                 retry_policy: Optional['outputs.RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicy'] = None,
                 timeout: Optional['outputs.RegionUrlMapPathMatcherPathRuleRouteActionTimeout'] = None,
                 url_rewrite: Optional['outputs.RegionUrlMapPathMatcherPathRuleRouteActionUrlRewrite'] = None,
                 weighted_backend_services: Optional[Sequence['outputs.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendService']] = None):
        """
        :param '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 '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 '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 'RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyArgs' retry_policy: Specifies the retry policy associated with this route.
               Structure is documented below.
        :param '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 '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 Sequence['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['outputs.RegionUrlMapPathMatcherPathRuleRouteActionCorsPolicy']:
        """
        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")

    @property
    @pulumi.getter(name="faultInjectionPolicy")
    def fault_injection_policy(self) -> Optional['outputs.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicy']:
        """
        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")

    @property
    @pulumi.getter(name="requestMirrorPolicy")
    def request_mirror_policy(self) -> Optional['outputs.RegionUrlMapPathMatcherPathRuleRouteActionRequestMirrorPolicy']:
        """
        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")

    @property
    @pulumi.getter(name="retryPolicy")
    def retry_policy(self) -> Optional['outputs.RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicy']:
        """
        Specifies the retry policy associated with this route.
        Structure is documented below.
        """
        return pulumi.get(self, "retry_policy")

    @property
    @pulumi.getter
    def timeout(self) -> Optional['outputs.RegionUrlMapPathMatcherPathRuleRouteActionTimeout']:
        """
        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")

    @property
    @pulumi.getter(name="urlRewrite")
    def url_rewrite(self) -> Optional['outputs.RegionUrlMapPathMatcherPathRuleRouteActionUrlRewrite']:
        """
        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")

    @property
    @pulumi.getter(name="weightedBackendServices")
    def weighted_backend_services(self) -> Optional[Sequence['outputs.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendService']]:
        """
        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")


@pulumi.output_type
class RegionUrlMapPathMatcherPathRuleRouteActionCorsPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowCredentials":
            suggest = "allow_credentials"
        elif key == "allowHeaders":
            suggest = "allow_headers"
        elif key == "allowMethods":
            suggest = "allow_methods"
        elif key == "allowOriginRegexes":
            suggest = "allow_origin_regexes"
        elif key == "allowOrigins":
            suggest = "allow_origins"
        elif key == "exposeHeaders":
            suggest = "expose_headers"
        elif key == "maxAge":
            suggest = "max_age"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherPathRuleRouteActionCorsPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherPathRuleRouteActionCorsPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherPathRuleRouteActionCorsPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 disabled: bool,
                 allow_credentials: Optional[bool] = None,
                 allow_headers: Optional[Sequence[str]] = None,
                 allow_methods: Optional[Sequence[str]] = None,
                 allow_origin_regexes: Optional[Sequence[str]] = None,
                 allow_origins: Optional[Sequence[str]] = None,
                 expose_headers: Optional[Sequence[str]] = None,
                 max_age: Optional[int] = None):
        """
        :param bool disabled: If true, the setting specifies the CORS policy is disabled. The default value of false, which indicates that the CORS policy is in effect.
        :param bool allow_credentials: In response to a preflight request, setting this to true indicates that the actual request can include user credentials. This field translates to the Access-Control-Allow-Credentials header.
               Default is false.
        :param Sequence[str] allow_headers: Specifies the content for the Access-Control-Allow-Headers header.
        :param Sequence[str] allow_methods: Specifies the content for the Access-Control-Allow-Methods header.
        :param Sequence[str] allow_origin_regexes: Specifies the regualar 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 Sequence[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 Sequence[str] expose_headers: Specifies the content for the Access-Control-Expose-Headers header.
        :param 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) -> bool:
        """
        If true, the setting specifies the CORS policy is disabled. The default value of false, which indicates that the CORS policy is in effect.
        """
        return pulumi.get(self, "disabled")

    @property
    @pulumi.getter(name="allowCredentials")
    def allow_credentials(self) -> Optional[bool]:
        """
        In response to a preflight request, setting this to true indicates that the actual request can include user credentials. This field translates to the Access-Control-Allow-Credentials header.
        Default is false.
        """
        return pulumi.get(self, "allow_credentials")

    @property
    @pulumi.getter(name="allowHeaders")
    def allow_headers(self) -> Optional[Sequence[str]]:
        """
        Specifies the content for the Access-Control-Allow-Headers header.
        """
        return pulumi.get(self, "allow_headers")

    @property
    @pulumi.getter(name="allowMethods")
    def allow_methods(self) -> Optional[Sequence[str]]:
        """
        Specifies the content for the Access-Control-Allow-Methods header.
        """
        return pulumi.get(self, "allow_methods")

    @property
    @pulumi.getter(name="allowOriginRegexes")
    def allow_origin_regexes(self) -> Optional[Sequence[str]]:
        """
        Specifies the regualar 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")

    @property
    @pulumi.getter(name="allowOrigins")
    def allow_origins(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter(name="exposeHeaders")
    def expose_headers(self) -> Optional[Sequence[str]]:
        """
        Specifies the content for the Access-Control-Expose-Headers header.
        """
        return pulumi.get(self, "expose_headers")

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[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")


@pulumi.output_type
class RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicy(dict):
    def __init__(__self__, *,
                 abort: Optional['outputs.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbort'] = None,
                 delay: Optional['outputs.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelay'] = None):
        """
        :param 'RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs' abort: The specification for how client requests are aborted as part of fault injection.
               Structure is documented below.
        :param '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['outputs.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbort']:
        """
        The specification for how client requests are aborted as part of fault injection.
        Structure is documented below.
        """
        return pulumi.get(self, "abort")

    @property
    @pulumi.getter
    def delay(self) -> Optional['outputs.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelay']:
        """
        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")


@pulumi.output_type
class RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbort(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "httpStatus":
            suggest = "http_status"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbort. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbort.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbort.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 http_status: int,
                 percentage: float):
        """
        :param int http_status: The HTTP status code used to abort the request.
               The value must be between 200 and 599 inclusive.
        :param 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) -> 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")

    @property
    @pulumi.getter
    def percentage(self) -> 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")


@pulumi.output_type
class RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelay(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fixedDelay":
            suggest = "fixed_delay"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelay. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelay.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelay.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 fixed_delay: 'outputs.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelay',
                 percentage: float):
        """
        :param 'RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs' fixed_delay: Specifies the value of the fixed delay interval.
               Structure is documented below.
        :param 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) -> 'outputs.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelay':
        """
        Specifies the value of the fixed delay interval.
        Structure is documented below.
        """
        return pulumi.get(self, "fixed_delay")

    @property
    @pulumi.getter
    def percentage(self) -> 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")


@pulumi.output_type
class RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelay(dict):
    def __init__(__self__, *,
                 seconds: str,
                 nanos: Optional[int] = None):
        """
        :param 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 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) -> 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")

    @property
    @pulumi.getter
    def nanos(self) -> Optional[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")


@pulumi.output_type
class RegionUrlMapPathMatcherPathRuleRouteActionRequestMirrorPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backendService":
            suggest = "backend_service"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherPathRuleRouteActionRequestMirrorPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherPathRuleRouteActionRequestMirrorPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherPathRuleRouteActionRequestMirrorPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 backend_service: str):
        """
        :param str backend_service: The full or partial URL to the RegionBackendService resource being mirrored to.
               The backend service configured for a mirroring policy must reference backends that are of the same type as the original backend service matched in the URL map.
               Serverless NEG backends are not currently supported as a mirrored backend service.
        """
        pulumi.set(__self__, "backend_service", backend_service)

    @property
    @pulumi.getter(name="backendService")
    def backend_service(self) -> str:
        """
        The full or partial URL to the RegionBackendService resource being mirrored to.
        The backend service configured for a mirroring policy must reference backends that are of the same type as the original backend service matched in the URL map.
        Serverless NEG backends are not currently supported as a mirrored backend service.
        """
        return pulumi.get(self, "backend_service")


@pulumi.output_type
class RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "numRetries":
            suggest = "num_retries"
        elif key == "perTryTimeout":
            suggest = "per_try_timeout"
        elif key == "retryConditions":
            suggest = "retry_conditions"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 num_retries: Optional[int] = None,
                 per_try_timeout: Optional['outputs.RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeout'] = None,
                 retry_conditions: Optional[Sequence[str]] = None):
        """
        :param int num_retries: Specifies the allowed number retries. This number must be > 0. If not specified, defaults to 1.
        :param 'RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs' 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 Sequence[str] retry_conditions: Specifies one or more conditions when this retry policy applies.
               Valid values are listed below. Only the following codes are supported when the URL map is bound to target gRPC proxy that has validateForProxyless field set to true: cancelled, deadline-exceeded, internal, resource-exhausted, unavailable.
               - 5xx : retry is attempted if the instance or endpoint responds with any 5xx response code, or if the instance or endpoint does not respond at all. For 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 : a retry is attempted on failures connecting to the instance or endpoint. For example, connection timeouts.
               - retriable-4xx : a retry is attempted if the instance or endpoint responds with a 4xx response code. The only error that you can retry is error code 409.
               - refused-stream : a retry is attempted if the instance or endpoint resets the stream with a REFUSED_STREAM error code. This reset type indicates that it is safe to retry.
               - cancelled : a retry is attempted if the gRPC status code in the response header is set to cancelled.
               - deadline-exceeded : a retry is attempted if the gRPC status code in the response header is set to deadline-exceeded.
               - internal :  a retry is attempted if the gRPC status code in the response header is set to internal.
               - resource-exhausted : a retry is attempted if the gRPC status code in the response header is set to resource-exhausted.
               - unavailable : a retry is attempted 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[int]:
        """
        Specifies the allowed number retries. This number must be > 0. If not specified, defaults to 1.
        """
        return pulumi.get(self, "num_retries")

    @property
    @pulumi.getter(name="perTryTimeout")
    def per_try_timeout(self) -> Optional['outputs.RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeout']:
        """
        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")

    @property
    @pulumi.getter(name="retryConditions")
    def retry_conditions(self) -> Optional[Sequence[str]]:
        """
        Specifies one or more conditions when this retry policy applies.
        Valid values are listed below. Only the following codes are supported when the URL map is bound to target gRPC proxy that has validateForProxyless field set to true: cancelled, deadline-exceeded, internal, resource-exhausted, unavailable.
        - 5xx : retry is attempted if the instance or endpoint responds with any 5xx response code, or if the instance or endpoint does not respond at all. For 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 : a retry is attempted on failures connecting to the instance or endpoint. For example, connection timeouts.
        - retriable-4xx : a retry is attempted if the instance or endpoint responds with a 4xx response code. The only error that you can retry is error code 409.
        - refused-stream : a retry is attempted if the instance or endpoint resets the stream with a REFUSED_STREAM error code. This reset type indicates that it is safe to retry.
        - cancelled : a retry is attempted if the gRPC status code in the response header is set to cancelled.
        - deadline-exceeded : a retry is attempted if the gRPC status code in the response header is set to deadline-exceeded.
        - internal :  a retry is attempted if the gRPC status code in the response header is set to internal.
        - resource-exhausted : a retry is attempted if the gRPC status code in the response header is set to resource-exhausted.
        - unavailable : a retry is attempted if the gRPC status code in the response header is set to unavailable.
        """
        return pulumi.get(self, "retry_conditions")


@pulumi.output_type
class RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeout(dict):
    def __init__(__self__, *,
                 seconds: str,
                 nanos: Optional[int] = None):
        """
        :param 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 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) -> 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")

    @property
    @pulumi.getter
    def nanos(self) -> Optional[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")


@pulumi.output_type
class RegionUrlMapPathMatcherPathRuleRouteActionTimeout(dict):
    def __init__(__self__, *,
                 seconds: str,
                 nanos: Optional[int] = None):
        """
        :param 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 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) -> 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")

    @property
    @pulumi.getter
    def nanos(self) -> Optional[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")


@pulumi.output_type
class RegionUrlMapPathMatcherPathRuleRouteActionUrlRewrite(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hostRewrite":
            suggest = "host_rewrite"
        elif key == "pathPrefixRewrite":
            suggest = "path_prefix_rewrite"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherPathRuleRouteActionUrlRewrite. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherPathRuleRouteActionUrlRewrite.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherPathRuleRouteActionUrlRewrite.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 host_rewrite: Optional[str] = None,
                 path_prefix_rewrite: Optional[str] = None):
        """
        :param str host_rewrite: Before forwarding the request to the selected service, the request's host header is replaced with contents of hostRewrite.
               The value must be from 1 to 255 characters.
        :param str path_prefix_rewrite: Before forwarding the request to the selected backend service, the matching portion of the request's path is replaced by pathPrefixRewrite.
               The value must be from 1 to 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[str]:
        """
        Before forwarding the request to the selected service, the request's host header is replaced with contents of hostRewrite.
        The value must be from 1 to 255 characters.
        """
        return pulumi.get(self, "host_rewrite")

    @property
    @pulumi.getter(name="pathPrefixRewrite")
    def path_prefix_rewrite(self) -> Optional[str]:
        """
        Before forwarding the request to the selected backend service, the matching portion of the request's path is replaced by pathPrefixRewrite.
        The value must be from 1 to 1024 characters.
        """
        return pulumi.get(self, "path_prefix_rewrite")


@pulumi.output_type
class RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendService(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backendService":
            suggest = "backend_service"
        elif key == "headerAction":
            suggest = "header_action"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendService. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendService.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendService.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 backend_service: str,
                 weight: int,
                 header_action: Optional['outputs.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderAction'] = None):
        """
        :param str backend_service: The full or partial URL to the default BackendService resource. Before forwarding the request to backendService, the load balancer applies any relevant headerActions specified as part of this backendServiceWeight.
        :param int weight: Specifies the fraction of traffic sent to a backend service, 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 backend service, subsequent requests are sent to the same backend service as determined by the backend service's session affinity policy.
               The value must be from 0 to 1000.
        :param '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.
               headerAction is not supported for load balancers that have their loadBalancingScheme set to EXTERNAL.
               Not supported when the URL map is bound to a target gRPC proxy that has validateForProxyless field set to true.
               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) -> str:
        """
        The full or partial URL to the default BackendService resource. Before forwarding the request to backendService, the load balancer applies any relevant headerActions specified as part of this backendServiceWeight.
        """
        return pulumi.get(self, "backend_service")

    @property
    @pulumi.getter
    def weight(self) -> int:
        """
        Specifies the fraction of traffic sent to a backend service, 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 backend service, subsequent requests are sent to the same backend service as determined by the backend service's session affinity policy.
        The value must be from 0 to 1000.
        """
        return pulumi.get(self, "weight")

    @property
    @pulumi.getter(name="headerAction")
    def header_action(self) -> Optional['outputs.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderAction']:
        """
        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.
        headerAction is not supported for load balancers that have their loadBalancingScheme set to EXTERNAL.
        Not supported when the URL map is bound to a target gRPC proxy that has validateForProxyless field set to true.
        Structure is documented below.
        """
        return pulumi.get(self, "header_action")


@pulumi.output_type
class RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "requestHeadersToAdds":
            suggest = "request_headers_to_adds"
        elif key == "requestHeadersToRemoves":
            suggest = "request_headers_to_removes"
        elif key == "responseHeadersToAdds":
            suggest = "response_headers_to_adds"
        elif key == "responseHeadersToRemoves":
            suggest = "response_headers_to_removes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 request_headers_to_adds: Optional[Sequence['outputs.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd']] = None,
                 request_headers_to_removes: Optional[Sequence[str]] = None,
                 response_headers_to_adds: Optional[Sequence['outputs.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd']] = None,
                 response_headers_to_removes: Optional[Sequence[str]] = None):
        """
        :param Sequence['RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs'] request_headers_to_adds: Headers to add to a matching request before forwarding the request to the backendService.
               Structure is documented below.
        :param Sequence[str] request_headers_to_removes: A list of header names for headers that need to be removed from the request before forwarding the request to the backendService.
        :param Sequence['RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs'] response_headers_to_adds: Headers to add the response before sending the response back to the client.
               Structure is documented below.
        :param Sequence[str] response_headers_to_removes: A list of header names for headers that need to be removed from the response before 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[Sequence['outputs.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd']]:
        """
        Headers to add to a matching request before forwarding the request to the backendService.
        Structure is documented below.
        """
        return pulumi.get(self, "request_headers_to_adds")

    @property
    @pulumi.getter(name="requestHeadersToRemoves")
    def request_headers_to_removes(self) -> Optional[Sequence[str]]:
        """
        A list of header names for headers that need to be removed from the request before forwarding the request to the backendService.
        """
        return pulumi.get(self, "request_headers_to_removes")

    @property
    @pulumi.getter(name="responseHeadersToAdds")
    def response_headers_to_adds(self) -> Optional[Sequence['outputs.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd']]:
        """
        Headers to add the response before sending the response back to the client.
        Structure is documented below.
        """
        return pulumi.get(self, "response_headers_to_adds")

    @property
    @pulumi.getter(name="responseHeadersToRemoves")
    def response_headers_to_removes(self) -> Optional[Sequence[str]]:
        """
        A list of header names for headers that need to be removed from the response before sending the response back to the client.
        """
        return pulumi.get(self, "response_headers_to_removes")


@pulumi.output_type
class RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: str,
                 header_value: str,
                 replace: bool):
        """
        :param str header_name: The name of the header.
        :param str header_value: The value of the header to add.
        :param 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.
               The default value is false.
        """
        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) -> str:
        """
        The name of the header.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> str:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @property
    @pulumi.getter
    def replace(self) -> 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.
        The default value is false.
        """
        return pulumi.get(self, "replace")


@pulumi.output_type
class RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: str,
                 header_value: str,
                 replace: bool):
        """
        :param str header_name: The name of the header.
        :param str header_value: The value of the header to add.
        :param 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.
               The default value is false.
        """
        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) -> str:
        """
        The name of the header.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> str:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @property
    @pulumi.getter
    def replace(self) -> 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.
        The default value is false.
        """
        return pulumi.get(self, "replace")


@pulumi.output_type
class RegionUrlMapPathMatcherPathRuleUrlRedirect(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "stripQuery":
            suggest = "strip_query"
        elif key == "hostRedirect":
            suggest = "host_redirect"
        elif key == "httpsRedirect":
            suggest = "https_redirect"
        elif key == "pathRedirect":
            suggest = "path_redirect"
        elif key == "prefixRedirect":
            suggest = "prefix_redirect"
        elif key == "redirectResponseCode":
            suggest = "redirect_response_code"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherPathRuleUrlRedirect. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherPathRuleUrlRedirect.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherPathRuleUrlRedirect.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 strip_query: bool,
                 host_redirect: Optional[str] = None,
                 https_redirect: Optional[bool] = None,
                 path_redirect: Optional[str] = None,
                 prefix_redirect: Optional[str] = None,
                 redirect_response_code: Optional[str] = None):
        """
        :param 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 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 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 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 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 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) -> 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")

    @property
    @pulumi.getter(name="hostRedirect")
    def host_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="httpsRedirect")
    def https_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="pathRedirect")
    def path_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="prefixRedirect")
    def prefix_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="redirectResponseCode")
    def redirect_response_code(self) -> Optional[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")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerAction":
            suggest = "header_action"
        elif key == "matchRules":
            suggest = "match_rules"
        elif key == "routeAction":
            suggest = "route_action"
        elif key == "urlRedirect":
            suggest = "url_redirect"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherRouteRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherRouteRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherRouteRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 priority: int,
                 header_action: Optional['outputs.RegionUrlMapPathMatcherRouteRuleHeaderAction'] = None,
                 match_rules: Optional[Sequence['outputs.RegionUrlMapPathMatcherRouteRuleMatchRule']] = None,
                 route_action: Optional['outputs.RegionUrlMapPathMatcherRouteRuleRouteAction'] = None,
                 service: Optional[str] = None,
                 url_redirect: Optional['outputs.RegionUrlMapPathMatcherRouteRuleUrlRedirect'] = None):
        """
        :param 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 'RegionUrlMapPathMatcherRouteRuleHeaderActionArgs' header_action: Specifies changes to request and response headers that need to take effect for
               the selected backendService. The headerAction specified here are applied before
               the matching pathMatchers[].headerAction and after pathMatchers[].routeRules[].r
               outeAction.weightedBackendService.backendServiceWeightAction[].headerAction
               Structure is documented below.
        :param Sequence['RegionUrlMapPathMatcherRouteRuleMatchRuleArgs'] match_rules: The rules for determining a match.
               Structure is documented below.
        :param 'RegionUrlMapPathMatcherRouteRuleRouteActionArgs' 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 str service: The region backend service resource to which traffic is
               directed if this rule is matched. If routeAction is additionally specified,
               advanced routing actions like URL Rewrites, etc. take effect prior to sending
               the request to the backend. However, if service is specified, routeAction cannot
               contain any weightedBackendService s. Conversely, if routeAction specifies any
               weightedBackendServices, service must not be specified. Only one of urlRedirect,
               service or routeAction.weightedBackendService must be set.
        :param 'RegionUrlMapPathMatcherRouteRuleUrlRedirectArgs' 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) -> 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")

    @property
    @pulumi.getter(name="headerAction")
    def header_action(self) -> Optional['outputs.RegionUrlMapPathMatcherRouteRuleHeaderAction']:
        """
        Specifies changes to request and response headers that need to take effect for
        the selected backendService. The headerAction specified here are applied before
        the matching pathMatchers[].headerAction and after pathMatchers[].routeRules[].r
        outeAction.weightedBackendService.backendServiceWeightAction[].headerAction
        Structure is documented below.
        """
        return pulumi.get(self, "header_action")

    @property
    @pulumi.getter(name="matchRules")
    def match_rules(self) -> Optional[Sequence['outputs.RegionUrlMapPathMatcherRouteRuleMatchRule']]:
        """
        The rules for determining a match.
        Structure is documented below.
        """
        return pulumi.get(self, "match_rules")

    @property
    @pulumi.getter(name="routeAction")
    def route_action(self) -> Optional['outputs.RegionUrlMapPathMatcherRouteRuleRouteAction']:
        """
        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")

    @property
    @pulumi.getter
    def service(self) -> Optional[str]:
        """
        The region backend service resource to which traffic is
        directed if this rule is matched. If routeAction is additionally specified,
        advanced routing actions like URL Rewrites, etc. take effect prior to sending
        the request to the backend. However, if service is specified, routeAction cannot
        contain any weightedBackendService s. Conversely, if routeAction specifies any
        weightedBackendServices, service must not be specified. Only one of urlRedirect,
        service or routeAction.weightedBackendService must be set.
        """
        return pulumi.get(self, "service")

    @property
    @pulumi.getter(name="urlRedirect")
    def url_redirect(self) -> Optional['outputs.RegionUrlMapPathMatcherRouteRuleUrlRedirect']:
        """
        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")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleHeaderAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "requestHeadersToAdds":
            suggest = "request_headers_to_adds"
        elif key == "requestHeadersToRemoves":
            suggest = "request_headers_to_removes"
        elif key == "responseHeadersToAdds":
            suggest = "response_headers_to_adds"
        elif key == "responseHeadersToRemoves":
            suggest = "response_headers_to_removes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherRouteRuleHeaderAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherRouteRuleHeaderAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherRouteRuleHeaderAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 request_headers_to_adds: Optional[Sequence['outputs.RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAdd']] = None,
                 request_headers_to_removes: Optional[Sequence[str]] = None,
                 response_headers_to_adds: Optional[Sequence['outputs.RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAdd']] = None,
                 response_headers_to_removes: Optional[Sequence[str]] = None):
        """
        :param Sequence['RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs'] request_headers_to_adds: Headers to add to a matching request before forwarding the request to the backendService.
               Structure is documented below.
        :param Sequence[str] request_headers_to_removes: A list of header names for headers that need to be removed from the request before forwarding the request to the backendService.
        :param Sequence['RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs'] response_headers_to_adds: Headers to add the response before sending the response back to the client.
               Structure is documented below.
        :param Sequence[str] response_headers_to_removes: A list of header names for headers that need to be removed from the response before 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[Sequence['outputs.RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAdd']]:
        """
        Headers to add to a matching request before forwarding the request to the backendService.
        Structure is documented below.
        """
        return pulumi.get(self, "request_headers_to_adds")

    @property
    @pulumi.getter(name="requestHeadersToRemoves")
    def request_headers_to_removes(self) -> Optional[Sequence[str]]:
        """
        A list of header names for headers that need to be removed from the request before forwarding the request to the backendService.
        """
        return pulumi.get(self, "request_headers_to_removes")

    @property
    @pulumi.getter(name="responseHeadersToAdds")
    def response_headers_to_adds(self) -> Optional[Sequence['outputs.RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAdd']]:
        """
        Headers to add the response before sending the response back to the client.
        Structure is documented below.
        """
        return pulumi.get(self, "response_headers_to_adds")

    @property
    @pulumi.getter(name="responseHeadersToRemoves")
    def response_headers_to_removes(self) -> Optional[Sequence[str]]:
        """
        A list of header names for headers that need to be removed from the response before sending the response back to the client.
        """
        return pulumi.get(self, "response_headers_to_removes")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: str,
                 header_value: str,
                 replace: bool):
        """
        :param str header_name: The name of the header.
        :param str header_value: The value of the header to add.
        :param 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.
               The default value is false.
        """
        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) -> str:
        """
        The name of the header.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> str:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @property
    @pulumi.getter
    def replace(self) -> 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.
        The default value is false.
        """
        return pulumi.get(self, "replace")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: str,
                 header_value: str,
                 replace: bool):
        """
        :param str header_name: The name of the header.
        :param str header_value: The value of the header to add.
        :param 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.
               The default value is false.
        """
        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) -> str:
        """
        The name of the header.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> str:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @property
    @pulumi.getter
    def replace(self) -> 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.
        The default value is false.
        """
        return pulumi.get(self, "replace")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleMatchRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fullPathMatch":
            suggest = "full_path_match"
        elif key == "headerMatches":
            suggest = "header_matches"
        elif key == "ignoreCase":
            suggest = "ignore_case"
        elif key == "metadataFilters":
            suggest = "metadata_filters"
        elif key == "prefixMatch":
            suggest = "prefix_match"
        elif key == "queryParameterMatches":
            suggest = "query_parameter_matches"
        elif key == "regexMatch":
            suggest = "regex_match"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherRouteRuleMatchRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherRouteRuleMatchRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherRouteRuleMatchRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 full_path_match: Optional[str] = None,
                 header_matches: Optional[Sequence['outputs.RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatch']] = None,
                 ignore_case: Optional[bool] = None,
                 metadata_filters: Optional[Sequence['outputs.RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilter']] = None,
                 prefix_match: Optional[str] = None,
                 query_parameter_matches: Optional[Sequence['outputs.RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatch']] = None,
                 regex_match: Optional[str] = None):
        """
        :param 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 Sequence['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 bool ignore_case: Specifies that prefixMatch and fullPathMatch matches are case sensitive.
               Defaults to false.
        :param Sequence['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 str prefix_match: For satisfying the matchRule condition, the request's path must begin with the
               specified prefixMatch. prefixMatch must begin with a /. The value must be
               between 1 and 1024 characters. Only one of prefixMatch, fullPathMatch or
               regexMatch must be specified.
        :param Sequence['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 str regex_match: For satisfying the matchRule condition, the path of the request must satisfy the
               regular expression specified in regexMatch after removing any query parameters
               and anchor supplied with the original URL. For regular expression grammar please
               see en.cppreference.com/w/cpp/regex/ecmascript  Only one of prefixMatch,
               fullPathMatch or regexMatch must be specified.
        """
        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[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")

    @property
    @pulumi.getter(name="headerMatches")
    def header_matches(self) -> Optional[Sequence['outputs.RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatch']]:
        """
        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")

    @property
    @pulumi.getter(name="ignoreCase")
    def ignore_case(self) -> Optional[bool]:
        """
        Specifies that prefixMatch and fullPathMatch matches are case sensitive.
        Defaults to false.
        """
        return pulumi.get(self, "ignore_case")

    @property
    @pulumi.getter(name="metadataFilters")
    def metadata_filters(self) -> Optional[Sequence['outputs.RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilter']]:
        """
        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")

    @property
    @pulumi.getter(name="prefixMatch")
    def prefix_match(self) -> Optional[str]:
        """
        For satisfying the matchRule condition, the request's path must begin with the
        specified prefixMatch. prefixMatch must begin with a /. The value must be
        between 1 and 1024 characters. Only one of prefixMatch, fullPathMatch or
        regexMatch must be specified.
        """
        return pulumi.get(self, "prefix_match")

    @property
    @pulumi.getter(name="queryParameterMatches")
    def query_parameter_matches(self) -> Optional[Sequence['outputs.RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatch']]:
        """
        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")

    @property
    @pulumi.getter(name="regexMatch")
    def regex_match(self) -> Optional[str]:
        """
        For satisfying the matchRule condition, the path of the request must satisfy the
        regular expression specified in regexMatch after removing any query parameters
        and anchor supplied with the original URL. For regular expression grammar please
        see en.cppreference.com/w/cpp/regex/ecmascript  Only one of prefixMatch,
        fullPathMatch or regexMatch must be specified.
        """
        return pulumi.get(self, "regex_match")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatch(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "exactMatch":
            suggest = "exact_match"
        elif key == "invertMatch":
            suggest = "invert_match"
        elif key == "prefixMatch":
            suggest = "prefix_match"
        elif key == "presentMatch":
            suggest = "present_match"
        elif key == "rangeMatch":
            suggest = "range_match"
        elif key == "regexMatch":
            suggest = "regex_match"
        elif key == "suffixMatch":
            suggest = "suffix_match"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatch. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatch.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatch.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: str,
                 exact_match: Optional[str] = None,
                 invert_match: Optional[bool] = None,
                 prefix_match: Optional[str] = None,
                 present_match: Optional[bool] = None,
                 range_match: Optional['outputs.RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatch'] = None,
                 regex_match: Optional[str] = None,
                 suffix_match: Optional[str] = None):
        """
        :param str header_name: The name of the HTTP header to match. For matching against the HTTP request's
               authority, use a headerMatch with the header name ":authority". For matching a
               request's method, use the headerName ":method".
        :param str exact_match: The value should exactly match contents of exactMatch. Only one of exactMatch,
               prefixMatch, suffixMatch, regexMatch, presentMatch or rangeMatch must be set.
        :param 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 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 bool present_match: A header with the contents of headerName must exist. The match takes place
               whether or not the request's header has a value or not. Only one of exactMatch,
               prefixMatch, suffixMatch, regexMatch, presentMatch or rangeMatch must be set.
        :param '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 str regex_match: The value of the header must match the regular expression specified in
               regexMatch. For regular expression grammar, please see:
               en.cppreference.com/w/cpp/regex/ecmascript  For matching against a port
               specified in the HTTP request, use a headerMatch with headerName set to PORT and
               a regular expression that satisfies the RFC2616 Host header's port specifier.
               Only one of exactMatch, prefixMatch, suffixMatch, regexMatch, presentMatch or
               rangeMatch must be set.
        :param 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) -> str:
        """
        The name of the HTTP header to match. For matching against the HTTP request's
        authority, use a headerMatch with the header name ":authority". For matching a
        request's method, use the headerName ":method".
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="exactMatch")
    def exact_match(self) -> Optional[str]:
        """
        The value should exactly match contents of exactMatch. Only one of exactMatch,
        prefixMatch, suffixMatch, regexMatch, presentMatch or rangeMatch must be set.
        """
        return pulumi.get(self, "exact_match")

    @property
    @pulumi.getter(name="invertMatch")
    def invert_match(self) -> Optional[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")

    @property
    @pulumi.getter(name="prefixMatch")
    def prefix_match(self) -> Optional[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")

    @property
    @pulumi.getter(name="presentMatch")
    def present_match(self) -> Optional[bool]:
        """
        A header with the contents of headerName must exist. The match takes place
        whether or not the request's header has a value or not. Only one of exactMatch,
        prefixMatch, suffixMatch, regexMatch, presentMatch or rangeMatch must be set.
        """
        return pulumi.get(self, "present_match")

    @property
    @pulumi.getter(name="rangeMatch")
    def range_match(self) -> Optional['outputs.RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatch']:
        """
        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")

    @property
    @pulumi.getter(name="regexMatch")
    def regex_match(self) -> Optional[str]:
        """
        The value of the header must match the regular expression specified in
        regexMatch. For regular expression grammar, please see:
        en.cppreference.com/w/cpp/regex/ecmascript  For matching against a port
        specified in the HTTP request, use a headerMatch with headerName set to PORT and
        a regular expression that satisfies the RFC2616 Host header's port specifier.
        Only one of exactMatch, prefixMatch, suffixMatch, regexMatch, presentMatch or
        rangeMatch must be set.
        """
        return pulumi.get(self, "regex_match")

    @property
    @pulumi.getter(name="suffixMatch")
    def suffix_match(self) -> Optional[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")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatch(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "rangeEnd":
            suggest = "range_end"
        elif key == "rangeStart":
            suggest = "range_start"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatch. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatch.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatch.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 range_end: int,
                 range_start: int):
        """
        :param int range_end: The end of the range (exclusive).
        :param 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) -> int:
        """
        The end of the range (exclusive).
        """
        return pulumi.get(self, "range_end")

    @property
    @pulumi.getter(name="rangeStart")
    def range_start(self) -> int:
        """
        The start of the range (inclusive).
        """
        return pulumi.get(self, "range_start")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "filterLabels":
            suggest = "filter_labels"
        elif key == "filterMatchCriteria":
            suggest = "filter_match_criteria"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilter. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilter.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilter.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 filter_labels: Sequence['outputs.RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabel'],
                 filter_match_criteria: str):
        """
        :param Sequence['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 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) -> Sequence['outputs.RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabel']:
        """
        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")

    @property
    @pulumi.getter(name="filterMatchCriteria")
    def filter_match_criteria(self) -> 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")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabel(dict):
    def __init__(__self__, *,
                 name: str,
                 value: str):
        """
        :param str name: Name of metadata label. The name can have a maximum length of 1024 characters
               and must be at least 1 character long.
        :param 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) -> str:
        """
        Name of metadata label. The name can have a maximum length of 1024 characters
        and must be at least 1 character long.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> 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")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatch(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "exactMatch":
            suggest = "exact_match"
        elif key == "presentMatch":
            suggest = "present_match"
        elif key == "regexMatch":
            suggest = "regex_match"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatch. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatch.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatch.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 exact_match: Optional[str] = None,
                 present_match: Optional[bool] = None,
                 regex_match: Optional[str] = None):
        """
        :param 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 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 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 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) -> 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")

    @property
    @pulumi.getter(name="exactMatch")
    def exact_match(self) -> Optional[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")

    @property
    @pulumi.getter(name="presentMatch")
    def present_match(self) -> Optional[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")

    @property
    @pulumi.getter(name="regexMatch")
    def regex_match(self) -> Optional[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")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleRouteAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "corsPolicy":
            suggest = "cors_policy"
        elif key == "faultInjectionPolicy":
            suggest = "fault_injection_policy"
        elif key == "requestMirrorPolicy":
            suggest = "request_mirror_policy"
        elif key == "retryPolicy":
            suggest = "retry_policy"
        elif key == "urlRewrite":
            suggest = "url_rewrite"
        elif key == "weightedBackendServices":
            suggest = "weighted_backend_services"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherRouteRuleRouteAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherRouteRuleRouteAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherRouteRuleRouteAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cors_policy: Optional['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionCorsPolicy'] = None,
                 fault_injection_policy: Optional['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicy'] = None,
                 request_mirror_policy: Optional['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionRequestMirrorPolicy'] = None,
                 retry_policy: Optional['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicy'] = None,
                 timeout: Optional['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionTimeout'] = None,
                 url_rewrite: Optional['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionUrlRewrite'] = None,
                 weighted_backend_services: Optional[Sequence['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendService']] = None):
        """
        :param '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 '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 '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 'RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyArgs' retry_policy: Specifies the retry policy associated with this route.
               Structure is documented below.
        :param '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 '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 Sequence['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['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionCorsPolicy']:
        """
        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")

    @property
    @pulumi.getter(name="faultInjectionPolicy")
    def fault_injection_policy(self) -> Optional['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicy']:
        """
        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")

    @property
    @pulumi.getter(name="requestMirrorPolicy")
    def request_mirror_policy(self) -> Optional['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionRequestMirrorPolicy']:
        """
        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")

    @property
    @pulumi.getter(name="retryPolicy")
    def retry_policy(self) -> Optional['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicy']:
        """
        Specifies the retry policy associated with this route.
        Structure is documented below.
        """
        return pulumi.get(self, "retry_policy")

    @property
    @pulumi.getter
    def timeout(self) -> Optional['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionTimeout']:
        """
        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")

    @property
    @pulumi.getter(name="urlRewrite")
    def url_rewrite(self) -> Optional['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionUrlRewrite']:
        """
        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")

    @property
    @pulumi.getter(name="weightedBackendServices")
    def weighted_backend_services(self) -> Optional[Sequence['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendService']]:
        """
        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")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleRouteActionCorsPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowCredentials":
            suggest = "allow_credentials"
        elif key == "allowHeaders":
            suggest = "allow_headers"
        elif key == "allowMethods":
            suggest = "allow_methods"
        elif key == "allowOriginRegexes":
            suggest = "allow_origin_regexes"
        elif key == "allowOrigins":
            suggest = "allow_origins"
        elif key == "exposeHeaders":
            suggest = "expose_headers"
        elif key == "maxAge":
            suggest = "max_age"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherRouteRuleRouteActionCorsPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherRouteRuleRouteActionCorsPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherRouteRuleRouteActionCorsPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 allow_credentials: Optional[bool] = None,
                 allow_headers: Optional[Sequence[str]] = None,
                 allow_methods: Optional[Sequence[str]] = None,
                 allow_origin_regexes: Optional[Sequence[str]] = None,
                 allow_origins: Optional[Sequence[str]] = None,
                 disabled: Optional[bool] = None,
                 expose_headers: Optional[Sequence[str]] = None,
                 max_age: Optional[int] = None):
        """
        :param bool allow_credentials: In response to a preflight request, setting this to true indicates that the actual request can include user credentials. This field translates to the Access-Control-Allow-Credentials header.
               Default is false.
        :param Sequence[str] allow_headers: Specifies the content for the Access-Control-Allow-Headers header.
        :param Sequence[str] allow_methods: Specifies the content for the Access-Control-Allow-Methods header.
        :param Sequence[str] allow_origin_regexes: Specifies the regualar 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 Sequence[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 bool disabled: If true, the setting specifies the CORS policy is disabled. The default value of false, which indicates that the CORS policy is in effect.
        :param Sequence[str] expose_headers: Specifies the content for the Access-Control-Expose-Headers header.
        :param 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[bool]:
        """
        In response to a preflight request, setting this to true indicates that the actual request can include user credentials. This field translates to the Access-Control-Allow-Credentials header.
        Default is false.
        """
        return pulumi.get(self, "allow_credentials")

    @property
    @pulumi.getter(name="allowHeaders")
    def allow_headers(self) -> Optional[Sequence[str]]:
        """
        Specifies the content for the Access-Control-Allow-Headers header.
        """
        return pulumi.get(self, "allow_headers")

    @property
    @pulumi.getter(name="allowMethods")
    def allow_methods(self) -> Optional[Sequence[str]]:
        """
        Specifies the content for the Access-Control-Allow-Methods header.
        """
        return pulumi.get(self, "allow_methods")

    @property
    @pulumi.getter(name="allowOriginRegexes")
    def allow_origin_regexes(self) -> Optional[Sequence[str]]:
        """
        Specifies the regualar 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")

    @property
    @pulumi.getter(name="allowOrigins")
    def allow_origins(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter
    def disabled(self) -> Optional[bool]:
        """
        If true, the setting specifies the CORS policy is disabled. The default value of false, which indicates that the CORS policy is in effect.
        """
        return pulumi.get(self, "disabled")

    @property
    @pulumi.getter(name="exposeHeaders")
    def expose_headers(self) -> Optional[Sequence[str]]:
        """
        Specifies the content for the Access-Control-Expose-Headers header.
        """
        return pulumi.get(self, "expose_headers")

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[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")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicy(dict):
    def __init__(__self__, *,
                 abort: Optional['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbort'] = None,
                 delay: Optional['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelay'] = None):
        """
        :param 'RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbortArgs' abort: The specification for how client requests are aborted as part of fault injection.
               Structure is documented below.
        :param '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['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbort']:
        """
        The specification for how client requests are aborted as part of fault injection.
        Structure is documented below.
        """
        return pulumi.get(self, "abort")

    @property
    @pulumi.getter
    def delay(self) -> Optional['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelay']:
        """
        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")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbort(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "httpStatus":
            suggest = "http_status"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbort. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbort.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbort.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 http_status: Optional[int] = None,
                 percentage: Optional[float] = None):
        """
        :param int http_status: The HTTP status code used to abort the request.
               The value must be between 200 and 599 inclusive.
        :param 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[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")

    @property
    @pulumi.getter
    def percentage(self) -> Optional[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")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelay(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fixedDelay":
            suggest = "fixed_delay"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelay. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelay.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelay.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 fixed_delay: Optional['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelay'] = None,
                 percentage: Optional[float] = None):
        """
        :param 'RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs' fixed_delay: Specifies the value of the fixed delay interval.
               Structure is documented below.
        :param 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['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelay']:
        """
        Specifies the value of the fixed delay interval.
        Structure is documented below.
        """
        return pulumi.get(self, "fixed_delay")

    @property
    @pulumi.getter
    def percentage(self) -> Optional[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")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelay(dict):
    def __init__(__self__, *,
                 seconds: str,
                 nanos: Optional[int] = None):
        """
        :param 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 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) -> 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")

    @property
    @pulumi.getter
    def nanos(self) -> Optional[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")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleRouteActionRequestMirrorPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backendService":
            suggest = "backend_service"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherRouteRuleRouteActionRequestMirrorPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherRouteRuleRouteActionRequestMirrorPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherRouteRuleRouteActionRequestMirrorPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 backend_service: str):
        """
        :param str backend_service: The full or partial URL to the RegionBackendService resource being mirrored to.
               The backend service configured for a mirroring policy must reference backends that are of the same type as the original backend service matched in the URL map.
               Serverless NEG backends are not currently supported as a mirrored backend service.
        """
        pulumi.set(__self__, "backend_service", backend_service)

    @property
    @pulumi.getter(name="backendService")
    def backend_service(self) -> str:
        """
        The full or partial URL to the RegionBackendService resource being mirrored to.
        The backend service configured for a mirroring policy must reference backends that are of the same type as the original backend service matched in the URL map.
        Serverless NEG backends are not currently supported as a mirrored backend service.
        """
        return pulumi.get(self, "backend_service")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "numRetries":
            suggest = "num_retries"
        elif key == "perTryTimeout":
            suggest = "per_try_timeout"
        elif key == "retryConditions":
            suggest = "retry_conditions"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 num_retries: int,
                 per_try_timeout: Optional['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeout'] = None,
                 retry_conditions: Optional[Sequence[str]] = None):
        """
        :param int num_retries: Specifies the allowed number retries. This number must be > 0. If not specified, defaults to 1.
        :param 'RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeoutArgs' 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 Sequence[str] retry_conditions: Specifies one or more conditions when this retry policy applies.
               Valid values are listed below. Only the following codes are supported when the URL map is bound to target gRPC proxy that has validateForProxyless field set to true: cancelled, deadline-exceeded, internal, resource-exhausted, unavailable.
               - 5xx : retry is attempted if the instance or endpoint responds with any 5xx response code, or if the instance or endpoint does not respond at all. For 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 : a retry is attempted on failures connecting to the instance or endpoint. For example, connection timeouts.
               - retriable-4xx : a retry is attempted if the instance or endpoint responds with a 4xx response code. The only error that you can retry is error code 409.
               - refused-stream : a retry is attempted if the instance or endpoint resets the stream with a REFUSED_STREAM error code. This reset type indicates that it is safe to retry.
               - cancelled : a retry is attempted if the gRPC status code in the response header is set to cancelled.
               - deadline-exceeded : a retry is attempted if the gRPC status code in the response header is set to deadline-exceeded.
               - internal :  a retry is attempted if the gRPC status code in the response header is set to internal.
               - resource-exhausted : a retry is attempted if the gRPC status code in the response header is set to resource-exhausted.
               - unavailable : a retry is attempted 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) -> int:
        """
        Specifies the allowed number retries. This number must be > 0. If not specified, defaults to 1.
        """
        return pulumi.get(self, "num_retries")

    @property
    @pulumi.getter(name="perTryTimeout")
    def per_try_timeout(self) -> Optional['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeout']:
        """
        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")

    @property
    @pulumi.getter(name="retryConditions")
    def retry_conditions(self) -> Optional[Sequence[str]]:
        """
        Specifies one or more conditions when this retry policy applies.
        Valid values are listed below. Only the following codes are supported when the URL map is bound to target gRPC proxy that has validateForProxyless field set to true: cancelled, deadline-exceeded, internal, resource-exhausted, unavailable.
        - 5xx : retry is attempted if the instance or endpoint responds with any 5xx response code, or if the instance or endpoint does not respond at all. For 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 : a retry is attempted on failures connecting to the instance or endpoint. For example, connection timeouts.
        - retriable-4xx : a retry is attempted if the instance or endpoint responds with a 4xx response code. The only error that you can retry is error code 409.
        - refused-stream : a retry is attempted if the instance or endpoint resets the stream with a REFUSED_STREAM error code. This reset type indicates that it is safe to retry.
        - cancelled : a retry is attempted if the gRPC status code in the response header is set to cancelled.
        - deadline-exceeded : a retry is attempted if the gRPC status code in the response header is set to deadline-exceeded.
        - internal :  a retry is attempted if the gRPC status code in the response header is set to internal.
        - resource-exhausted : a retry is attempted if the gRPC status code in the response header is set to resource-exhausted.
        - unavailable : a retry is attempted if the gRPC status code in the response header is set to unavailable.
        """
        return pulumi.get(self, "retry_conditions")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeout(dict):
    def __init__(__self__, *,
                 seconds: str,
                 nanos: Optional[int] = None):
        """
        :param 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 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) -> 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")

    @property
    @pulumi.getter
    def nanos(self) -> Optional[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")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleRouteActionTimeout(dict):
    def __init__(__self__, *,
                 seconds: str,
                 nanos: Optional[int] = None):
        """
        :param 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 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) -> 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")

    @property
    @pulumi.getter
    def nanos(self) -> Optional[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")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleRouteActionUrlRewrite(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hostRewrite":
            suggest = "host_rewrite"
        elif key == "pathPrefixRewrite":
            suggest = "path_prefix_rewrite"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherRouteRuleRouteActionUrlRewrite. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherRouteRuleRouteActionUrlRewrite.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherRouteRuleRouteActionUrlRewrite.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 host_rewrite: Optional[str] = None,
                 path_prefix_rewrite: Optional[str] = None):
        """
        :param str host_rewrite: Before forwarding the request to the selected service, the request's host header is replaced with contents of hostRewrite.
               The value must be from 1 to 255 characters.
        :param str path_prefix_rewrite: Before forwarding the request to the selected backend service, the matching portion of the request's path is replaced by pathPrefixRewrite.
               The value must be from 1 to 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[str]:
        """
        Before forwarding the request to the selected service, the request's host header is replaced with contents of hostRewrite.
        The value must be from 1 to 255 characters.
        """
        return pulumi.get(self, "host_rewrite")

    @property
    @pulumi.getter(name="pathPrefixRewrite")
    def path_prefix_rewrite(self) -> Optional[str]:
        """
        Before forwarding the request to the selected backend service, the matching portion of the request's path is replaced by pathPrefixRewrite.
        The value must be from 1 to 1024 characters.
        """
        return pulumi.get(self, "path_prefix_rewrite")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendService(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backendService":
            suggest = "backend_service"
        elif key == "headerAction":
            suggest = "header_action"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendService. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendService.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendService.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 backend_service: str,
                 weight: int,
                 header_action: Optional['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderAction'] = None):
        """
        :param str backend_service: The full or partial URL to the default BackendService resource. Before forwarding the request to backendService, the load balancer applies any relevant headerActions specified as part of this backendServiceWeight.
        :param int weight: Specifies the fraction of traffic sent to a backend service, 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 backend service, subsequent requests are sent to the same backend service as determined by the backend service's session affinity policy.
               The value must be from 0 to 1000.
        :param '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.
               headerAction is not supported for load balancers that have their loadBalancingScheme set to EXTERNAL.
               Not supported when the URL map is bound to a target gRPC proxy that has validateForProxyless field set to true.
               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) -> str:
        """
        The full or partial URL to the default BackendService resource. Before forwarding the request to backendService, the load balancer applies any relevant headerActions specified as part of this backendServiceWeight.
        """
        return pulumi.get(self, "backend_service")

    @property
    @pulumi.getter
    def weight(self) -> int:
        """
        Specifies the fraction of traffic sent to a backend service, 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 backend service, subsequent requests are sent to the same backend service as determined by the backend service's session affinity policy.
        The value must be from 0 to 1000.
        """
        return pulumi.get(self, "weight")

    @property
    @pulumi.getter(name="headerAction")
    def header_action(self) -> Optional['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderAction']:
        """
        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.
        headerAction is not supported for load balancers that have their loadBalancingScheme set to EXTERNAL.
        Not supported when the URL map is bound to a target gRPC proxy that has validateForProxyless field set to true.
        Structure is documented below.
        """
        return pulumi.get(self, "header_action")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "requestHeadersToAdds":
            suggest = "request_headers_to_adds"
        elif key == "requestHeadersToRemoves":
            suggest = "request_headers_to_removes"
        elif key == "responseHeadersToAdds":
            suggest = "response_headers_to_adds"
        elif key == "responseHeadersToRemoves":
            suggest = "response_headers_to_removes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 request_headers_to_adds: Optional[Sequence['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd']] = None,
                 request_headers_to_removes: Optional[Sequence[str]] = None,
                 response_headers_to_adds: Optional[Sequence['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd']] = None,
                 response_headers_to_removes: Optional[Sequence[str]] = None):
        """
        :param Sequence['RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs'] request_headers_to_adds: Headers to add to a matching request before forwarding the request to the backendService.
               Structure is documented below.
        :param Sequence[str] request_headers_to_removes: A list of header names for headers that need to be removed from the request before forwarding the request to the backendService.
        :param Sequence['RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs'] response_headers_to_adds: Headers to add the response before sending the response back to the client.
               Structure is documented below.
        :param Sequence[str] response_headers_to_removes: A list of header names for headers that need to be removed from the response before 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[Sequence['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd']]:
        """
        Headers to add to a matching request before forwarding the request to the backendService.
        Structure is documented below.
        """
        return pulumi.get(self, "request_headers_to_adds")

    @property
    @pulumi.getter(name="requestHeadersToRemoves")
    def request_headers_to_removes(self) -> Optional[Sequence[str]]:
        """
        A list of header names for headers that need to be removed from the request before forwarding the request to the backendService.
        """
        return pulumi.get(self, "request_headers_to_removes")

    @property
    @pulumi.getter(name="responseHeadersToAdds")
    def response_headers_to_adds(self) -> Optional[Sequence['outputs.RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd']]:
        """
        Headers to add the response before sending the response back to the client.
        Structure is documented below.
        """
        return pulumi.get(self, "response_headers_to_adds")

    @property
    @pulumi.getter(name="responseHeadersToRemoves")
    def response_headers_to_removes(self) -> Optional[Sequence[str]]:
        """
        A list of header names for headers that need to be removed from the response before sending the response back to the client.
        """
        return pulumi.get(self, "response_headers_to_removes")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: str,
                 header_value: str,
                 replace: bool):
        """
        :param str header_name: The name of the header.
        :param str header_value: The value of the header to add.
        :param 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.
               The default value is false.
        """
        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) -> str:
        """
        The name of the header.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> str:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @property
    @pulumi.getter
    def replace(self) -> 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.
        The default value is false.
        """
        return pulumi.get(self, "replace")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: str,
                 header_value: str,
                 replace: bool):
        """
        :param str header_name: The name of the header.
        :param str header_value: The value of the header to add.
        :param 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.
               The default value is false.
        """
        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) -> str:
        """
        The name of the header.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> str:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @property
    @pulumi.getter
    def replace(self) -> 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.
        The default value is false.
        """
        return pulumi.get(self, "replace")


@pulumi.output_type
class RegionUrlMapPathMatcherRouteRuleUrlRedirect(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hostRedirect":
            suggest = "host_redirect"
        elif key == "httpsRedirect":
            suggest = "https_redirect"
        elif key == "pathRedirect":
            suggest = "path_redirect"
        elif key == "prefixRedirect":
            suggest = "prefix_redirect"
        elif key == "redirectResponseCode":
            suggest = "redirect_response_code"
        elif key == "stripQuery":
            suggest = "strip_query"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RegionUrlMapPathMatcherRouteRuleUrlRedirect. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RegionUrlMapPathMatcherRouteRuleUrlRedirect.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RegionUrlMapPathMatcherRouteRuleUrlRedirect.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 host_redirect: Optional[str] = None,
                 https_redirect: Optional[bool] = None,
                 path_redirect: Optional[str] = None,
                 prefix_redirect: Optional[str] = None,
                 redirect_response_code: Optional[str] = None,
                 strip_query: Optional[bool] = None):
        """
        :param 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 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 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 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 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 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[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")

    @property
    @pulumi.getter(name="httpsRedirect")
    def https_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="pathRedirect")
    def path_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="prefixRedirect")
    def prefix_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="redirectResponseCode")
    def redirect_response_code(self) -> Optional[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")

    @property
    @pulumi.getter(name="stripQuery")
    def strip_query(self) -> Optional[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")


@pulumi.output_type
class RegionUrlMapTest(dict):
    def __init__(__self__, *,
                 host: str,
                 path: str,
                 service: str,
                 description: Optional[str] = None):
        """
        :param str host: Host portion of the URL.
        :param str path: Path portion of the URL.
        :param str service: A reference to expected RegionBackendService resource the given URL should be mapped to.
        :param 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) -> str:
        """
        Host portion of the URL.
        """
        return pulumi.get(self, "host")

    @property
    @pulumi.getter
    def path(self) -> str:
        """
        Path portion of the URL.
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def service(self) -> str:
        """
        A reference to expected RegionBackendService resource the given URL should be mapped to.
        """
        return pulumi.get(self, "service")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        Description of this test case.
        """
        return pulumi.get(self, "description")


@pulumi.output_type
class ReservationShareSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "projectMaps":
            suggest = "project_maps"
        elif key == "shareType":
            suggest = "share_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ReservationShareSettings. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ReservationShareSettings.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ReservationShareSettings.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 project_maps: Optional[Sequence['outputs.ReservationShareSettingsProjectMap']] = None,
                 share_type: Optional[str] = None):
        """
        :param Sequence['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 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[Sequence['outputs.ReservationShareSettingsProjectMap']]:
        """
        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")

    @property
    @pulumi.getter(name="shareType")
    def share_type(self) -> Optional[str]:
        """
        Type of sharing for this shared-reservation
        Possible values are `LOCAL` and `SPECIFIC_PROJECTS`.
        """
        return pulumi.get(self, "share_type")


@pulumi.output_type
class ReservationShareSettingsProjectMap(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "projectId":
            suggest = "project_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ReservationShareSettingsProjectMap. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ReservationShareSettingsProjectMap.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ReservationShareSettingsProjectMap.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 id: str,
                 project_id: Optional[str] = None):
        """
        :param str id: The identifier for this object. Format specified above.
        :param 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) -> str:
        """
        The identifier for this object. Format specified above.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> Optional[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")


@pulumi.output_type
class ReservationSpecificReservation(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceProperties":
            suggest = "instance_properties"
        elif key == "inUseCount":
            suggest = "in_use_count"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ReservationSpecificReservation. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ReservationSpecificReservation.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ReservationSpecificReservation.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 count: int,
                 instance_properties: 'outputs.ReservationSpecificReservationInstanceProperties',
                 in_use_count: Optional[int] = None):
        """
        :param int count: The number of resources that are allocated.
        :param 'ReservationSpecificReservationInstancePropertiesArgs' instance_properties: The instance properties for the reservation.
               Structure is documented below.
        :param 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) -> int:
        """
        The number of resources that are allocated.
        """
        return pulumi.get(self, "count")

    @property
    @pulumi.getter(name="instanceProperties")
    def instance_properties(self) -> 'outputs.ReservationSpecificReservationInstanceProperties':
        """
        The instance properties for the reservation.
        Structure is documented below.
        """
        return pulumi.get(self, "instance_properties")

    @property
    @pulumi.getter(name="inUseCount")
    def in_use_count(self) -> Optional[int]:
        """
        How many instances are in use.
        """
        return pulumi.get(self, "in_use_count")


@pulumi.output_type
class ReservationSpecificReservationInstanceProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "machineType":
            suggest = "machine_type"
        elif key == "guestAccelerators":
            suggest = "guest_accelerators"
        elif key == "localSsds":
            suggest = "local_ssds"
        elif key == "minCpuPlatform":
            suggest = "min_cpu_platform"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ReservationSpecificReservationInstanceProperties. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ReservationSpecificReservationInstanceProperties.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ReservationSpecificReservationInstanceProperties.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 machine_type: str,
                 guest_accelerators: Optional[Sequence['outputs.ReservationSpecificReservationInstancePropertiesGuestAccelerator']] = None,
                 local_ssds: Optional[Sequence['outputs.ReservationSpecificReservationInstancePropertiesLocalSsd']] = None,
                 min_cpu_platform: Optional[str] = None):
        """
        :param str machine_type: The name of the machine type to reserve.
        :param Sequence['ReservationSpecificReservationInstancePropertiesGuestAcceleratorArgs'] guest_accelerators: Guest accelerator type and count.
               Structure is documented below.
        :param Sequence['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 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) -> str:
        """
        The name of the machine type to reserve.
        """
        return pulumi.get(self, "machine_type")

    @property
    @pulumi.getter(name="guestAccelerators")
    def guest_accelerators(self) -> Optional[Sequence['outputs.ReservationSpecificReservationInstancePropertiesGuestAccelerator']]:
        """
        Guest accelerator type and count.
        Structure is documented below.
        """
        return pulumi.get(self, "guest_accelerators")

    @property
    @pulumi.getter(name="localSsds")
    def local_ssds(self) -> Optional[Sequence['outputs.ReservationSpecificReservationInstancePropertiesLocalSsd']]:
        """
        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")

    @property
    @pulumi.getter(name="minCpuPlatform")
    def min_cpu_platform(self) -> Optional[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")


@pulumi.output_type
class ReservationSpecificReservationInstancePropertiesGuestAccelerator(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "acceleratorCount":
            suggest = "accelerator_count"
        elif key == "acceleratorType":
            suggest = "accelerator_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ReservationSpecificReservationInstancePropertiesGuestAccelerator. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ReservationSpecificReservationInstancePropertiesGuestAccelerator.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ReservationSpecificReservationInstancePropertiesGuestAccelerator.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 accelerator_count: int,
                 accelerator_type: str):
        """
        :param int accelerator_count: The number of the guest accelerator cards exposed to
               this instance.
        :param 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) -> int:
        """
        The number of the guest accelerator cards exposed to
        this instance.
        """
        return pulumi.get(self, "accelerator_count")

    @property
    @pulumi.getter(name="acceleratorType")
    def accelerator_type(self) -> 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")


@pulumi.output_type
class ReservationSpecificReservationInstancePropertiesLocalSsd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "diskSizeGb":
            suggest = "disk_size_gb"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ReservationSpecificReservationInstancePropertiesLocalSsd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ReservationSpecificReservationInstancePropertiesLocalSsd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ReservationSpecificReservationInstancePropertiesLocalSsd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 disk_size_gb: int,
                 interface: Optional[str] = None):
        """
        :param int disk_size_gb: The size of the disk in base-2 GB.
        :param 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) -> int:
        """
        The size of the disk in base-2 GB.
        """
        return pulumi.get(self, "disk_size_gb")

    @property
    @pulumi.getter
    def interface(self) -> Optional[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")


@pulumi.output_type
class ResourcePolicyGroupPlacementPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "availabilityDomainCount":
            suggest = "availability_domain_count"
        elif key == "maxDistance":
            suggest = "max_distance"
        elif key == "vmCount":
            suggest = "vm_count"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ResourcePolicyGroupPlacementPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ResourcePolicyGroupPlacementPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ResourcePolicyGroupPlacementPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 availability_domain_count: Optional[int] = None,
                 collocation: Optional[str] = None,
                 max_distance: Optional[int] = None,
                 vm_count: Optional[int] = None):
        """
        :param 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 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 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 max_distance is not None:
            pulumi.set(__self__, "max_distance", max_distance)
        if vm_count is not None:
            pulumi.set(__self__, "vm_count", vm_count)

    @property
    @pulumi.getter(name="availabilityDomainCount")
    def availability_domain_count(self) -> Optional[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")

    @property
    @pulumi.getter
    def collocation(self) -> Optional[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")

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

    @property
    @pulumi.getter(name="vmCount")
    def vm_count(self) -> Optional[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")


@pulumi.output_type
class ResourcePolicyInstanceSchedulePolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "timeZone":
            suggest = "time_zone"
        elif key == "expirationTime":
            suggest = "expiration_time"
        elif key == "startTime":
            suggest = "start_time"
        elif key == "vmStartSchedule":
            suggest = "vm_start_schedule"
        elif key == "vmStopSchedule":
            suggest = "vm_stop_schedule"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ResourcePolicyInstanceSchedulePolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ResourcePolicyInstanceSchedulePolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ResourcePolicyInstanceSchedulePolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 time_zone: str,
                 expiration_time: Optional[str] = None,
                 start_time: Optional[str] = None,
                 vm_start_schedule: Optional['outputs.ResourcePolicyInstanceSchedulePolicyVmStartSchedule'] = None,
                 vm_stop_schedule: Optional['outputs.ResourcePolicyInstanceSchedulePolicyVmStopSchedule'] = None):
        """
        :param 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 str expiration_time: The expiration time of the schedule. The timestamp is an RFC3339 string.
        :param str start_time: The start time of the schedule. The timestamp is an RFC3339 string.
        :param 'ResourcePolicyInstanceSchedulePolicyVmStartScheduleArgs' vm_start_schedule: Specifies the schedule for starting instances.
               Structure is documented below.
        :param '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) -> 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")

    @property
    @pulumi.getter(name="expirationTime")
    def expiration_time(self) -> Optional[str]:
        """
        The expiration time of the schedule. The timestamp is an RFC3339 string.
        """
        return pulumi.get(self, "expiration_time")

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> Optional[str]:
        """
        The start time of the schedule. The timestamp is an RFC3339 string.
        """
        return pulumi.get(self, "start_time")

    @property
    @pulumi.getter(name="vmStartSchedule")
    def vm_start_schedule(self) -> Optional['outputs.ResourcePolicyInstanceSchedulePolicyVmStartSchedule']:
        """
        Specifies the schedule for starting instances.
        Structure is documented below.
        """
        return pulumi.get(self, "vm_start_schedule")

    @property
    @pulumi.getter(name="vmStopSchedule")
    def vm_stop_schedule(self) -> Optional['outputs.ResourcePolicyInstanceSchedulePolicyVmStopSchedule']:
        """
        Specifies the schedule for stopping instances.
        Structure is documented below.
        """
        return pulumi.get(self, "vm_stop_schedule")


@pulumi.output_type
class ResourcePolicyInstanceSchedulePolicyVmStartSchedule(dict):
    def __init__(__self__, *,
                 schedule: str):
        """
        :param str schedule: Specifies the frequency for the operation, using the unix-cron format.
        """
        pulumi.set(__self__, "schedule", schedule)

    @property
    @pulumi.getter
    def schedule(self) -> str:
        """
        Specifies the frequency for the operation, using the unix-cron format.
        """
        return pulumi.get(self, "schedule")


@pulumi.output_type
class ResourcePolicyInstanceSchedulePolicyVmStopSchedule(dict):
    def __init__(__self__, *,
                 schedule: str):
        """
        :param str schedule: Specifies the frequency for the operation, using the unix-cron format.
        """
        pulumi.set(__self__, "schedule", schedule)

    @property
    @pulumi.getter
    def schedule(self) -> str:
        """
        Specifies the frequency for the operation, using the unix-cron format.
        """
        return pulumi.get(self, "schedule")


@pulumi.output_type
class ResourcePolicySnapshotSchedulePolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "retentionPolicy":
            suggest = "retention_policy"
        elif key == "snapshotProperties":
            suggest = "snapshot_properties"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ResourcePolicySnapshotSchedulePolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ResourcePolicySnapshotSchedulePolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ResourcePolicySnapshotSchedulePolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 schedule: 'outputs.ResourcePolicySnapshotSchedulePolicySchedule',
                 retention_policy: Optional['outputs.ResourcePolicySnapshotSchedulePolicyRetentionPolicy'] = None,
                 snapshot_properties: Optional['outputs.ResourcePolicySnapshotSchedulePolicySnapshotProperties'] = None):
        """
        :param 'ResourcePolicySnapshotSchedulePolicyScheduleArgs' schedule: Contains one of an `hourlySchedule`, `dailySchedule`, or `weeklySchedule`.
               Structure is documented below.
        :param 'ResourcePolicySnapshotSchedulePolicyRetentionPolicyArgs' retention_policy: Retention policy applied to snapshots created by this resource policy.
               Structure is documented below.
        :param '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) -> 'outputs.ResourcePolicySnapshotSchedulePolicySchedule':
        """
        Contains one of an `hourlySchedule`, `dailySchedule`, or `weeklySchedule`.
        Structure is documented below.
        """
        return pulumi.get(self, "schedule")

    @property
    @pulumi.getter(name="retentionPolicy")
    def retention_policy(self) -> Optional['outputs.ResourcePolicySnapshotSchedulePolicyRetentionPolicy']:
        """
        Retention policy applied to snapshots created by this resource policy.
        Structure is documented below.
        """
        return pulumi.get(self, "retention_policy")

    @property
    @pulumi.getter(name="snapshotProperties")
    def snapshot_properties(self) -> Optional['outputs.ResourcePolicySnapshotSchedulePolicySnapshotProperties']:
        """
        Properties with which the snapshots are created, such as labels.
        Structure is documented below.
        """
        return pulumi.get(self, "snapshot_properties")


@pulumi.output_type
class ResourcePolicySnapshotSchedulePolicyRetentionPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxRetentionDays":
            suggest = "max_retention_days"
        elif key == "onSourceDiskDelete":
            suggest = "on_source_disk_delete"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ResourcePolicySnapshotSchedulePolicyRetentionPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ResourcePolicySnapshotSchedulePolicyRetentionPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ResourcePolicySnapshotSchedulePolicyRetentionPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 max_retention_days: int,
                 on_source_disk_delete: Optional[str] = None):
        """
        :param int max_retention_days: Maximum age of the snapshot that is allowed to be kept.
        :param 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) -> int:
        """
        Maximum age of the snapshot that is allowed to be kept.
        """
        return pulumi.get(self, "max_retention_days")

    @property
    @pulumi.getter(name="onSourceDiskDelete")
    def on_source_disk_delete(self) -> Optional[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")


@pulumi.output_type
class ResourcePolicySnapshotSchedulePolicySchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dailySchedule":
            suggest = "daily_schedule"
        elif key == "hourlySchedule":
            suggest = "hourly_schedule"
        elif key == "weeklySchedule":
            suggest = "weekly_schedule"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ResourcePolicySnapshotSchedulePolicySchedule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ResourcePolicySnapshotSchedulePolicySchedule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ResourcePolicySnapshotSchedulePolicySchedule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 daily_schedule: Optional['outputs.ResourcePolicySnapshotSchedulePolicyScheduleDailySchedule'] = None,
                 hourly_schedule: Optional['outputs.ResourcePolicySnapshotSchedulePolicyScheduleHourlySchedule'] = None,
                 weekly_schedule: Optional['outputs.ResourcePolicySnapshotSchedulePolicyScheduleWeeklySchedule'] = None):
        """
        :param 'ResourcePolicySnapshotSchedulePolicyScheduleDailyScheduleArgs' daily_schedule: The policy will execute every nth day at the specified time.
               Structure is documented below.
        :param 'ResourcePolicySnapshotSchedulePolicyScheduleHourlyScheduleArgs' hourly_schedule: The policy will execute every nth hour starting at the specified time.
               Structure is documented below.
        :param '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['outputs.ResourcePolicySnapshotSchedulePolicyScheduleDailySchedule']:
        """
        The policy will execute every nth day at the specified time.
        Structure is documented below.
        """
        return pulumi.get(self, "daily_schedule")

    @property
    @pulumi.getter(name="hourlySchedule")
    def hourly_schedule(self) -> Optional['outputs.ResourcePolicySnapshotSchedulePolicyScheduleHourlySchedule']:
        """
        The policy will execute every nth hour starting at the specified time.
        Structure is documented below.
        """
        return pulumi.get(self, "hourly_schedule")

    @property
    @pulumi.getter(name="weeklySchedule")
    def weekly_schedule(self) -> Optional['outputs.ResourcePolicySnapshotSchedulePolicyScheduleWeeklySchedule']:
        """
        Allows specifying a snapshot time for each day of the week.
        Structure is documented below.
        """
        return pulumi.get(self, "weekly_schedule")


@pulumi.output_type
class ResourcePolicySnapshotSchedulePolicyScheduleDailySchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "daysInCycle":
            suggest = "days_in_cycle"
        elif key == "startTime":
            suggest = "start_time"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ResourcePolicySnapshotSchedulePolicyScheduleDailySchedule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ResourcePolicySnapshotSchedulePolicyScheduleDailySchedule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ResourcePolicySnapshotSchedulePolicyScheduleDailySchedule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 days_in_cycle: int,
                 start_time: str):
        """
        :param int days_in_cycle: The number of days between snapshots.
        :param str start_time: 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__, "days_in_cycle", days_in_cycle)
        pulumi.set(__self__, "start_time", start_time)

    @property
    @pulumi.getter(name="daysInCycle")
    def days_in_cycle(self) -> int:
        """
        The number of days between snapshots.
        """
        return pulumi.get(self, "days_in_cycle")

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> str:
        """
        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")


@pulumi.output_type
class ResourcePolicySnapshotSchedulePolicyScheduleHourlySchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hoursInCycle":
            suggest = "hours_in_cycle"
        elif key == "startTime":
            suggest = "start_time"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ResourcePolicySnapshotSchedulePolicyScheduleHourlySchedule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ResourcePolicySnapshotSchedulePolicyScheduleHourlySchedule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ResourcePolicySnapshotSchedulePolicyScheduleHourlySchedule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 hours_in_cycle: int,
                 start_time: str):
        """
        :param int hours_in_cycle: The number of hours between snapshots.
        :param str start_time: Time within the window to start the operations.
               It must be in an hourly format "HH:MM",
               where HH : [00-23] and MM : [00] GMT.
               eg: 21:00
        """
        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) -> int:
        """
        The number of hours between snapshots.
        """
        return pulumi.get(self, "hours_in_cycle")

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> str:
        """
        Time within the window to start the operations.
        It must be in an hourly format "HH:MM",
        where HH : [00-23] and MM : [00] GMT.
        eg: 21:00
        """
        return pulumi.get(self, "start_time")


@pulumi.output_type
class ResourcePolicySnapshotSchedulePolicyScheduleWeeklySchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dayOfWeeks":
            suggest = "day_of_weeks"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ResourcePolicySnapshotSchedulePolicyScheduleWeeklySchedule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ResourcePolicySnapshotSchedulePolicyScheduleWeeklySchedule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ResourcePolicySnapshotSchedulePolicyScheduleWeeklySchedule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 day_of_weeks: Sequence['outputs.ResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleDayOfWeek']):
        """
        :param Sequence['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) -> Sequence['outputs.ResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleDayOfWeek']:
        """
        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")


@pulumi.output_type
class ResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleDayOfWeek(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "startTime":
            suggest = "start_time"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleDayOfWeek. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleDayOfWeek.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleDayOfWeek.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 day: str,
                 start_time: str):
        """
        :param 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 str start_time: Time within the window to start the operations.
               It must be in format "HH:MM", where HH : [00-23] and MM : [00-00] GMT.
        """
        pulumi.set(__self__, "day", day)
        pulumi.set(__self__, "start_time", start_time)

    @property
    @pulumi.getter
    def day(self) -> 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")

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> str:
        """
        Time within the window to start the operations.
        It must be in format "HH:MM", where HH : [00-23] and MM : [00-00] GMT.
        """
        return pulumi.get(self, "start_time")


@pulumi.output_type
class ResourcePolicySnapshotSchedulePolicySnapshotProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "chainName":
            suggest = "chain_name"
        elif key == "guestFlush":
            suggest = "guest_flush"
        elif key == "storageLocations":
            suggest = "storage_locations"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ResourcePolicySnapshotSchedulePolicySnapshotProperties. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ResourcePolicySnapshotSchedulePolicySnapshotProperties.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ResourcePolicySnapshotSchedulePolicySnapshotProperties.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 chain_name: Optional[str] = None,
                 guest_flush: Optional[bool] = None,
                 labels: Optional[Mapping[str, str]] = None,
                 storage_locations: Optional[str] = None):
        """
        :param str chain_name: Creates the new snapshot in the snapshot chain labeled with the
               specified name. The chain name must be 1-63 characters long and comply
               with RFC1035.
        :param bool guest_flush: Whether to perform a 'guest aware' snapshot.
        :param Mapping[str, str] labels: A set of key-value pairs.
        :param str storage_locations: Cloud Storage bucket location to store the auto snapshot
               (regional or multi-regional)
        """
        if chain_name is not None:
            pulumi.set(__self__, "chain_name", chain_name)
        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="chainName")
    def chain_name(self) -> Optional[str]:
        """
        Creates the new snapshot in the snapshot chain labeled with the
        specified name. The chain name must be 1-63 characters long and comply
        with RFC1035.
        """
        return pulumi.get(self, "chain_name")

    @property
    @pulumi.getter(name="guestFlush")
    def guest_flush(self) -> Optional[bool]:
        """
        Whether to perform a 'guest aware' snapshot.
        """
        return pulumi.get(self, "guest_flush")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, str]]:
        """
        A set of key-value pairs.
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="storageLocations")
    def storage_locations(self) -> Optional[str]:
        """
        Cloud Storage bucket location to store the auto snapshot
        (regional or multi-regional)
        """
        return pulumi.get(self, "storage_locations")


@pulumi.output_type
class RouterBgp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "advertiseMode":
            suggest = "advertise_mode"
        elif key == "advertisedGroups":
            suggest = "advertised_groups"
        elif key == "advertisedIpRanges":
            suggest = "advertised_ip_ranges"
        elif key == "keepaliveInterval":
            suggest = "keepalive_interval"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RouterBgp. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RouterBgp.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RouterBgp.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 asn: int,
                 advertise_mode: Optional[str] = None,
                 advertised_groups: Optional[Sequence[str]] = None,
                 advertised_ip_ranges: Optional[Sequence['outputs.RouterBgpAdvertisedIpRange']] = None,
                 keepalive_interval: Optional[int] = None):
        """
        :param 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 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 Sequence[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 Sequence['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 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) -> 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")

    @property
    @pulumi.getter(name="advertiseMode")
    def advertise_mode(self) -> Optional[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")

    @property
    @pulumi.getter(name="advertisedGroups")
    def advertised_groups(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter(name="advertisedIpRanges")
    def advertised_ip_ranges(self) -> Optional[Sequence['outputs.RouterBgpAdvertisedIpRange']]:
        """
        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")

    @property
    @pulumi.getter(name="keepaliveInterval")
    def keepalive_interval(self) -> Optional[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")


@pulumi.output_type
class RouterBgpAdvertisedIpRange(dict):
    def __init__(__self__, *,
                 range: str,
                 description: Optional[str] = None):
        """
        :param str range: The IP range to advertise. The value must be a
               CIDR-formatted string.
        :param 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) -> str:
        """
        The IP range to advertise. The value must be a
        CIDR-formatted string.
        """
        return pulumi.get(self, "range")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        User-specified description for the IP range.
        """
        return pulumi.get(self, "description")


@pulumi.output_type
class RouterNatLogConfig(dict):
    def __init__(__self__, *,
                 enable: bool,
                 filter: str):
        """
        :param bool enable: Indicates whether or not to export logs.
        :param 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) -> bool:
        """
        Indicates whether or not to export logs.
        """
        return pulumi.get(self, "enable")

    @property
    @pulumi.getter
    def filter(self) -> str:
        """
        Specifies the desired filtering of logs on this NAT.
        Possible values are `ERRORS_ONLY`, `TRANSLATIONS_ONLY`, and `ALL`.
        """
        return pulumi.get(self, "filter")


@pulumi.output_type
class RouterNatRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ruleNumber":
            suggest = "rule_number"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RouterNatRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RouterNatRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RouterNatRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 match: str,
                 rule_number: int,
                 action: Optional['outputs.RouterNatRuleAction'] = None,
                 description: Optional[str] = None):
        """
        :param str match: CEL expression that specifies the match condition that egress traffic from a VM is evaluated against.
               If it evaluates to true, the corresponding action is enforced.
               The following examples are valid match expressions for public NAT:
               "inIpRange(destination.ip, '1.1.0.0/16') || inIpRange(destination.ip, '2.2.0.0/16')"
               "destination.ip == '1.1.0.1' || destination.ip == '8.8.8.8'"
               The following example is a valid match expression for private NAT:
               "nexthop.hub == 'https://networkconnectivity.googleapis.com/v1alpha1/projects/my-project/global/hub/hub-1'"
        :param int rule_number: An integer uniquely identifying a rule in the list.
               The rule number must be a positive value between 0 and 65000, and must be unique among rules within a NAT.
        :param 'RouterNatRuleActionArgs' action: The action to be enforced for traffic that matches this rule.
               Structure is documented below.
        :param str description: An optional description of this rule.
        """
        pulumi.set(__self__, "match", match)
        pulumi.set(__self__, "rule_number", rule_number)
        if action is not None:
            pulumi.set(__self__, "action", action)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def match(self) -> str:
        """
        CEL expression that specifies the match condition that egress traffic from a VM is evaluated against.
        If it evaluates to true, the corresponding action is enforced.
        The following examples are valid match expressions for public NAT:
        "inIpRange(destination.ip, '1.1.0.0/16') || inIpRange(destination.ip, '2.2.0.0/16')"
        "destination.ip == '1.1.0.1' || destination.ip == '8.8.8.8'"
        The following example is a valid match expression for private NAT:
        "nexthop.hub == 'https://networkconnectivity.googleapis.com/v1alpha1/projects/my-project/global/hub/hub-1'"
        """
        return pulumi.get(self, "match")

    @property
    @pulumi.getter(name="ruleNumber")
    def rule_number(self) -> int:
        """
        An integer uniquely identifying a rule in the list.
        The rule number must be a positive value between 0 and 65000, and must be unique among rules within a NAT.
        """
        return pulumi.get(self, "rule_number")

    @property
    @pulumi.getter
    def action(self) -> Optional['outputs.RouterNatRuleAction']:
        """
        The action to be enforced for traffic that matches this rule.
        Structure is documented below.
        """
        return pulumi.get(self, "action")

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


@pulumi.output_type
class RouterNatRuleAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sourceNatActiveIps":
            suggest = "source_nat_active_ips"
        elif key == "sourceNatDrainIps":
            suggest = "source_nat_drain_ips"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RouterNatRuleAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RouterNatRuleAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RouterNatRuleAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 source_nat_active_ips: Optional[Sequence[str]] = None,
                 source_nat_drain_ips: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] source_nat_active_ips: A list of URLs of the IP resources used for this NAT rule.
               These IP addresses must be valid static external IP addresses assigned to the project.
               This field is used for public NAT.
        :param Sequence[str] source_nat_drain_ips: A list of URLs of the IP resources to be drained.
               These IPs must be valid static external IPs that have been assigned to the NAT.
               These IPs should be used for updating/patching a NAT rule only.
               This field is used for public NAT.
        """
        if source_nat_active_ips is not None:
            pulumi.set(__self__, "source_nat_active_ips", source_nat_active_ips)
        if source_nat_drain_ips is not None:
            pulumi.set(__self__, "source_nat_drain_ips", source_nat_drain_ips)

    @property
    @pulumi.getter(name="sourceNatActiveIps")
    def source_nat_active_ips(self) -> Optional[Sequence[str]]:
        """
        A list of URLs of the IP resources used for this NAT rule.
        These IP addresses must be valid static external IP addresses assigned to the project.
        This field is used for public NAT.
        """
        return pulumi.get(self, "source_nat_active_ips")

    @property
    @pulumi.getter(name="sourceNatDrainIps")
    def source_nat_drain_ips(self) -> Optional[Sequence[str]]:
        """
        A list of URLs of the IP resources to be drained.
        These IPs must be valid static external IPs that have been assigned to the NAT.
        These IPs should be used for updating/patching a NAT rule only.
        This field is used for public NAT.
        """
        return pulumi.get(self, "source_nat_drain_ips")


@pulumi.output_type
class RouterNatSubnetwork(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sourceIpRangesToNats":
            suggest = "source_ip_ranges_to_nats"
        elif key == "secondaryIpRangeNames":
            suggest = "secondary_ip_range_names"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RouterNatSubnetwork. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RouterNatSubnetwork.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RouterNatSubnetwork.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 source_ip_ranges_to_nats: Sequence[str],
                 secondary_ip_range_names: Optional[Sequence[str]] = None):
        """
        :param str name: Self-link of subnetwork to NAT
        :param Sequence[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 Sequence[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) -> str:
        """
        Self-link of subnetwork to NAT
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="sourceIpRangesToNats")
    def source_ip_ranges_to_nats(self) -> Sequence[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")

    @property
    @pulumi.getter(name="secondaryIpRangeNames")
    def secondary_ip_range_names(self) -> Optional[Sequence[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")


@pulumi.output_type
class RouterPeerAdvertisedIpRange(dict):
    def __init__(__self__, *,
                 range: str,
                 description: Optional[str] = None):
        """
        :param str range: The IP range to advertise. The value must be a
               CIDR-formatted string.
        :param 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) -> str:
        """
        The IP range to advertise. The value must be a
        CIDR-formatted string.
        """
        return pulumi.get(self, "range")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        User-specified description for the IP range.
        """
        return pulumi.get(self, "description")


@pulumi.output_type
class RouterPeerBfd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sessionInitializationMode":
            suggest = "session_initialization_mode"
        elif key == "minReceiveInterval":
            suggest = "min_receive_interval"
        elif key == "minTransmitInterval":
            suggest = "min_transmit_interval"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RouterPeerBfd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RouterPeerBfd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RouterPeerBfd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 session_initialization_mode: str,
                 min_receive_interval: Optional[int] = None,
                 min_transmit_interval: Optional[int] = None,
                 multiplier: Optional[int] = None):
        """
        :param 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 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 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 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) -> 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")

    @property
    @pulumi.getter(name="minReceiveInterval")
    def min_receive_interval(self) -> Optional[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")

    @property
    @pulumi.getter(name="minTransmitInterval")
    def min_transmit_interval(self) -> Optional[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")

    @property
    @pulumi.getter
    def multiplier(self) -> Optional[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")


@pulumi.output_type
class RouterStatusBestRouteResult(dict):
    def __init__(__self__, *,
                 description: str,
                 dest_range: str,
                 name: str,
                 network: str,
                 next_hop_gateway: str,
                 next_hop_ilb: str,
                 next_hop_instance: str,
                 next_hop_instance_zone: str,
                 next_hop_ip: str,
                 next_hop_network: str,
                 next_hop_vpn_tunnel: str,
                 priority: int,
                 project: str,
                 self_link: str,
                 tags: Sequence[str]):
        """
        :param str name: The name of the router.
        :param str network: The network name or resource link to the parent
               network of this subnetwork.
        :param str project: The ID of the project in which the resource
               belongs. If it is not provided, the provider project is used.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "dest_range", dest_range)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "next_hop_gateway", next_hop_gateway)
        pulumi.set(__self__, "next_hop_ilb", next_hop_ilb)
        pulumi.set(__self__, "next_hop_instance", next_hop_instance)
        pulumi.set(__self__, "next_hop_instance_zone", next_hop_instance_zone)
        pulumi.set(__self__, "next_hop_ip", next_hop_ip)
        pulumi.set(__self__, "next_hop_network", next_hop_network)
        pulumi.set(__self__, "next_hop_vpn_tunnel", next_hop_vpn_tunnel)
        pulumi.set(__self__, "priority", priority)
        pulumi.set(__self__, "project", project)
        pulumi.set(__self__, "self_link", self_link)
        pulumi.set(__self__, "tags", tags)

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

    @property
    @pulumi.getter(name="destRange")
    def dest_range(self) -> str:
        return pulumi.get(self, "dest_range")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the router.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def network(self) -> str:
        """
        The network name or resource link to the parent
        network of this subnetwork.
        """
        return pulumi.get(self, "network")

    @property
    @pulumi.getter(name="nextHopGateway")
    def next_hop_gateway(self) -> str:
        return pulumi.get(self, "next_hop_gateway")

    @property
    @pulumi.getter(name="nextHopIlb")
    def next_hop_ilb(self) -> str:
        return pulumi.get(self, "next_hop_ilb")

    @property
    @pulumi.getter(name="nextHopInstance")
    def next_hop_instance(self) -> str:
        return pulumi.get(self, "next_hop_instance")

    @property
    @pulumi.getter(name="nextHopInstanceZone")
    def next_hop_instance_zone(self) -> str:
        return pulumi.get(self, "next_hop_instance_zone")

    @property
    @pulumi.getter(name="nextHopIp")
    def next_hop_ip(self) -> str:
        return pulumi.get(self, "next_hop_ip")

    @property
    @pulumi.getter(name="nextHopNetwork")
    def next_hop_network(self) -> str:
        return pulumi.get(self, "next_hop_network")

    @property
    @pulumi.getter(name="nextHopVpnTunnel")
    def next_hop_vpn_tunnel(self) -> str:
        return pulumi.get(self, "next_hop_vpn_tunnel")

    @property
    @pulumi.getter
    def priority(self) -> int:
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter
    def project(self) -> str:
        """
        The ID of the project in which the resource
        belongs. If it is not provided, the provider project is used.
        """
        return pulumi.get(self, "project")

    @property
    @pulumi.getter(name="selfLink")
    def self_link(self) -> str:
        return pulumi.get(self, "self_link")

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


@pulumi.output_type
class RouterStatusBestRoutesForRouterResult(dict):
    def __init__(__self__, *,
                 description: str,
                 dest_range: str,
                 name: str,
                 network: str,
                 next_hop_gateway: str,
                 next_hop_ilb: str,
                 next_hop_instance: str,
                 next_hop_instance_zone: str,
                 next_hop_ip: str,
                 next_hop_network: str,
                 next_hop_vpn_tunnel: str,
                 priority: int,
                 project: str,
                 self_link: str,
                 tags: Sequence[str]):
        """
        :param str name: The name of the router.
        :param str network: The network name or resource link to the parent
               network of this subnetwork.
        :param str project: The ID of the project in which the resource
               belongs. If it is not provided, the provider project is used.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "dest_range", dest_range)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "next_hop_gateway", next_hop_gateway)
        pulumi.set(__self__, "next_hop_ilb", next_hop_ilb)
        pulumi.set(__self__, "next_hop_instance", next_hop_instance)
        pulumi.set(__self__, "next_hop_instance_zone", next_hop_instance_zone)
        pulumi.set(__self__, "next_hop_ip", next_hop_ip)
        pulumi.set(__self__, "next_hop_network", next_hop_network)
        pulumi.set(__self__, "next_hop_vpn_tunnel", next_hop_vpn_tunnel)
        pulumi.set(__self__, "priority", priority)
        pulumi.set(__self__, "project", project)
        pulumi.set(__self__, "self_link", self_link)
        pulumi.set(__self__, "tags", tags)

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

    @property
    @pulumi.getter(name="destRange")
    def dest_range(self) -> str:
        return pulumi.get(self, "dest_range")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the router.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def network(self) -> str:
        """
        The network name or resource link to the parent
        network of this subnetwork.
        """
        return pulumi.get(self, "network")

    @property
    @pulumi.getter(name="nextHopGateway")
    def next_hop_gateway(self) -> str:
        return pulumi.get(self, "next_hop_gateway")

    @property
    @pulumi.getter(name="nextHopIlb")
    def next_hop_ilb(self) -> str:
        return pulumi.get(self, "next_hop_ilb")

    @property
    @pulumi.getter(name="nextHopInstance")
    def next_hop_instance(self) -> str:
        return pulumi.get(self, "next_hop_instance")

    @property
    @pulumi.getter(name="nextHopInstanceZone")
    def next_hop_instance_zone(self) -> str:
        return pulumi.get(self, "next_hop_instance_zone")

    @property
    @pulumi.getter(name="nextHopIp")
    def next_hop_ip(self) -> str:
        return pulumi.get(self, "next_hop_ip")

    @property
    @pulumi.getter(name="nextHopNetwork")
    def next_hop_network(self) -> str:
        return pulumi.get(self, "next_hop_network")

    @property
    @pulumi.getter(name="nextHopVpnTunnel")
    def next_hop_vpn_tunnel(self) -> str:
        return pulumi.get(self, "next_hop_vpn_tunnel")

    @property
    @pulumi.getter
    def priority(self) -> int:
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter
    def project(self) -> str:
        """
        The ID of the project in which the resource
        belongs. If it is not provided, the provider project is used.
        """
        return pulumi.get(self, "project")

    @property
    @pulumi.getter(name="selfLink")
    def self_link(self) -> str:
        return pulumi.get(self, "self_link")

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


@pulumi.output_type
class SecurityPolicyAdaptiveProtectionConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "autoDeployConfig":
            suggest = "auto_deploy_config"
        elif key == "layer7DdosDefenseConfig":
            suggest = "layer7_ddos_defense_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SecurityPolicyAdaptiveProtectionConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SecurityPolicyAdaptiveProtectionConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SecurityPolicyAdaptiveProtectionConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 auto_deploy_config: Optional['outputs.SecurityPolicyAdaptiveProtectionConfigAutoDeployConfig'] = None,
                 layer7_ddos_defense_config: Optional['outputs.SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig'] = None):
        """
        :param 'SecurityPolicyAdaptiveProtectionConfigAutoDeployConfigArgs' auto_deploy_config: ) Configuration for [Automatically deploy Adaptive Protection suggested rules](https://cloud.google.com/armor/docs/adaptive-protection-auto-deploy?hl=en). Structure is documented below.
        :param '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 auto_deploy_config is not None:
            pulumi.set(__self__, "auto_deploy_config", auto_deploy_config)
        if layer7_ddos_defense_config is not None:
            pulumi.set(__self__, "layer7_ddos_defense_config", layer7_ddos_defense_config)

    @property
    @pulumi.getter(name="autoDeployConfig")
    def auto_deploy_config(self) -> Optional['outputs.SecurityPolicyAdaptiveProtectionConfigAutoDeployConfig']:
        """
        ) Configuration for [Automatically deploy Adaptive Protection suggested rules](https://cloud.google.com/armor/docs/adaptive-protection-auto-deploy?hl=en). Structure is documented below.
        """
        return pulumi.get(self, "auto_deploy_config")

    @property
    @pulumi.getter(name="layer7DdosDefenseConfig")
    def layer7_ddos_defense_config(self) -> Optional['outputs.SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig']:
        """
        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")


@pulumi.output_type
class SecurityPolicyAdaptiveProtectionConfigAutoDeployConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "confidenceThreshold":
            suggest = "confidence_threshold"
        elif key == "expirationSec":
            suggest = "expiration_sec"
        elif key == "impactedBaselineThreshold":
            suggest = "impacted_baseline_threshold"
        elif key == "loadThreshold":
            suggest = "load_threshold"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SecurityPolicyAdaptiveProtectionConfigAutoDeployConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SecurityPolicyAdaptiveProtectionConfigAutoDeployConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SecurityPolicyAdaptiveProtectionConfigAutoDeployConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 confidence_threshold: Optional[float] = None,
                 expiration_sec: Optional[int] = None,
                 impacted_baseline_threshold: Optional[float] = None,
                 load_threshold: Optional[float] = None):
        """
        :param float confidence_threshold: Rules are only automatically deployed for alerts on potential attacks with confidence scores greater than this threshold.
        :param int expiration_sec: Google Cloud Armor stops applying the action in the automatically deployed rule to an identified attacker after this duration. The rule continues to operate against new requests.
        :param float impacted_baseline_threshold: Rules are only automatically deployed when the estimated impact to baseline traffic from the suggested mitigation is below this threshold.
        :param float load_threshold: Identifies new attackers only when the load to the backend service that is under attack exceeds this threshold.
        """
        if confidence_threshold is not None:
            pulumi.set(__self__, "confidence_threshold", confidence_threshold)
        if expiration_sec is not None:
            pulumi.set(__self__, "expiration_sec", expiration_sec)
        if impacted_baseline_threshold is not None:
            pulumi.set(__self__, "impacted_baseline_threshold", impacted_baseline_threshold)
        if load_threshold is not None:
            pulumi.set(__self__, "load_threshold", load_threshold)

    @property
    @pulumi.getter(name="confidenceThreshold")
    def confidence_threshold(self) -> Optional[float]:
        """
        Rules are only automatically deployed for alerts on potential attacks with confidence scores greater than this threshold.
        """
        return pulumi.get(self, "confidence_threshold")

    @property
    @pulumi.getter(name="expirationSec")
    def expiration_sec(self) -> Optional[int]:
        """
        Google Cloud Armor stops applying the action in the automatically deployed rule to an identified attacker after this duration. The rule continues to operate against new requests.
        """
        return pulumi.get(self, "expiration_sec")

    @property
    @pulumi.getter(name="impactedBaselineThreshold")
    def impacted_baseline_threshold(self) -> Optional[float]:
        """
        Rules are only automatically deployed when the estimated impact to baseline traffic from the suggested mitigation is below this threshold.
        """
        return pulumi.get(self, "impacted_baseline_threshold")

    @property
    @pulumi.getter(name="loadThreshold")
    def load_threshold(self) -> Optional[float]:
        """
        Identifies new attackers only when the load to the backend service that is under attack exceeds this threshold.
        """
        return pulumi.get(self, "load_threshold")


@pulumi.output_type
class SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ruleVisibility":
            suggest = "rule_visibility"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enable: Optional[bool] = None,
                 rule_visibility: Optional[str] = None):
        """
        :param bool enable: If set to true, enables CAAP for L7 DDoS detection.
        :param 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[bool]:
        """
        If set to true, enables CAAP for L7 DDoS detection.
        """
        return pulumi.get(self, "enable")

    @property
    @pulumi.getter(name="ruleVisibility")
    def rule_visibility(self) -> Optional[str]:
        """
        Rule visibility can be one of the following: STANDARD - opaque rules. (default) PREMIUM - transparent rules.
        """
        return pulumi.get(self, "rule_visibility")


@pulumi.output_type
class SecurityPolicyAdvancedOptionsConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "jsonCustomConfig":
            suggest = "json_custom_config"
        elif key == "jsonParsing":
            suggest = "json_parsing"
        elif key == "logLevel":
            suggest = "log_level"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SecurityPolicyAdvancedOptionsConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SecurityPolicyAdvancedOptionsConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SecurityPolicyAdvancedOptionsConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 json_custom_config: Optional['outputs.SecurityPolicyAdvancedOptionsConfigJsonCustomConfig'] = None,
                 json_parsing: Optional[str] = None,
                 log_level: Optional[str] = None):
        """
        :param 'SecurityPolicyAdvancedOptionsConfigJsonCustomConfigArgs' json_custom_config: Custom configuration to apply the JSON parsing. Only applicable when
               `json_parsing` is set to `STANDARD`. Structure is documented below.
        :param 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 str log_level: Log level to use. Defaults to `NORMAL`.
               * NORMAL - Normal log level.
               * VERBOSE - Verbose log level.
        """
        if json_custom_config is not None:
            pulumi.set(__self__, "json_custom_config", json_custom_config)
        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="jsonCustomConfig")
    def json_custom_config(self) -> Optional['outputs.SecurityPolicyAdvancedOptionsConfigJsonCustomConfig']:
        """
        Custom configuration to apply the JSON parsing. Only applicable when
        `json_parsing` is set to `STANDARD`. Structure is documented below.
        """
        return pulumi.get(self, "json_custom_config")

    @property
    @pulumi.getter(name="jsonParsing")
    def json_parsing(self) -> Optional[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")

    @property
    @pulumi.getter(name="logLevel")
    def log_level(self) -> Optional[str]:
        """
        Log level to use. Defaults to `NORMAL`.
        * NORMAL - Normal log level.
        * VERBOSE - Verbose log level.
        """
        return pulumi.get(self, "log_level")


@pulumi.output_type
class SecurityPolicyAdvancedOptionsConfigJsonCustomConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "contentTypes":
            suggest = "content_types"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SecurityPolicyAdvancedOptionsConfigJsonCustomConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SecurityPolicyAdvancedOptionsConfigJsonCustomConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SecurityPolicyAdvancedOptionsConfigJsonCustomConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 content_types: Sequence[str]):
        """
        :param Sequence[str] content_types: A list of custom Content-Type header values to apply the JSON parsing. The
               format of the Content-Type header values is defined in
               [RFC 1341](https://www.ietf.org/rfc/rfc1341.txt). When configuring a custom Content-Type header
               value, only the type/subtype needs to be specified, and the parameters should be excluded.
        """
        pulumi.set(__self__, "content_types", content_types)

    @property
    @pulumi.getter(name="contentTypes")
    def content_types(self) -> Sequence[str]:
        """
        A list of custom Content-Type header values to apply the JSON parsing. The
        format of the Content-Type header values is defined in
        [RFC 1341](https://www.ietf.org/rfc/rfc1341.txt). When configuring a custom Content-Type header
        value, only the type/subtype needs to be specified, and the parameters should be excluded.
        """
        return pulumi.get(self, "content_types")


@pulumi.output_type
class SecurityPolicyRecaptchaOptionsConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "redirectSiteKey":
            suggest = "redirect_site_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SecurityPolicyRecaptchaOptionsConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SecurityPolicyRecaptchaOptionsConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SecurityPolicyRecaptchaOptionsConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 redirect_site_key: str):
        """
        :param str redirect_site_key: A field to supply a reCAPTCHA site key to be used for all the rules using the redirect action with the type of GOOGLE_RECAPTCHA under the security policy. The specified site key needs to be created from the reCAPTCHA API. The user is responsible for the validity of the specified site key. If not specified, a Google-managed site key is used.
        """
        pulumi.set(__self__, "redirect_site_key", redirect_site_key)

    @property
    @pulumi.getter(name="redirectSiteKey")
    def redirect_site_key(self) -> str:
        """
        A field to supply a reCAPTCHA site key to be used for all the rules using the redirect action with the type of GOOGLE_RECAPTCHA under the security policy. The specified site key needs to be created from the reCAPTCHA API. The user is responsible for the validity of the specified site key. If not specified, a Google-managed site key is used.
        """
        return pulumi.get(self, "redirect_site_key")


@pulumi.output_type
class SecurityPolicyRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerAction":
            suggest = "header_action"
        elif key == "preconfiguredWafConfig":
            suggest = "preconfigured_waf_config"
        elif key == "rateLimitOptions":
            suggest = "rate_limit_options"
        elif key == "redirectOptions":
            suggest = "redirect_options"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SecurityPolicyRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SecurityPolicyRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SecurityPolicyRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 action: str,
                 match: 'outputs.SecurityPolicyRuleMatch',
                 priority: int,
                 description: Optional[str] = None,
                 header_action: Optional['outputs.SecurityPolicyRuleHeaderAction'] = None,
                 preconfigured_waf_config: Optional['outputs.SecurityPolicyRulePreconfiguredWafConfig'] = None,
                 preview: Optional[bool] = None,
                 rate_limit_options: Optional['outputs.SecurityPolicyRuleRateLimitOptions'] = None,
                 redirect_options: Optional['outputs.SecurityPolicyRuleRedirectOptions'] = None):
        """
        :param 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 '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 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 str description: An optional description of this rule. Max size is 64.
        :param 'SecurityPolicyRuleHeaderActionArgs' header_action: Additional actions that are performed on headers. Structure is documented below.
        :param 'SecurityPolicyRulePreconfiguredWafConfigArgs' preconfigured_waf_config: ) Preconfigured WAF configuration to be applied for the rule. If the rule does not evaluate preconfigured WAF rules, i.e., if evaluatePreconfiguredWaf() is not used, this field will have no effect. Structure is documented below.
        :param 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 'SecurityPolicyRuleRateLimitOptionsArgs' rate_limit_options: Must be specified if the `action` is "rate_based_ban" or "throttle". Cannot be specified for other actions. Structure is documented below.
        :param '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 header_action is not None:
            pulumi.set(__self__, "header_action", header_action)
        if preconfigured_waf_config is not None:
            pulumi.set(__self__, "preconfigured_waf_config", preconfigured_waf_config)
        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) -> 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")

    @property
    @pulumi.getter
    def match(self) -> 'outputs.SecurityPolicyRuleMatch':
        """
        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")

    @property
    @pulumi.getter
    def priority(self) -> 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")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        An optional description of this rule. Max size is 64.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="headerAction")
    def header_action(self) -> Optional['outputs.SecurityPolicyRuleHeaderAction']:
        """
        Additional actions that are performed on headers. Structure is documented below.
        """
        return pulumi.get(self, "header_action")

    @property
    @pulumi.getter(name="preconfiguredWafConfig")
    def preconfigured_waf_config(self) -> Optional['outputs.SecurityPolicyRulePreconfiguredWafConfig']:
        """
        ) Preconfigured WAF configuration to be applied for the rule. If the rule does not evaluate preconfigured WAF rules, i.e., if evaluatePreconfiguredWaf() is not used, this field will have no effect. Structure is documented below.
        """
        return pulumi.get(self, "preconfigured_waf_config")

    @property
    @pulumi.getter
    def preview(self) -> Optional[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")

    @property
    @pulumi.getter(name="rateLimitOptions")
    def rate_limit_options(self) -> Optional['outputs.SecurityPolicyRuleRateLimitOptions']:
        """
        Must be specified if the `action` is "rate_based_ban" or "throttle". Cannot be specified for other actions. Structure is documented below.
        """
        return pulumi.get(self, "rate_limit_options")

    @property
    @pulumi.getter(name="redirectOptions")
    def redirect_options(self) -> Optional['outputs.SecurityPolicyRuleRedirectOptions']:
        """
        Can be specified if the `action` is "redirect". Cannot be specified for other actions. Structure is documented below.
        """
        return pulumi.get(self, "redirect_options")


@pulumi.output_type
class SecurityPolicyRuleHeaderAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "requestHeadersToAdds":
            suggest = "request_headers_to_adds"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SecurityPolicyRuleHeaderAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SecurityPolicyRuleHeaderAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SecurityPolicyRuleHeaderAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 request_headers_to_adds: Sequence['outputs.SecurityPolicyRuleHeaderActionRequestHeadersToAdd']):
        """
        :param Sequence['SecurityPolicyRuleHeaderActionRequestHeadersToAddArgs'] request_headers_to_adds: The list of request headers to add or overwrite if they're already present. Structure is documented below.
        """
        pulumi.set(__self__, "request_headers_to_adds", request_headers_to_adds)

    @property
    @pulumi.getter(name="requestHeadersToAdds")
    def request_headers_to_adds(self) -> Sequence['outputs.SecurityPolicyRuleHeaderActionRequestHeadersToAdd']:
        """
        The list of request headers to add or overwrite if they're already present. Structure is documented below.
        """
        return pulumi.get(self, "request_headers_to_adds")


@pulumi.output_type
class SecurityPolicyRuleHeaderActionRequestHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SecurityPolicyRuleHeaderActionRequestHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SecurityPolicyRuleHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SecurityPolicyRuleHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: str,
                 header_value: Optional[str] = None):
        """
        :param str header_name: The name of the header to set.
        :param str header_value: The value to set the named header to.
        """
        pulumi.set(__self__, "header_name", header_name)
        if header_value is not None:
            pulumi.set(__self__, "header_value", header_value)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> str:
        """
        The name of the header to set.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> Optional[str]:
        """
        The value to set the named header to.
        """
        return pulumi.get(self, "header_value")


@pulumi.output_type
class SecurityPolicyRuleMatch(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "versionedExpr":
            suggest = "versioned_expr"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SecurityPolicyRuleMatch. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SecurityPolicyRuleMatch.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SecurityPolicyRuleMatch.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 config: Optional['outputs.SecurityPolicyRuleMatchConfig'] = None,
                 expr: Optional['outputs.SecurityPolicyRuleMatchExpr'] = None,
                 versioned_expr: Optional[str] = None):
        """
        :param '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 '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 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['outputs.SecurityPolicyRuleMatchConfig']:
        """
        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")

    @property
    @pulumi.getter
    def expr(self) -> Optional['outputs.SecurityPolicyRuleMatchExpr']:
        """
        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")

    @property
    @pulumi.getter(name="versionedExpr")
    def versioned_expr(self) -> Optional[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")


@pulumi.output_type
class SecurityPolicyRuleMatchConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "srcIpRanges":
            suggest = "src_ip_ranges"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SecurityPolicyRuleMatchConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SecurityPolicyRuleMatchConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SecurityPolicyRuleMatchConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 src_ip_ranges: Sequence[str]):
        """
        :param Sequence[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) -> Sequence[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")


@pulumi.output_type
class SecurityPolicyRuleMatchExpr(dict):
    def __init__(__self__, *,
                 expression: str):
        """
        :param 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) -> 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")


@pulumi.output_type
class SecurityPolicyRulePreconfiguredWafConfig(dict):
    def __init__(__self__, *,
                 exclusions: Optional[Sequence['outputs.SecurityPolicyRulePreconfiguredWafConfigExclusion']] = None):
        """
        :param Sequence['SecurityPolicyRulePreconfiguredWafConfigExclusionArgs'] exclusions: An exclusion to apply during preconfigured WAF evaluation. Structure is documented below.
        """
        if exclusions is not None:
            pulumi.set(__self__, "exclusions", exclusions)

    @property
    @pulumi.getter
    def exclusions(self) -> Optional[Sequence['outputs.SecurityPolicyRulePreconfiguredWafConfigExclusion']]:
        """
        An exclusion to apply during preconfigured WAF evaluation. Structure is documented below.
        """
        return pulumi.get(self, "exclusions")


@pulumi.output_type
class SecurityPolicyRulePreconfiguredWafConfigExclusion(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "targetRuleSet":
            suggest = "target_rule_set"
        elif key == "requestCookies":
            suggest = "request_cookies"
        elif key == "requestHeaders":
            suggest = "request_headers"
        elif key == "requestQueryParams":
            suggest = "request_query_params"
        elif key == "requestUris":
            suggest = "request_uris"
        elif key == "targetRuleIds":
            suggest = "target_rule_ids"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SecurityPolicyRulePreconfiguredWafConfigExclusion. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SecurityPolicyRulePreconfiguredWafConfigExclusion.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SecurityPolicyRulePreconfiguredWafConfigExclusion.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 target_rule_set: str,
                 request_cookies: Optional[Sequence['outputs.SecurityPolicyRulePreconfiguredWafConfigExclusionRequestCooky']] = None,
                 request_headers: Optional[Sequence['outputs.SecurityPolicyRulePreconfiguredWafConfigExclusionRequestHeader']] = None,
                 request_query_params: Optional[Sequence['outputs.SecurityPolicyRulePreconfiguredWafConfigExclusionRequestQueryParam']] = None,
                 request_uris: Optional[Sequence['outputs.SecurityPolicyRulePreconfiguredWafConfigExclusionRequestUri']] = None,
                 target_rule_ids: Optional[Sequence[str]] = None):
        """
        :param str target_rule_set: Target WAF rule set to apply the preconfigured WAF exclusion.
        :param Sequence['SecurityPolicyRulePreconfiguredWafConfigExclusionRequestCookyArgs'] request_cookies: Request cookie whose value will be excluded from inspection during preconfigured WAF evaluation. Structure is documented below.
        :param Sequence['SecurityPolicyRulePreconfiguredWafConfigExclusionRequestHeaderArgs'] request_headers: Request header whose value will be excluded from inspection during preconfigured WAF evaluation. Structure is documented below.
        :param Sequence['SecurityPolicyRulePreconfiguredWafConfigExclusionRequestQueryParamArgs'] request_query_params: Request URI from the request line to be excluded from inspection during preconfigured WAF evaluation. When specifying this field, the query or fragment part should be excluded. Structure is documented below.
        :param Sequence['SecurityPolicyRulePreconfiguredWafConfigExclusionRequestUriArgs'] request_uris: Request query parameter whose value will be excluded from inspection during preconfigured WAF evaluation. Note that the parameter can be in the query string or in the POST body. Structure is documented below.
        :param Sequence[str] target_rule_ids: A list of target rule IDs under the WAF rule set to apply the preconfigured WAF exclusion. If omitted, it refers to all the rule IDs under the WAF rule set.
        """
        pulumi.set(__self__, "target_rule_set", target_rule_set)
        if request_cookies is not None:
            pulumi.set(__self__, "request_cookies", request_cookies)
        if request_headers is not None:
            pulumi.set(__self__, "request_headers", request_headers)
        if request_query_params is not None:
            pulumi.set(__self__, "request_query_params", request_query_params)
        if request_uris is not None:
            pulumi.set(__self__, "request_uris", request_uris)
        if target_rule_ids is not None:
            pulumi.set(__self__, "target_rule_ids", target_rule_ids)

    @property
    @pulumi.getter(name="targetRuleSet")
    def target_rule_set(self) -> str:
        """
        Target WAF rule set to apply the preconfigured WAF exclusion.
        """
        return pulumi.get(self, "target_rule_set")

    @property
    @pulumi.getter(name="requestCookies")
    def request_cookies(self) -> Optional[Sequence['outputs.SecurityPolicyRulePreconfiguredWafConfigExclusionRequestCooky']]:
        """
        Request cookie whose value will be excluded from inspection during preconfigured WAF evaluation. Structure is documented below.
        """
        return pulumi.get(self, "request_cookies")

    @property
    @pulumi.getter(name="requestHeaders")
    def request_headers(self) -> Optional[Sequence['outputs.SecurityPolicyRulePreconfiguredWafConfigExclusionRequestHeader']]:
        """
        Request header whose value will be excluded from inspection during preconfigured WAF evaluation. Structure is documented below.
        """
        return pulumi.get(self, "request_headers")

    @property
    @pulumi.getter(name="requestQueryParams")
    def request_query_params(self) -> Optional[Sequence['outputs.SecurityPolicyRulePreconfiguredWafConfigExclusionRequestQueryParam']]:
        """
        Request URI from the request line to be excluded from inspection during preconfigured WAF evaluation. When specifying this field, the query or fragment part should be excluded. Structure is documented below.
        """
        return pulumi.get(self, "request_query_params")

    @property
    @pulumi.getter(name="requestUris")
    def request_uris(self) -> Optional[Sequence['outputs.SecurityPolicyRulePreconfiguredWafConfigExclusionRequestUri']]:
        """
        Request query parameter whose value will be excluded from inspection during preconfigured WAF evaluation. Note that the parameter can be in the query string or in the POST body. Structure is documented below.
        """
        return pulumi.get(self, "request_uris")

    @property
    @pulumi.getter(name="targetRuleIds")
    def target_rule_ids(self) -> Optional[Sequence[str]]:
        """
        A list of target rule IDs under the WAF rule set to apply the preconfigured WAF exclusion. If omitted, it refers to all the rule IDs under the WAF rule set.
        """
        return pulumi.get(self, "target_rule_ids")


@pulumi.output_type
class SecurityPolicyRulePreconfiguredWafConfigExclusionRequestCooky(dict):
    def __init__(__self__, *,
                 operator: str,
                 value: Optional[str] = None):
        """
        :param str operator: You can specify an exact match or a partial match by using a field operator and a field value.
        :param str value: A request field matching the specified value will be excluded from inspection during preconfigured WAF evaluation.
               The field value must be given if the field `operator` is not "EQUALS_ANY", and cannot be given if the field `operator` is "EQUALS_ANY".
        """
        pulumi.set(__self__, "operator", operator)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        You can specify an exact match or a partial match by using a field operator and a field value.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        A request field matching the specified value will be excluded from inspection during preconfigured WAF evaluation.
        The field value must be given if the field `operator` is not "EQUALS_ANY", and cannot be given if the field `operator` is "EQUALS_ANY".
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class SecurityPolicyRulePreconfiguredWafConfigExclusionRequestHeader(dict):
    def __init__(__self__, *,
                 operator: str,
                 value: Optional[str] = None):
        """
        :param str operator: You can specify an exact match or a partial match by using a field operator and a field value.
        :param str value: A request field matching the specified value will be excluded from inspection during preconfigured WAF evaluation.
               The field value must be given if the field `operator` is not "EQUALS_ANY", and cannot be given if the field `operator` is "EQUALS_ANY".
        """
        pulumi.set(__self__, "operator", operator)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        You can specify an exact match or a partial match by using a field operator and a field value.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        A request field matching the specified value will be excluded from inspection during preconfigured WAF evaluation.
        The field value must be given if the field `operator` is not "EQUALS_ANY", and cannot be given if the field `operator` is "EQUALS_ANY".
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class SecurityPolicyRulePreconfiguredWafConfigExclusionRequestQueryParam(dict):
    def __init__(__self__, *,
                 operator: str,
                 value: Optional[str] = None):
        """
        :param str operator: You can specify an exact match or a partial match by using a field operator and a field value.
        :param str value: A request field matching the specified value will be excluded from inspection during preconfigured WAF evaluation.
               The field value must be given if the field `operator` is not "EQUALS_ANY", and cannot be given if the field `operator` is "EQUALS_ANY".
        """
        pulumi.set(__self__, "operator", operator)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        You can specify an exact match or a partial match by using a field operator and a field value.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        A request field matching the specified value will be excluded from inspection during preconfigured WAF evaluation.
        The field value must be given if the field `operator` is not "EQUALS_ANY", and cannot be given if the field `operator` is "EQUALS_ANY".
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class SecurityPolicyRulePreconfiguredWafConfigExclusionRequestUri(dict):
    def __init__(__self__, *,
                 operator: str,
                 value: Optional[str] = None):
        """
        :param str operator: You can specify an exact match or a partial match by using a field operator and a field value.
        :param str value: A request field matching the specified value will be excluded from inspection during preconfigured WAF evaluation.
               The field value must be given if the field `operator` is not "EQUALS_ANY", and cannot be given if the field `operator` is "EQUALS_ANY".
        """
        pulumi.set(__self__, "operator", operator)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        You can specify an exact match or a partial match by using a field operator and a field value.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        A request field matching the specified value will be excluded from inspection during preconfigured WAF evaluation.
        The field value must be given if the field `operator` is not "EQUALS_ANY", and cannot be given if the field `operator` is "EQUALS_ANY".
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class SecurityPolicyRuleRateLimitOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "conformAction":
            suggest = "conform_action"
        elif key == "exceedAction":
            suggest = "exceed_action"
        elif key == "rateLimitThreshold":
            suggest = "rate_limit_threshold"
        elif key == "banDurationSec":
            suggest = "ban_duration_sec"
        elif key == "banThreshold":
            suggest = "ban_threshold"
        elif key == "enforceOnKey":
            suggest = "enforce_on_key"
        elif key == "enforceOnKeyConfigs":
            suggest = "enforce_on_key_configs"
        elif key == "enforceOnKeyName":
            suggest = "enforce_on_key_name"
        elif key == "exceedRedirectOptions":
            suggest = "exceed_redirect_options"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SecurityPolicyRuleRateLimitOptions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SecurityPolicyRuleRateLimitOptions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SecurityPolicyRuleRateLimitOptions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 conform_action: str,
                 exceed_action: str,
                 rate_limit_threshold: 'outputs.SecurityPolicyRuleRateLimitOptionsRateLimitThreshold',
                 ban_duration_sec: Optional[int] = None,
                 ban_threshold: Optional['outputs.SecurityPolicyRuleRateLimitOptionsBanThreshold'] = None,
                 enforce_on_key: Optional[str] = None,
                 enforce_on_key_configs: Optional[Sequence['outputs.SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig']] = None,
                 enforce_on_key_name: Optional[str] = None,
                 exceed_redirect_options: Optional['outputs.SecurityPolicyRuleRateLimitOptionsExceedRedirectOptions'] = None):
        """
        :param str conform_action: Action to take for requests that are under the configured rate limit threshold. Valid option is "allow" only.
        :param 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 'SecurityPolicyRuleRateLimitOptionsRateLimitThresholdArgs' rate_limit_threshold: Threshold at which to begin ratelimiting. Structure is documented below.
        :param 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 '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 str enforce_on_key: Determines the key to enforce the rate_limit_threshold on. If not specified, defaults to "ALL".
        :param Sequence['SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfigArgs'] enforce_on_key_configs: ) If specified, any combination of values of enforce_on_key_type/enforce_on_key_name is treated as the key on which ratelimit threshold/action is enforced. You can specify up to 3 enforce_on_key_configs. If `enforce_on_key_configs` is specified, enforce_on_key must be set to an empty string. Structure is documented below.
        :param 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.
        :param 'SecurityPolicyRuleRateLimitOptionsExceedRedirectOptionsArgs' exceed_redirect_options: Parameters defining the redirect action that is used as the exceed action. Cannot be specified if the exceed action is not redirect. Structure is documented below.
        """
        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_configs is not None:
            pulumi.set(__self__, "enforce_on_key_configs", enforce_on_key_configs)
        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) -> 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")

    @property
    @pulumi.getter(name="exceedAction")
    def exceed_action(self) -> 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")

    @property
    @pulumi.getter(name="rateLimitThreshold")
    def rate_limit_threshold(self) -> 'outputs.SecurityPolicyRuleRateLimitOptionsRateLimitThreshold':
        """
        Threshold at which to begin ratelimiting. Structure is documented below.
        """
        return pulumi.get(self, "rate_limit_threshold")

    @property
    @pulumi.getter(name="banDurationSec")
    def ban_duration_sec(self) -> Optional[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")

    @property
    @pulumi.getter(name="banThreshold")
    def ban_threshold(self) -> Optional['outputs.SecurityPolicyRuleRateLimitOptionsBanThreshold']:
        """
        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")

    @property
    @pulumi.getter(name="enforceOnKey")
    def enforce_on_key(self) -> Optional[str]:
        """
        Determines the key to enforce the rate_limit_threshold on. If not specified, defaults to "ALL".
        """
        return pulumi.get(self, "enforce_on_key")

    @property
    @pulumi.getter(name="enforceOnKeyConfigs")
    def enforce_on_key_configs(self) -> Optional[Sequence['outputs.SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig']]:
        """
        ) If specified, any combination of values of enforce_on_key_type/enforce_on_key_name is treated as the key on which ratelimit threshold/action is enforced. You can specify up to 3 enforce_on_key_configs. If `enforce_on_key_configs` is specified, enforce_on_key must be set to an empty string. Structure is documented below.
        """
        return pulumi.get(self, "enforce_on_key_configs")

    @property
    @pulumi.getter(name="enforceOnKeyName")
    def enforce_on_key_name(self) -> Optional[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")

    @property
    @pulumi.getter(name="exceedRedirectOptions")
    def exceed_redirect_options(self) -> Optional['outputs.SecurityPolicyRuleRateLimitOptionsExceedRedirectOptions']:
        """
        Parameters defining the redirect action that is used as the exceed action. Cannot be specified if the exceed action is not redirect. Structure is documented below.
        """
        return pulumi.get(self, "exceed_redirect_options")


@pulumi.output_type
class SecurityPolicyRuleRateLimitOptionsBanThreshold(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "intervalSec":
            suggest = "interval_sec"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SecurityPolicyRuleRateLimitOptionsBanThreshold. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SecurityPolicyRuleRateLimitOptionsBanThreshold.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SecurityPolicyRuleRateLimitOptionsBanThreshold.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 count: int,
                 interval_sec: int):
        """
        :param int count: Number of HTTP(S) requests for calculating the threshold.
        :param 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) -> int:
        """
        Number of HTTP(S) requests for calculating the threshold.
        """
        return pulumi.get(self, "count")

    @property
    @pulumi.getter(name="intervalSec")
    def interval_sec(self) -> int:
        """
        Interval over which the threshold is computed.
        """
        return pulumi.get(self, "interval_sec")


@pulumi.output_type
class SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enforceOnKeyName":
            suggest = "enforce_on_key_name"
        elif key == "enforceOnKeyType":
            suggest = "enforce_on_key_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enforce_on_key_name: Optional[str] = None,
                 enforce_on_key_type: Optional[str] = None):
        """
        :param 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.
        :param str enforce_on_key_type: Determines the key to enforce the rate_limit_threshold on. If not specified, defaults to "ALL".
        """
        if enforce_on_key_name is not None:
            pulumi.set(__self__, "enforce_on_key_name", enforce_on_key_name)
        if enforce_on_key_type is not None:
            pulumi.set(__self__, "enforce_on_key_type", enforce_on_key_type)

    @property
    @pulumi.getter(name="enforceOnKeyName")
    def enforce_on_key_name(self) -> Optional[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")

    @property
    @pulumi.getter(name="enforceOnKeyType")
    def enforce_on_key_type(self) -> Optional[str]:
        """
        Determines the key to enforce the rate_limit_threshold on. If not specified, defaults to "ALL".
        """
        return pulumi.get(self, "enforce_on_key_type")


@pulumi.output_type
class SecurityPolicyRuleRateLimitOptionsExceedRedirectOptions(dict):
    def __init__(__self__, *,
                 type: str,
                 target: Optional[str] = None):
        """
        :param str type: Type of the redirect action.
        :param str target: Target for the redirect action. This is required if the type is EXTERNAL_302 and cannot be specified for GOOGLE_RECAPTCHA.
        """
        pulumi.set(__self__, "type", type)
        if target is not None:
            pulumi.set(__self__, "target", target)

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Type of the redirect action.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def target(self) -> Optional[str]:
        """
        Target for the redirect action. This is required if the type is EXTERNAL_302 and cannot be specified for GOOGLE_RECAPTCHA.
        """
        return pulumi.get(self, "target")


@pulumi.output_type
class SecurityPolicyRuleRateLimitOptionsRateLimitThreshold(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "intervalSec":
            suggest = "interval_sec"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SecurityPolicyRuleRateLimitOptionsRateLimitThreshold. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SecurityPolicyRuleRateLimitOptionsRateLimitThreshold.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SecurityPolicyRuleRateLimitOptionsRateLimitThreshold.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 count: int,
                 interval_sec: int):
        """
        :param int count: Number of HTTP(S) requests for calculating the threshold.
        :param 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) -> int:
        """
        Number of HTTP(S) requests for calculating the threshold.
        """
        return pulumi.get(self, "count")

    @property
    @pulumi.getter(name="intervalSec")
    def interval_sec(self) -> int:
        """
        Interval over which the threshold is computed.
        """
        return pulumi.get(self, "interval_sec")


@pulumi.output_type
class SecurityPolicyRuleRedirectOptions(dict):
    def __init__(__self__, *,
                 type: str,
                 target: Optional[str] = None):
        """
        :param str type: Type of redirect action.
        :param 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) -> str:
        """
        Type of redirect action.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def target(self) -> Optional[str]:
        """
        External redirection target when "EXTERNAL_302" is set in 'type'.
        """
        return pulumi.get(self, "target")


@pulumi.output_type
class SecurityScanConfigAuthentication(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "customAccount":
            suggest = "custom_account"
        elif key == "googleAccount":
            suggest = "google_account"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SecurityScanConfigAuthentication. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SecurityScanConfigAuthentication.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SecurityScanConfigAuthentication.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 custom_account: Optional['outputs.SecurityScanConfigAuthenticationCustomAccount'] = None,
                 google_account: Optional['outputs.SecurityScanConfigAuthenticationGoogleAccount'] = None):
        """
        :param 'SecurityScanConfigAuthenticationCustomAccountArgs' custom_account: Describes authentication configuration that uses a custom account.
               Structure is documented below.
        :param '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['outputs.SecurityScanConfigAuthenticationCustomAccount']:
        """
        Describes authentication configuration that uses a custom account.
        Structure is documented below.
        """
        return pulumi.get(self, "custom_account")

    @property
    @pulumi.getter(name="googleAccount")
    def google_account(self) -> Optional['outputs.SecurityScanConfigAuthenticationGoogleAccount']:
        """
        Describes authentication configuration that uses a Google account.
        Structure is documented below.
        """
        return pulumi.get(self, "google_account")


@pulumi.output_type
class SecurityScanConfigAuthenticationCustomAccount(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "loginUrl":
            suggest = "login_url"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SecurityScanConfigAuthenticationCustomAccount. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SecurityScanConfigAuthenticationCustomAccount.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SecurityScanConfigAuthenticationCustomAccount.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 login_url: str,
                 password: str,
                 username: str):
        """
        :param str login_url: The login form URL of the website.
        :param 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 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) -> str:
        """
        The login form URL of the website.
        """
        return pulumi.get(self, "login_url")

    @property
    @pulumi.getter
    def password(self) -> 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")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The user name of the custom account.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class SecurityScanConfigAuthenticationGoogleAccount(dict):
    def __init__(__self__, *,
                 password: str,
                 username: str):
        """
        :param str password: The password of the Google account. The credential is stored encrypted
               in GCP.
               **Note**: This property is sensitive and will not be displayed in the plan.
        :param str username: The user name of the Google account.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The password of the Google 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")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The user name of the Google account.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class SecurityScanConfigSchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "intervalDurationDays":
            suggest = "interval_duration_days"
        elif key == "scheduleTime":
            suggest = "schedule_time"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SecurityScanConfigSchedule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SecurityScanConfigSchedule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SecurityScanConfigSchedule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 interval_duration_days: int,
                 schedule_time: Optional[str] = None):
        """
        :param int interval_duration_days: The duration of time between executions in days
        :param 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) -> int:
        """
        The duration of time between executions in days
        """
        return pulumi.get(self, "interval_duration_days")

    @property
    @pulumi.getter(name="scheduleTime")
    def schedule_time(self) -> Optional[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")


@pulumi.output_type
class ServiceAttachmentConnectedEndpoint(dict):
    def __init__(__self__, *,
                 endpoint: Optional[str] = None,
                 status: Optional[str] = None):
        """
        :param str endpoint: The URL of the consumer forwarding rule.
        :param str status: The status of the connection from the consumer forwarding rule to
               this service attachment.
        """
        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[str]:
        """
        The URL of the consumer forwarding rule.
        """
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter
    def status(self) -> Optional[str]:
        """
        The status of the connection from the consumer forwarding rule to
        this service attachment.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class ServiceAttachmentConsumerAcceptList(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "connectionLimit":
            suggest = "connection_limit"
        elif key == "projectIdOrNum":
            suggest = "project_id_or_num"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ServiceAttachmentConsumerAcceptList. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ServiceAttachmentConsumerAcceptList.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ServiceAttachmentConsumerAcceptList.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 connection_limit: int,
                 project_id_or_num: str):
        """
        :param int connection_limit: The number of consumer forwarding rules the consumer project can
               create.
        :param 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) -> int:
        """
        The number of consumer forwarding rules the consumer project can
        create.
        """
        return pulumi.get(self, "connection_limit")

    @property
    @pulumi.getter(name="projectIdOrNum")
    def project_id_or_num(self) -> str:
        """
        A project that is allowed to connect to this service attachment.
        """
        return pulumi.get(self, "project_id_or_num")


@pulumi.output_type
class SnapshotIamBindingCondition(dict):
    def __init__(__self__, *,
                 expression: str,
                 title: str,
                 description: Optional[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) -> str:
        return pulumi.get(self, "expression")

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

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


@pulumi.output_type
class SnapshotIamMemberCondition(dict):
    def __init__(__self__, *,
                 expression: str,
                 title: str,
                 description: Optional[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) -> str:
        return pulumi.get(self, "expression")

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

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


@pulumi.output_type
class SnapshotSnapshotEncryptionKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kmsKeySelfLink":
            suggest = "kms_key_self_link"
        elif key == "kmsKeyServiceAccount":
            suggest = "kms_key_service_account"
        elif key == "rawKey":
            suggest = "raw_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SnapshotSnapshotEncryptionKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SnapshotSnapshotEncryptionKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SnapshotSnapshotEncryptionKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kms_key_self_link: Optional[str] = None,
                 kms_key_service_account: Optional[str] = None,
                 raw_key: Optional[str] = None,
                 sha256: Optional[str] = None):
        """
        :param str kms_key_self_link: The name of the encryption key that is stored in Google Cloud KMS.
        :param 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 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 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[str]:
        """
        The name of the encryption key that is stored in Google Cloud KMS.
        """
        return pulumi.get(self, "kms_key_self_link")

    @property
    @pulumi.getter(name="kmsKeyServiceAccount")
    def kms_key_service_account(self) -> Optional[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")

    @property
    @pulumi.getter(name="rawKey")
    def raw_key(self) -> Optional[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")

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


@pulumi.output_type
class SnapshotSourceDiskEncryptionKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kmsKeyServiceAccount":
            suggest = "kms_key_service_account"
        elif key == "rawKey":
            suggest = "raw_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SnapshotSourceDiskEncryptionKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SnapshotSourceDiskEncryptionKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SnapshotSourceDiskEncryptionKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kms_key_service_account: Optional[str] = None,
                 raw_key: Optional[str] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter(name="rawKey")
    def raw_key(self) -> Optional[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")


@pulumi.output_type
class SubnetworkIAMBindingCondition(dict):
    def __init__(__self__, *,
                 expression: str,
                 title: str,
                 description: Optional[str] = None):
        """
        :param str expression: Textual representation of an expression in Common Expression Language syntax.
        :param str title: A title for the expression, i.e. a short string describing its purpose.
        :param 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) -> str:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[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")


@pulumi.output_type
class SubnetworkIAMMemberCondition(dict):
    def __init__(__self__, *,
                 expression: str,
                 title: str,
                 description: Optional[str] = None):
        """
        :param str expression: Textual representation of an expression in Common Expression Language syntax.
        :param str title: A title for the expression, i.e. a short string describing its purpose.
        :param 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) -> str:
        """
        Textual representation of an expression in Common Expression Language syntax.
        """
        return pulumi.get(self, "expression")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[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")


@pulumi.output_type
class SubnetworkLogConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aggregationInterval":
            suggest = "aggregation_interval"
        elif key == "filterExpr":
            suggest = "filter_expr"
        elif key == "flowSampling":
            suggest = "flow_sampling"
        elif key == "metadataFields":
            suggest = "metadata_fields"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SubnetworkLogConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SubnetworkLogConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SubnetworkLogConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 aggregation_interval: Optional[str] = None,
                 filter_expr: Optional[str] = None,
                 flow_sampling: Optional[float] = None,
                 metadata: Optional[str] = None,
                 metadata_fields: Optional[Sequence[str]] = None):
        """
        :param 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 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 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 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 Sequence[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[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")

    @property
    @pulumi.getter(name="filterExpr")
    def filter_expr(self) -> Optional[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")

    @property
    @pulumi.getter(name="flowSampling")
    def flow_sampling(self) -> Optional[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")

    @property
    @pulumi.getter
    def metadata(self) -> Optional[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")

    @property
    @pulumi.getter(name="metadataFields")
    def metadata_fields(self) -> Optional[Sequence[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")


@pulumi.output_type
class SubnetworkSecondaryIpRange(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipCidrRange":
            suggest = "ip_cidr_range"
        elif key == "rangeName":
            suggest = "range_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SubnetworkSecondaryIpRange. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SubnetworkSecondaryIpRange.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SubnetworkSecondaryIpRange.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ip_cidr_range: str,
                 range_name: str):
        """
        :param 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 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) -> 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")

    @property
    @pulumi.getter(name="rangeName")
    def range_name(self) -> 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")


@pulumi.output_type
class URLMapDefaultRouteAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "corsPolicy":
            suggest = "cors_policy"
        elif key == "faultInjectionPolicy":
            suggest = "fault_injection_policy"
        elif key == "requestMirrorPolicy":
            suggest = "request_mirror_policy"
        elif key == "retryPolicy":
            suggest = "retry_policy"
        elif key == "urlRewrite":
            suggest = "url_rewrite"
        elif key == "weightedBackendServices":
            suggest = "weighted_backend_services"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapDefaultRouteAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapDefaultRouteAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapDefaultRouteAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cors_policy: Optional['outputs.URLMapDefaultRouteActionCorsPolicy'] = None,
                 fault_injection_policy: Optional['outputs.URLMapDefaultRouteActionFaultInjectionPolicy'] = None,
                 request_mirror_policy: Optional['outputs.URLMapDefaultRouteActionRequestMirrorPolicy'] = None,
                 retry_policy: Optional['outputs.URLMapDefaultRouteActionRetryPolicy'] = None,
                 timeout: Optional['outputs.URLMapDefaultRouteActionTimeout'] = None,
                 url_rewrite: Optional['outputs.URLMapDefaultRouteActionUrlRewrite'] = None,
                 weighted_backend_services: Optional[Sequence['outputs.URLMapDefaultRouteActionWeightedBackendService']] = None):
        """
        :param '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 '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 '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 'URLMapDefaultRouteActionRetryPolicyArgs' retry_policy: Specifies the retry policy associated with this route.
               Structure is documented below.
        :param '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 '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 Sequence['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['outputs.URLMapDefaultRouteActionCorsPolicy']:
        """
        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")

    @property
    @pulumi.getter(name="faultInjectionPolicy")
    def fault_injection_policy(self) -> Optional['outputs.URLMapDefaultRouteActionFaultInjectionPolicy']:
        """
        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")

    @property
    @pulumi.getter(name="requestMirrorPolicy")
    def request_mirror_policy(self) -> Optional['outputs.URLMapDefaultRouteActionRequestMirrorPolicy']:
        """
        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")

    @property
    @pulumi.getter(name="retryPolicy")
    def retry_policy(self) -> Optional['outputs.URLMapDefaultRouteActionRetryPolicy']:
        """
        Specifies the retry policy associated with this route.
        Structure is documented below.
        """
        return pulumi.get(self, "retry_policy")

    @property
    @pulumi.getter
    def timeout(self) -> Optional['outputs.URLMapDefaultRouteActionTimeout']:
        """
        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")

    @property
    @pulumi.getter(name="urlRewrite")
    def url_rewrite(self) -> Optional['outputs.URLMapDefaultRouteActionUrlRewrite']:
        """
        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")

    @property
    @pulumi.getter(name="weightedBackendServices")
    def weighted_backend_services(self) -> Optional[Sequence['outputs.URLMapDefaultRouteActionWeightedBackendService']]:
        """
        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")


@pulumi.output_type
class URLMapDefaultRouteActionCorsPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowCredentials":
            suggest = "allow_credentials"
        elif key == "allowHeaders":
            suggest = "allow_headers"
        elif key == "allowMethods":
            suggest = "allow_methods"
        elif key == "allowOriginRegexes":
            suggest = "allow_origin_regexes"
        elif key == "allowOrigins":
            suggest = "allow_origins"
        elif key == "exposeHeaders":
            suggest = "expose_headers"
        elif key == "maxAge":
            suggest = "max_age"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapDefaultRouteActionCorsPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapDefaultRouteActionCorsPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapDefaultRouteActionCorsPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 allow_credentials: Optional[bool] = None,
                 allow_headers: Optional[Sequence[str]] = None,
                 allow_methods: Optional[Sequence[str]] = None,
                 allow_origin_regexes: Optional[Sequence[str]] = None,
                 allow_origins: Optional[Sequence[str]] = None,
                 disabled: Optional[bool] = None,
                 expose_headers: Optional[Sequence[str]] = None,
                 max_age: Optional[int] = None):
        """
        :param 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 Sequence[str] allow_headers: Specifies the content for the Access-Control-Allow-Headers header.
        :param Sequence[str] allow_methods: Specifies the content for the Access-Control-Allow-Methods header.
        :param Sequence[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 Sequence[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 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 Sequence[str] expose_headers: Specifies the content for the Access-Control-Expose-Headers header.
        :param 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[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")

    @property
    @pulumi.getter(name="allowHeaders")
    def allow_headers(self) -> Optional[Sequence[str]]:
        """
        Specifies the content for the Access-Control-Allow-Headers header.
        """
        return pulumi.get(self, "allow_headers")

    @property
    @pulumi.getter(name="allowMethods")
    def allow_methods(self) -> Optional[Sequence[str]]:
        """
        Specifies the content for the Access-Control-Allow-Methods header.
        """
        return pulumi.get(self, "allow_methods")

    @property
    @pulumi.getter(name="allowOriginRegexes")
    def allow_origin_regexes(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter(name="allowOrigins")
    def allow_origins(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter
    def disabled(self) -> Optional[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")

    @property
    @pulumi.getter(name="exposeHeaders")
    def expose_headers(self) -> Optional[Sequence[str]]:
        """
        Specifies the content for the Access-Control-Expose-Headers header.
        """
        return pulumi.get(self, "expose_headers")

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[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")


@pulumi.output_type
class URLMapDefaultRouteActionFaultInjectionPolicy(dict):
    def __init__(__self__, *,
                 abort: Optional['outputs.URLMapDefaultRouteActionFaultInjectionPolicyAbort'] = None,
                 delay: Optional['outputs.URLMapDefaultRouteActionFaultInjectionPolicyDelay'] = None):
        """
        :param 'URLMapDefaultRouteActionFaultInjectionPolicyAbortArgs' abort: The specification for how client requests are aborted as part of fault injection.
               Structure is documented below.
        :param '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['outputs.URLMapDefaultRouteActionFaultInjectionPolicyAbort']:
        """
        The specification for how client requests are aborted as part of fault injection.
        Structure is documented below.
        """
        return pulumi.get(self, "abort")

    @property
    @pulumi.getter
    def delay(self) -> Optional['outputs.URLMapDefaultRouteActionFaultInjectionPolicyDelay']:
        """
        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")


@pulumi.output_type
class URLMapDefaultRouteActionFaultInjectionPolicyAbort(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "httpStatus":
            suggest = "http_status"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapDefaultRouteActionFaultInjectionPolicyAbort. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapDefaultRouteActionFaultInjectionPolicyAbort.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapDefaultRouteActionFaultInjectionPolicyAbort.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 http_status: Optional[int] = None,
                 percentage: Optional[float] = None):
        """
        :param int http_status: The HTTP status code used to abort the request.
               The value must be between 200 and 599 inclusive.
        :param 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[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")

    @property
    @pulumi.getter
    def percentage(self) -> Optional[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")


@pulumi.output_type
class URLMapDefaultRouteActionFaultInjectionPolicyDelay(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fixedDelay":
            suggest = "fixed_delay"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapDefaultRouteActionFaultInjectionPolicyDelay. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapDefaultRouteActionFaultInjectionPolicyDelay.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapDefaultRouteActionFaultInjectionPolicyDelay.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 fixed_delay: Optional['outputs.URLMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelay'] = None,
                 percentage: Optional[float] = None):
        """
        :param 'URLMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs' fixed_delay: Specifies the value of the fixed delay interval.
               Structure is documented below.
        :param 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['outputs.URLMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelay']:
        """
        Specifies the value of the fixed delay interval.
        Structure is documented below.
        """
        return pulumi.get(self, "fixed_delay")

    @property
    @pulumi.getter
    def percentage(self) -> Optional[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")


@pulumi.output_type
class URLMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelay(dict):
    def __init__(__self__, *,
                 nanos: Optional[int] = None,
                 seconds: Optional[str] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter
    def seconds(self) -> Optional[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")


@pulumi.output_type
class URLMapDefaultRouteActionRequestMirrorPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backendService":
            suggest = "backend_service"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapDefaultRouteActionRequestMirrorPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapDefaultRouteActionRequestMirrorPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapDefaultRouteActionRequestMirrorPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 backend_service: str):
        """
        :param 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) -> str:
        """
        The full or partial URL to the BackendService resource being mirrored to.
        """
        return pulumi.get(self, "backend_service")


@pulumi.output_type
class URLMapDefaultRouteActionRetryPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "numRetries":
            suggest = "num_retries"
        elif key == "perTryTimeout":
            suggest = "per_try_timeout"
        elif key == "retryConditions":
            suggest = "retry_conditions"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapDefaultRouteActionRetryPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapDefaultRouteActionRetryPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapDefaultRouteActionRetryPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 num_retries: Optional[int] = None,
                 per_try_timeout: Optional['outputs.URLMapDefaultRouteActionRetryPolicyPerTryTimeout'] = None,
                 retry_conditions: Optional[Sequence[str]] = None):
        """
        :param int num_retries: Specifies the allowed number retries. This number must be > 0. If not specified, defaults to 1.
        :param '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 Sequence[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[int]:
        """
        Specifies the allowed number retries. This number must be > 0. If not specified, defaults to 1.
        """
        return pulumi.get(self, "num_retries")

    @property
    @pulumi.getter(name="perTryTimeout")
    def per_try_timeout(self) -> Optional['outputs.URLMapDefaultRouteActionRetryPolicyPerTryTimeout']:
        """
        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")

    @property
    @pulumi.getter(name="retryConditions")
    def retry_conditions(self) -> Optional[Sequence[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")


@pulumi.output_type
class URLMapDefaultRouteActionRetryPolicyPerTryTimeout(dict):
    def __init__(__self__, *,
                 nanos: Optional[int] = None,
                 seconds: Optional[str] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter
    def seconds(self) -> Optional[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")


@pulumi.output_type
class URLMapDefaultRouteActionTimeout(dict):
    def __init__(__self__, *,
                 nanos: Optional[int] = None,
                 seconds: Optional[str] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter
    def seconds(self) -> Optional[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")


@pulumi.output_type
class URLMapDefaultRouteActionUrlRewrite(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hostRewrite":
            suggest = "host_rewrite"
        elif key == "pathPrefixRewrite":
            suggest = "path_prefix_rewrite"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapDefaultRouteActionUrlRewrite. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapDefaultRouteActionUrlRewrite.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapDefaultRouteActionUrlRewrite.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 host_rewrite: Optional[str] = None,
                 path_prefix_rewrite: Optional[str] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter(name="pathPrefixRewrite")
    def path_prefix_rewrite(self) -> Optional[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")


@pulumi.output_type
class URLMapDefaultRouteActionWeightedBackendService(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backendService":
            suggest = "backend_service"
        elif key == "headerAction":
            suggest = "header_action"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapDefaultRouteActionWeightedBackendService. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapDefaultRouteActionWeightedBackendService.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapDefaultRouteActionWeightedBackendService.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 backend_service: Optional[str] = None,
                 header_action: Optional['outputs.URLMapDefaultRouteActionWeightedBackendServiceHeaderAction'] = None,
                 weight: Optional[int] = None):
        """
        :param str backend_service: The full or partial URL to the default BackendService resource. Before forwarding the
               request to backendService, the loadbalancer applies any relevant headerActions
               specified as part of this backendServiceWeight.
        :param '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 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[str]:
        """
        The full or partial URL to the default BackendService 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")

    @property
    @pulumi.getter(name="headerAction")
    def header_action(self) -> Optional['outputs.URLMapDefaultRouteActionWeightedBackendServiceHeaderAction']:
        """
        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")

    @property
    @pulumi.getter
    def weight(self) -> Optional[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")


@pulumi.output_type
class URLMapDefaultRouteActionWeightedBackendServiceHeaderAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "requestHeadersToAdds":
            suggest = "request_headers_to_adds"
        elif key == "requestHeadersToRemoves":
            suggest = "request_headers_to_removes"
        elif key == "responseHeadersToAdds":
            suggest = "response_headers_to_adds"
        elif key == "responseHeadersToRemoves":
            suggest = "response_headers_to_removes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapDefaultRouteActionWeightedBackendServiceHeaderAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapDefaultRouteActionWeightedBackendServiceHeaderAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapDefaultRouteActionWeightedBackendServiceHeaderAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 request_headers_to_adds: Optional[Sequence['outputs.URLMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd']] = None,
                 request_headers_to_removes: Optional[Sequence[str]] = None,
                 response_headers_to_adds: Optional[Sequence['outputs.URLMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd']] = None,
                 response_headers_to_removes: Optional[Sequence[str]] = None):
        """
        :param Sequence['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 Sequence[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 Sequence['URLMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs'] response_headers_to_adds: Headers to add the response prior to sending the response back to the client.
               Structure is documented below.
        :param Sequence[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[Sequence['outputs.URLMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd']]:
        """
        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")

    @property
    @pulumi.getter(name="requestHeadersToRemoves")
    def request_headers_to_removes(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter(name="responseHeadersToAdds")
    def response_headers_to_adds(self) -> Optional[Sequence['outputs.URLMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd']]:
        """
        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")

    @property
    @pulumi.getter(name="responseHeadersToRemoves")
    def response_headers_to_removes(self) -> Optional[Sequence[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")


@pulumi.output_type
class URLMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: Optional[str] = None,
                 header_value: Optional[str] = None,
                 replace: Optional[bool] = None):
        """
        :param str header_name: The name of the header to add.
        :param str header_value: The value of the header to add.
        :param 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[str]:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> Optional[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @property
    @pulumi.getter
    def replace(self) -> Optional[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")


@pulumi.output_type
class URLMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: Optional[str] = None,
                 header_value: Optional[str] = None,
                 replace: Optional[bool] = None):
        """
        :param str header_name: The name of the header to add.
        :param str header_value: The value of the header to add.
        :param 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[str]:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> Optional[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @property
    @pulumi.getter
    def replace(self) -> Optional[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")


@pulumi.output_type
class URLMapDefaultUrlRedirect(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "stripQuery":
            suggest = "strip_query"
        elif key == "hostRedirect":
            suggest = "host_redirect"
        elif key == "httpsRedirect":
            suggest = "https_redirect"
        elif key == "pathRedirect":
            suggest = "path_redirect"
        elif key == "prefixRedirect":
            suggest = "prefix_redirect"
        elif key == "redirectResponseCode":
            suggest = "redirect_response_code"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapDefaultUrlRedirect. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapDefaultUrlRedirect.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapDefaultUrlRedirect.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 strip_query: bool,
                 host_redirect: Optional[str] = None,
                 https_redirect: Optional[bool] = None,
                 path_redirect: Optional[str] = None,
                 prefix_redirect: Optional[str] = None,
                 redirect_response_code: Optional[str] = None):
        """
        :param 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 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 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 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 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 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) -> 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")

    @property
    @pulumi.getter(name="hostRedirect")
    def host_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="httpsRedirect")
    def https_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="pathRedirect")
    def path_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="prefixRedirect")
    def prefix_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="redirectResponseCode")
    def redirect_response_code(self) -> Optional[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")


@pulumi.output_type
class URLMapHeaderAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "requestHeadersToAdds":
            suggest = "request_headers_to_adds"
        elif key == "requestHeadersToRemoves":
            suggest = "request_headers_to_removes"
        elif key == "responseHeadersToAdds":
            suggest = "response_headers_to_adds"
        elif key == "responseHeadersToRemoves":
            suggest = "response_headers_to_removes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapHeaderAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapHeaderAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapHeaderAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 request_headers_to_adds: Optional[Sequence['outputs.URLMapHeaderActionRequestHeadersToAdd']] = None,
                 request_headers_to_removes: Optional[Sequence[str]] = None,
                 response_headers_to_adds: Optional[Sequence['outputs.URLMapHeaderActionResponseHeadersToAdd']] = None,
                 response_headers_to_removes: Optional[Sequence[str]] = None):
        """
        :param Sequence['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 Sequence[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 Sequence['URLMapHeaderActionResponseHeadersToAddArgs'] response_headers_to_adds: Headers to add the response prior to sending the response back to the client.
               Structure is documented below.
        :param Sequence[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[Sequence['outputs.URLMapHeaderActionRequestHeadersToAdd']]:
        """
        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")

    @property
    @pulumi.getter(name="requestHeadersToRemoves")
    def request_headers_to_removes(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter(name="responseHeadersToAdds")
    def response_headers_to_adds(self) -> Optional[Sequence['outputs.URLMapHeaderActionResponseHeadersToAdd']]:
        """
        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")

    @property
    @pulumi.getter(name="responseHeadersToRemoves")
    def response_headers_to_removes(self) -> Optional[Sequence[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")


@pulumi.output_type
class URLMapHeaderActionRequestHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapHeaderActionRequestHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: str,
                 header_value: str,
                 replace: bool):
        """
        :param str header_name: The name of the header to add.
        :param str header_value: The value of the header to add.
        :param 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) -> str:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> str:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @property
    @pulumi.getter
    def replace(self) -> 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")


@pulumi.output_type
class URLMapHeaderActionResponseHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapHeaderActionResponseHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapHeaderActionResponseHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapHeaderActionResponseHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: str,
                 header_value: str,
                 replace: bool):
        """
        :param str header_name: The name of the header to add.
        :param str header_value: The value of the header to add.
        :param 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) -> str:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> str:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @property
    @pulumi.getter
    def replace(self) -> 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")


@pulumi.output_type
class URLMapHostRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "pathMatcher":
            suggest = "path_matcher"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapHostRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapHostRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapHostRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 hosts: Sequence[str],
                 path_matcher: str,
                 description: Optional[str] = None):
        """
        :param Sequence[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 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 str description: An optional description of this resource. Provide this property when you create
               the resource.
        """
        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) -> Sequence[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")

    @property
    @pulumi.getter(name="pathMatcher")
    def path_matcher(self) -> 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")

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


@pulumi.output_type
class URLMapPathMatcher(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultRouteAction":
            suggest = "default_route_action"
        elif key == "defaultService":
            suggest = "default_service"
        elif key == "defaultUrlRedirect":
            suggest = "default_url_redirect"
        elif key == "headerAction":
            suggest = "header_action"
        elif key == "pathRules":
            suggest = "path_rules"
        elif key == "routeRules":
            suggest = "route_rules"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcher. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcher.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcher.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 default_route_action: Optional['outputs.URLMapPathMatcherDefaultRouteAction'] = None,
                 default_service: Optional[str] = None,
                 default_url_redirect: Optional['outputs.URLMapPathMatcherDefaultUrlRedirect'] = None,
                 description: Optional[str] = None,
                 header_action: Optional['outputs.URLMapPathMatcherHeaderAction'] = None,
                 path_rules: Optional[Sequence['outputs.URLMapPathMatcherPathRule']] = None,
                 route_rules: Optional[Sequence['outputs.URLMapPathMatcherRouteRule']] = None):
        """
        :param str name: The name to which this PathMatcher is referred by the HostRule.
        :param '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 str default_service: The backend service or backend bucket to use when none of the given paths match.
        :param '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 str description: An optional description of this resource. Provide this property when you create
               the resource.
        :param 'URLMapPathMatcherHeaderActionArgs' header_action: Specifies changes to request and response headers that need to take effect for
               the selected backendService. HeaderAction specified here are applied after the
               matching HttpRouteRule HeaderAction and before the HeaderAction in the UrlMap
               Structure is documented below.
        :param Sequence['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 Sequence['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) -> str:
        """
        The name to which this PathMatcher is referred by the HostRule.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="defaultRouteAction")
    def default_route_action(self) -> Optional['outputs.URLMapPathMatcherDefaultRouteAction']:
        """
        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")

    @property
    @pulumi.getter(name="defaultService")
    def default_service(self) -> Optional[str]:
        """
        The backend service or backend bucket to use when none of the given paths match.
        """
        return pulumi.get(self, "default_service")

    @property
    @pulumi.getter(name="defaultUrlRedirect")
    def default_url_redirect(self) -> Optional['outputs.URLMapPathMatcherDefaultUrlRedirect']:
        """
        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")

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

    @property
    @pulumi.getter(name="headerAction")
    def header_action(self) -> Optional['outputs.URLMapPathMatcherHeaderAction']:
        """
        Specifies changes to request and response headers that need to take effect for
        the selected backendService. HeaderAction specified here are applied after the
        matching HttpRouteRule HeaderAction and before the HeaderAction in the UrlMap
        Structure is documented below.
        """
        return pulumi.get(self, "header_action")

    @property
    @pulumi.getter(name="pathRules")
    def path_rules(self) -> Optional[Sequence['outputs.URLMapPathMatcherPathRule']]:
        """
        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")

    @property
    @pulumi.getter(name="routeRules")
    def route_rules(self) -> Optional[Sequence['outputs.URLMapPathMatcherRouteRule']]:
        """
        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")


@pulumi.output_type
class URLMapPathMatcherDefaultRouteAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "corsPolicy":
            suggest = "cors_policy"
        elif key == "faultInjectionPolicy":
            suggest = "fault_injection_policy"
        elif key == "requestMirrorPolicy":
            suggest = "request_mirror_policy"
        elif key == "retryPolicy":
            suggest = "retry_policy"
        elif key == "urlRewrite":
            suggest = "url_rewrite"
        elif key == "weightedBackendServices":
            suggest = "weighted_backend_services"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherDefaultRouteAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherDefaultRouteAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherDefaultRouteAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cors_policy: Optional['outputs.URLMapPathMatcherDefaultRouteActionCorsPolicy'] = None,
                 fault_injection_policy: Optional['outputs.URLMapPathMatcherDefaultRouteActionFaultInjectionPolicy'] = None,
                 request_mirror_policy: Optional['outputs.URLMapPathMatcherDefaultRouteActionRequestMirrorPolicy'] = None,
                 retry_policy: Optional['outputs.URLMapPathMatcherDefaultRouteActionRetryPolicy'] = None,
                 timeout: Optional['outputs.URLMapPathMatcherDefaultRouteActionTimeout'] = None,
                 url_rewrite: Optional['outputs.URLMapPathMatcherDefaultRouteActionUrlRewrite'] = None,
                 weighted_backend_services: Optional[Sequence['outputs.URLMapPathMatcherDefaultRouteActionWeightedBackendService']] = None):
        """
        :param '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 '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 '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 'URLMapPathMatcherDefaultRouteActionRetryPolicyArgs' retry_policy: Specifies the retry policy associated with this route.
               Structure is documented below.
        :param '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 '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 Sequence['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['outputs.URLMapPathMatcherDefaultRouteActionCorsPolicy']:
        """
        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")

    @property
    @pulumi.getter(name="faultInjectionPolicy")
    def fault_injection_policy(self) -> Optional['outputs.URLMapPathMatcherDefaultRouteActionFaultInjectionPolicy']:
        """
        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")

    @property
    @pulumi.getter(name="requestMirrorPolicy")
    def request_mirror_policy(self) -> Optional['outputs.URLMapPathMatcherDefaultRouteActionRequestMirrorPolicy']:
        """
        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")

    @property
    @pulumi.getter(name="retryPolicy")
    def retry_policy(self) -> Optional['outputs.URLMapPathMatcherDefaultRouteActionRetryPolicy']:
        """
        Specifies the retry policy associated with this route.
        Structure is documented below.
        """
        return pulumi.get(self, "retry_policy")

    @property
    @pulumi.getter
    def timeout(self) -> Optional['outputs.URLMapPathMatcherDefaultRouteActionTimeout']:
        """
        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")

    @property
    @pulumi.getter(name="urlRewrite")
    def url_rewrite(self) -> Optional['outputs.URLMapPathMatcherDefaultRouteActionUrlRewrite']:
        """
        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")

    @property
    @pulumi.getter(name="weightedBackendServices")
    def weighted_backend_services(self) -> Optional[Sequence['outputs.URLMapPathMatcherDefaultRouteActionWeightedBackendService']]:
        """
        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")


@pulumi.output_type
class URLMapPathMatcherDefaultRouteActionCorsPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowCredentials":
            suggest = "allow_credentials"
        elif key == "allowHeaders":
            suggest = "allow_headers"
        elif key == "allowMethods":
            suggest = "allow_methods"
        elif key == "allowOriginRegexes":
            suggest = "allow_origin_regexes"
        elif key == "allowOrigins":
            suggest = "allow_origins"
        elif key == "exposeHeaders":
            suggest = "expose_headers"
        elif key == "maxAge":
            suggest = "max_age"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherDefaultRouteActionCorsPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherDefaultRouteActionCorsPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherDefaultRouteActionCorsPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 allow_credentials: Optional[bool] = None,
                 allow_headers: Optional[Sequence[str]] = None,
                 allow_methods: Optional[Sequence[str]] = None,
                 allow_origin_regexes: Optional[Sequence[str]] = None,
                 allow_origins: Optional[Sequence[str]] = None,
                 disabled: Optional[bool] = None,
                 expose_headers: Optional[Sequence[str]] = None,
                 max_age: Optional[int] = None):
        """
        :param 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 Sequence[str] allow_headers: Specifies the content for the Access-Control-Allow-Headers header.
        :param Sequence[str] allow_methods: Specifies the content for the Access-Control-Allow-Methods header.
        :param Sequence[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 Sequence[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 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 Sequence[str] expose_headers: Specifies the content for the Access-Control-Expose-Headers header.
        :param 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[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")

    @property
    @pulumi.getter(name="allowHeaders")
    def allow_headers(self) -> Optional[Sequence[str]]:
        """
        Specifies the content for the Access-Control-Allow-Headers header.
        """
        return pulumi.get(self, "allow_headers")

    @property
    @pulumi.getter(name="allowMethods")
    def allow_methods(self) -> Optional[Sequence[str]]:
        """
        Specifies the content for the Access-Control-Allow-Methods header.
        """
        return pulumi.get(self, "allow_methods")

    @property
    @pulumi.getter(name="allowOriginRegexes")
    def allow_origin_regexes(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter(name="allowOrigins")
    def allow_origins(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter
    def disabled(self) -> Optional[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")

    @property
    @pulumi.getter(name="exposeHeaders")
    def expose_headers(self) -> Optional[Sequence[str]]:
        """
        Specifies the content for the Access-Control-Expose-Headers header.
        """
        return pulumi.get(self, "expose_headers")

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherDefaultRouteActionFaultInjectionPolicy(dict):
    def __init__(__self__, *,
                 abort: Optional['outputs.URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyAbort'] = None,
                 delay: Optional['outputs.URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelay'] = None):
        """
        :param 'URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyAbortArgs' abort: The specification for how client requests are aborted as part of fault injection.
               Structure is documented below.
        :param '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['outputs.URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyAbort']:
        """
        The specification for how client requests are aborted as part of fault injection.
        Structure is documented below.
        """
        return pulumi.get(self, "abort")

    @property
    @pulumi.getter
    def delay(self) -> Optional['outputs.URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelay']:
        """
        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")


@pulumi.output_type
class URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyAbort(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "httpStatus":
            suggest = "http_status"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyAbort. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyAbort.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyAbort.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 http_status: Optional[int] = None,
                 percentage: Optional[float] = None):
        """
        :param int http_status: The HTTP status code used to abort the request.
               The value must be between 200 and 599 inclusive.
        :param 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[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")

    @property
    @pulumi.getter
    def percentage(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelay(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fixedDelay":
            suggest = "fixed_delay"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelay. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelay.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelay.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 fixed_delay: Optional['outputs.URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayFixedDelay'] = None,
                 percentage: Optional[float] = None):
        """
        :param 'URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs' fixed_delay: Specifies the value of the fixed delay interval.
               Structure is documented below.
        :param 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['outputs.URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayFixedDelay']:
        """
        Specifies the value of the fixed delay interval.
        Structure is documented below.
        """
        return pulumi.get(self, "fixed_delay")

    @property
    @pulumi.getter
    def percentage(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayFixedDelay(dict):
    def __init__(__self__, *,
                 nanos: Optional[int] = None,
                 seconds: Optional[str] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter
    def seconds(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherDefaultRouteActionRequestMirrorPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backendService":
            suggest = "backend_service"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherDefaultRouteActionRequestMirrorPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherDefaultRouteActionRequestMirrorPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherDefaultRouteActionRequestMirrorPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 backend_service: str):
        """
        :param 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) -> str:
        """
        The full or partial URL to the BackendService resource being mirrored to.
        """
        return pulumi.get(self, "backend_service")


@pulumi.output_type
class URLMapPathMatcherDefaultRouteActionRetryPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "numRetries":
            suggest = "num_retries"
        elif key == "perTryTimeout":
            suggest = "per_try_timeout"
        elif key == "retryConditions":
            suggest = "retry_conditions"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherDefaultRouteActionRetryPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherDefaultRouteActionRetryPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherDefaultRouteActionRetryPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 num_retries: Optional[int] = None,
                 per_try_timeout: Optional['outputs.URLMapPathMatcherDefaultRouteActionRetryPolicyPerTryTimeout'] = None,
                 retry_conditions: Optional[Sequence[str]] = None):
        """
        :param int num_retries: Specifies the allowed number retries. This number must be > 0. If not specified, defaults to 1.
        :param '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 Sequence[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[int]:
        """
        Specifies the allowed number retries. This number must be > 0. If not specified, defaults to 1.
        """
        return pulumi.get(self, "num_retries")

    @property
    @pulumi.getter(name="perTryTimeout")
    def per_try_timeout(self) -> Optional['outputs.URLMapPathMatcherDefaultRouteActionRetryPolicyPerTryTimeout']:
        """
        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")

    @property
    @pulumi.getter(name="retryConditions")
    def retry_conditions(self) -> Optional[Sequence[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")


@pulumi.output_type
class URLMapPathMatcherDefaultRouteActionRetryPolicyPerTryTimeout(dict):
    def __init__(__self__, *,
                 nanos: Optional[int] = None,
                 seconds: Optional[str] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter
    def seconds(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherDefaultRouteActionTimeout(dict):
    def __init__(__self__, *,
                 nanos: Optional[int] = None,
                 seconds: Optional[str] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter
    def seconds(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherDefaultRouteActionUrlRewrite(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hostRewrite":
            suggest = "host_rewrite"
        elif key == "pathPrefixRewrite":
            suggest = "path_prefix_rewrite"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherDefaultRouteActionUrlRewrite. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherDefaultRouteActionUrlRewrite.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherDefaultRouteActionUrlRewrite.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 host_rewrite: Optional[str] = None,
                 path_prefix_rewrite: Optional[str] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter(name="pathPrefixRewrite")
    def path_prefix_rewrite(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherDefaultRouteActionWeightedBackendService(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backendService":
            suggest = "backend_service"
        elif key == "headerAction":
            suggest = "header_action"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherDefaultRouteActionWeightedBackendService. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherDefaultRouteActionWeightedBackendService.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherDefaultRouteActionWeightedBackendService.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 backend_service: Optional[str] = None,
                 header_action: Optional['outputs.URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderAction'] = None,
                 weight: Optional[int] = None):
        """
        :param str backend_service: The full or partial URL to the default BackendService resource. Before forwarding the
               request to backendService, the loadbalancer applies any relevant headerActions
               specified as part of this backendServiceWeight.
        :param '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 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[str]:
        """
        The full or partial URL to the default BackendService 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")

    @property
    @pulumi.getter(name="headerAction")
    def header_action(self) -> Optional['outputs.URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderAction']:
        """
        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")

    @property
    @pulumi.getter
    def weight(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "requestHeadersToAdds":
            suggest = "request_headers_to_adds"
        elif key == "requestHeadersToRemoves":
            suggest = "request_headers_to_removes"
        elif key == "responseHeadersToAdds":
            suggest = "response_headers_to_adds"
        elif key == "responseHeadersToRemoves":
            suggest = "response_headers_to_removes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 request_headers_to_adds: Optional[Sequence['outputs.URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd']] = None,
                 request_headers_to_removes: Optional[Sequence[str]] = None,
                 response_headers_to_adds: Optional[Sequence['outputs.URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd']] = None,
                 response_headers_to_removes: Optional[Sequence[str]] = None):
        """
        :param Sequence['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 Sequence[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 Sequence['URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs'] response_headers_to_adds: Headers to add the response prior to sending the response back to the client.
               Structure is documented below.
        :param Sequence[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[Sequence['outputs.URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd']]:
        """
        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")

    @property
    @pulumi.getter(name="requestHeadersToRemoves")
    def request_headers_to_removes(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter(name="responseHeadersToAdds")
    def response_headers_to_adds(self) -> Optional[Sequence['outputs.URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd']]:
        """
        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")

    @property
    @pulumi.getter(name="responseHeadersToRemoves")
    def response_headers_to_removes(self) -> Optional[Sequence[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")


@pulumi.output_type
class URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: Optional[str] = None,
                 header_value: Optional[str] = None,
                 replace: Optional[bool] = None):
        """
        :param str header_name: The name of the header to add.
        :param str header_value: The value of the header to add.
        :param 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[str]:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> Optional[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @property
    @pulumi.getter
    def replace(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: Optional[str] = None,
                 header_value: Optional[str] = None,
                 replace: Optional[bool] = None):
        """
        :param str header_name: The name of the header to add.
        :param str header_value: The value of the header to add.
        :param 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[str]:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> Optional[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @property
    @pulumi.getter
    def replace(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherDefaultUrlRedirect(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "stripQuery":
            suggest = "strip_query"
        elif key == "hostRedirect":
            suggest = "host_redirect"
        elif key == "httpsRedirect":
            suggest = "https_redirect"
        elif key == "pathRedirect":
            suggest = "path_redirect"
        elif key == "prefixRedirect":
            suggest = "prefix_redirect"
        elif key == "redirectResponseCode":
            suggest = "redirect_response_code"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherDefaultUrlRedirect. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherDefaultUrlRedirect.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherDefaultUrlRedirect.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 strip_query: bool,
                 host_redirect: Optional[str] = None,
                 https_redirect: Optional[bool] = None,
                 path_redirect: Optional[str] = None,
                 prefix_redirect: Optional[str] = None,
                 redirect_response_code: Optional[str] = None):
        """
        :param 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 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 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 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 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 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) -> 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")

    @property
    @pulumi.getter(name="hostRedirect")
    def host_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="httpsRedirect")
    def https_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="pathRedirect")
    def path_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="prefixRedirect")
    def prefix_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="redirectResponseCode")
    def redirect_response_code(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherHeaderAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "requestHeadersToAdds":
            suggest = "request_headers_to_adds"
        elif key == "requestHeadersToRemoves":
            suggest = "request_headers_to_removes"
        elif key == "responseHeadersToAdds":
            suggest = "response_headers_to_adds"
        elif key == "responseHeadersToRemoves":
            suggest = "response_headers_to_removes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherHeaderAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherHeaderAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherHeaderAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 request_headers_to_adds: Optional[Sequence['outputs.URLMapPathMatcherHeaderActionRequestHeadersToAdd']] = None,
                 request_headers_to_removes: Optional[Sequence[str]] = None,
                 response_headers_to_adds: Optional[Sequence['outputs.URLMapPathMatcherHeaderActionResponseHeadersToAdd']] = None,
                 response_headers_to_removes: Optional[Sequence[str]] = None):
        """
        :param Sequence['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 Sequence[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 Sequence['URLMapPathMatcherHeaderActionResponseHeadersToAddArgs'] response_headers_to_adds: Headers to add the response prior to sending the response back to the client.
               Structure is documented below.
        :param Sequence[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[Sequence['outputs.URLMapPathMatcherHeaderActionRequestHeadersToAdd']]:
        """
        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")

    @property
    @pulumi.getter(name="requestHeadersToRemoves")
    def request_headers_to_removes(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter(name="responseHeadersToAdds")
    def response_headers_to_adds(self) -> Optional[Sequence['outputs.URLMapPathMatcherHeaderActionResponseHeadersToAdd']]:
        """
        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")

    @property
    @pulumi.getter(name="responseHeadersToRemoves")
    def response_headers_to_removes(self) -> Optional[Sequence[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")


@pulumi.output_type
class URLMapPathMatcherHeaderActionRequestHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherHeaderActionRequestHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: str,
                 header_value: str,
                 replace: bool):
        """
        :param str header_name: The name of the header to add.
        :param str header_value: The value of the header to add.
        :param 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) -> str:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> str:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @property
    @pulumi.getter
    def replace(self) -> 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")


@pulumi.output_type
class URLMapPathMatcherHeaderActionResponseHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherHeaderActionResponseHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherHeaderActionResponseHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherHeaderActionResponseHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: str,
                 header_value: str,
                 replace: bool):
        """
        :param str header_name: The name of the header to add.
        :param str header_value: The value of the header to add.
        :param 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) -> str:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> str:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @property
    @pulumi.getter
    def replace(self) -> 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")


@pulumi.output_type
class URLMapPathMatcherPathRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "routeAction":
            suggest = "route_action"
        elif key == "urlRedirect":
            suggest = "url_redirect"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherPathRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherPathRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherPathRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 paths: Sequence[str],
                 route_action: Optional['outputs.URLMapPathMatcherPathRuleRouteAction'] = None,
                 service: Optional[str] = None,
                 url_redirect: Optional['outputs.URLMapPathMatcherPathRuleUrlRedirect'] = None):
        """
        :param Sequence[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 'URLMapPathMatcherPathRuleRouteActionArgs' 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 str service: The backend service or backend bucket to use if any of the given paths match.
        :param 'URLMapPathMatcherPathRuleUrlRedirectArgs' 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) -> Sequence[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")

    @property
    @pulumi.getter(name="routeAction")
    def route_action(self) -> Optional['outputs.URLMapPathMatcherPathRuleRouteAction']:
        """
        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")

    @property
    @pulumi.getter
    def service(self) -> Optional[str]:
        """
        The backend service or backend bucket to use if any of the given paths match.
        """
        return pulumi.get(self, "service")

    @property
    @pulumi.getter(name="urlRedirect")
    def url_redirect(self) -> Optional['outputs.URLMapPathMatcherPathRuleUrlRedirect']:
        """
        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")


@pulumi.output_type
class URLMapPathMatcherPathRuleRouteAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "corsPolicy":
            suggest = "cors_policy"
        elif key == "faultInjectionPolicy":
            suggest = "fault_injection_policy"
        elif key == "requestMirrorPolicy":
            suggest = "request_mirror_policy"
        elif key == "retryPolicy":
            suggest = "retry_policy"
        elif key == "urlRewrite":
            suggest = "url_rewrite"
        elif key == "weightedBackendServices":
            suggest = "weighted_backend_services"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherPathRuleRouteAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherPathRuleRouteAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherPathRuleRouteAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cors_policy: Optional['outputs.URLMapPathMatcherPathRuleRouteActionCorsPolicy'] = None,
                 fault_injection_policy: Optional['outputs.URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicy'] = None,
                 request_mirror_policy: Optional['outputs.URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicy'] = None,
                 retry_policy: Optional['outputs.URLMapPathMatcherPathRuleRouteActionRetryPolicy'] = None,
                 timeout: Optional['outputs.URLMapPathMatcherPathRuleRouteActionTimeout'] = None,
                 url_rewrite: Optional['outputs.URLMapPathMatcherPathRuleRouteActionUrlRewrite'] = None,
                 weighted_backend_services: Optional[Sequence['outputs.URLMapPathMatcherPathRuleRouteActionWeightedBackendService']] = None):
        """
        :param 'URLMapPathMatcherPathRuleRouteActionCorsPolicyArgs' 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 '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 retry_policy will be
               ignored by clients that are configured with a fault_injection_policy.
               Structure is documented below.
        :param '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 'URLMapPathMatcherPathRuleRouteActionRetryPolicyArgs' retry_policy: Specifies the retry policy associated with this route.
               Structure is documented below.
        :param 'URLMapPathMatcherPathRuleRouteActionTimeoutArgs' 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 '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 Sequence['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['outputs.URLMapPathMatcherPathRuleRouteActionCorsPolicy']:
        """
        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")

    @property
    @pulumi.getter(name="faultInjectionPolicy")
    def fault_injection_policy(self) -> Optional['outputs.URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicy']:
        """
        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")

    @property
    @pulumi.getter(name="requestMirrorPolicy")
    def request_mirror_policy(self) -> Optional['outputs.URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicy']:
        """
        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")

    @property
    @pulumi.getter(name="retryPolicy")
    def retry_policy(self) -> Optional['outputs.URLMapPathMatcherPathRuleRouteActionRetryPolicy']:
        """
        Specifies the retry policy associated with this route.
        Structure is documented below.
        """
        return pulumi.get(self, "retry_policy")

    @property
    @pulumi.getter
    def timeout(self) -> Optional['outputs.URLMapPathMatcherPathRuleRouteActionTimeout']:
        """
        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")

    @property
    @pulumi.getter(name="urlRewrite")
    def url_rewrite(self) -> Optional['outputs.URLMapPathMatcherPathRuleRouteActionUrlRewrite']:
        """
        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")

    @property
    @pulumi.getter(name="weightedBackendServices")
    def weighted_backend_services(self) -> Optional[Sequence['outputs.URLMapPathMatcherPathRuleRouteActionWeightedBackendService']]:
        """
        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")


@pulumi.output_type
class URLMapPathMatcherPathRuleRouteActionCorsPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowCredentials":
            suggest = "allow_credentials"
        elif key == "allowHeaders":
            suggest = "allow_headers"
        elif key == "allowMethods":
            suggest = "allow_methods"
        elif key == "allowOriginRegexes":
            suggest = "allow_origin_regexes"
        elif key == "allowOrigins":
            suggest = "allow_origins"
        elif key == "exposeHeaders":
            suggest = "expose_headers"
        elif key == "maxAge":
            suggest = "max_age"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherPathRuleRouteActionCorsPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherPathRuleRouteActionCorsPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherPathRuleRouteActionCorsPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 disabled: bool,
                 allow_credentials: Optional[bool] = None,
                 allow_headers: Optional[Sequence[str]] = None,
                 allow_methods: Optional[Sequence[str]] = None,
                 allow_origin_regexes: Optional[Sequence[str]] = None,
                 allow_origins: Optional[Sequence[str]] = None,
                 expose_headers: Optional[Sequence[str]] = None,
                 max_age: Optional[int] = None):
        """
        :param 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 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 Sequence[str] allow_headers: Specifies the content for the Access-Control-Allow-Headers header.
        :param Sequence[str] allow_methods: Specifies the content for the Access-Control-Allow-Methods header.
        :param Sequence[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 Sequence[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 Sequence[str] expose_headers: Specifies the content for the Access-Control-Expose-Headers header.
        :param 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) -> 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")

    @property
    @pulumi.getter(name="allowCredentials")
    def allow_credentials(self) -> Optional[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")

    @property
    @pulumi.getter(name="allowHeaders")
    def allow_headers(self) -> Optional[Sequence[str]]:
        """
        Specifies the content for the Access-Control-Allow-Headers header.
        """
        return pulumi.get(self, "allow_headers")

    @property
    @pulumi.getter(name="allowMethods")
    def allow_methods(self) -> Optional[Sequence[str]]:
        """
        Specifies the content for the Access-Control-Allow-Methods header.
        """
        return pulumi.get(self, "allow_methods")

    @property
    @pulumi.getter(name="allowOriginRegexes")
    def allow_origin_regexes(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter(name="allowOrigins")
    def allow_origins(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter(name="exposeHeaders")
    def expose_headers(self) -> Optional[Sequence[str]]:
        """
        Specifies the content for the Access-Control-Expose-Headers header.
        """
        return pulumi.get(self, "expose_headers")

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicy(dict):
    def __init__(__self__, *,
                 abort: Optional['outputs.URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbort'] = None,
                 delay: Optional['outputs.URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelay'] = None):
        """
        :param 'URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs' abort: The specification for how client requests are aborted as part of fault injection.
               Structure is documented below.
        :param '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['outputs.URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbort']:
        """
        The specification for how client requests are aborted as part of fault injection.
        Structure is documented below.
        """
        return pulumi.get(self, "abort")

    @property
    @pulumi.getter
    def delay(self) -> Optional['outputs.URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelay']:
        """
        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")


@pulumi.output_type
class URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbort(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "httpStatus":
            suggest = "http_status"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbort. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbort.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbort.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 http_status: int,
                 percentage: float):
        """
        :param int http_status: The HTTP status code used to abort the request.
               The value must be between 200 and 599 inclusive.
        :param 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) -> 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")

    @property
    @pulumi.getter
    def percentage(self) -> 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")


@pulumi.output_type
class URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelay(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fixedDelay":
            suggest = "fixed_delay"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelay. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelay.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelay.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 fixed_delay: 'outputs.URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelay',
                 percentage: float):
        """
        :param 'URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs' fixed_delay: Specifies the value of the fixed delay interval.
               Structure is documented below.
        :param 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) -> 'outputs.URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelay':
        """
        Specifies the value of the fixed delay interval.
        Structure is documented below.
        """
        return pulumi.get(self, "fixed_delay")

    @property
    @pulumi.getter
    def percentage(self) -> 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")


@pulumi.output_type
class URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelay(dict):
    def __init__(__self__, *,
                 seconds: str,
                 nanos: Optional[int] = None):
        """
        :param 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 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) -> 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")

    @property
    @pulumi.getter
    def nanos(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backendService":
            suggest = "backend_service"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 backend_service: str):
        """
        :param 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) -> str:
        """
        The full or partial URL to the BackendService resource being mirrored to.
        """
        return pulumi.get(self, "backend_service")


@pulumi.output_type
class URLMapPathMatcherPathRuleRouteActionRetryPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "numRetries":
            suggest = "num_retries"
        elif key == "perTryTimeout":
            suggest = "per_try_timeout"
        elif key == "retryConditions":
            suggest = "retry_conditions"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherPathRuleRouteActionRetryPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherPathRuleRouteActionRetryPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherPathRuleRouteActionRetryPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 num_retries: Optional[int] = None,
                 per_try_timeout: Optional['outputs.URLMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeout'] = None,
                 retry_conditions: Optional[Sequence[str]] = None):
        """
        :param int num_retries: Specifies the allowed number retries. This number must be > 0. If not specified, defaults to 1.
        :param '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 Sequence[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[int]:
        """
        Specifies the allowed number retries. This number must be > 0. If not specified, defaults to 1.
        """
        return pulumi.get(self, "num_retries")

    @property
    @pulumi.getter(name="perTryTimeout")
    def per_try_timeout(self) -> Optional['outputs.URLMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeout']:
        """
        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")

    @property
    @pulumi.getter(name="retryConditions")
    def retry_conditions(self) -> Optional[Sequence[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")


@pulumi.output_type
class URLMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeout(dict):
    def __init__(__self__, *,
                 seconds: str,
                 nanos: Optional[int] = None):
        """
        :param 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 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) -> 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")

    @property
    @pulumi.getter
    def nanos(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherPathRuleRouteActionTimeout(dict):
    def __init__(__self__, *,
                 seconds: str,
                 nanos: Optional[int] = None):
        """
        :param 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 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) -> 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")

    @property
    @pulumi.getter
    def nanos(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherPathRuleRouteActionUrlRewrite(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hostRewrite":
            suggest = "host_rewrite"
        elif key == "pathPrefixRewrite":
            suggest = "path_prefix_rewrite"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherPathRuleRouteActionUrlRewrite. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherPathRuleRouteActionUrlRewrite.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherPathRuleRouteActionUrlRewrite.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 host_rewrite: Optional[str] = None,
                 path_prefix_rewrite: Optional[str] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter(name="pathPrefixRewrite")
    def path_prefix_rewrite(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherPathRuleRouteActionWeightedBackendService(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backendService":
            suggest = "backend_service"
        elif key == "headerAction":
            suggest = "header_action"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherPathRuleRouteActionWeightedBackendService. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherPathRuleRouteActionWeightedBackendService.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherPathRuleRouteActionWeightedBackendService.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 backend_service: str,
                 weight: int,
                 header_action: Optional['outputs.URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderAction'] = None):
        """
        :param str backend_service: The full or partial URL to the default BackendService resource. Before forwarding the
               request to backendService, the loadbalancer applies any relevant headerActions
               specified as part of this backendServiceWeight.
        :param 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 '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) -> str:
        """
        The full or partial URL to the default BackendService 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")

    @property
    @pulumi.getter
    def weight(self) -> 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")

    @property
    @pulumi.getter(name="headerAction")
    def header_action(self) -> Optional['outputs.URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderAction']:
        """
        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")


@pulumi.output_type
class URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "requestHeadersToAdds":
            suggest = "request_headers_to_adds"
        elif key == "requestHeadersToRemoves":
            suggest = "request_headers_to_removes"
        elif key == "responseHeadersToAdds":
            suggest = "response_headers_to_adds"
        elif key == "responseHeadersToRemoves":
            suggest = "response_headers_to_removes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 request_headers_to_adds: Optional[Sequence['outputs.URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd']] = None,
                 request_headers_to_removes: Optional[Sequence[str]] = None,
                 response_headers_to_adds: Optional[Sequence['outputs.URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd']] = None,
                 response_headers_to_removes: Optional[Sequence[str]] = None):
        """
        :param Sequence['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 Sequence[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 Sequence['URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs'] response_headers_to_adds: Headers to add the response prior to sending the response back to the client.
               Structure is documented below.
        :param Sequence[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[Sequence['outputs.URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd']]:
        """
        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")

    @property
    @pulumi.getter(name="requestHeadersToRemoves")
    def request_headers_to_removes(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter(name="responseHeadersToAdds")
    def response_headers_to_adds(self) -> Optional[Sequence['outputs.URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd']]:
        """
        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")

    @property
    @pulumi.getter(name="responseHeadersToRemoves")
    def response_headers_to_removes(self) -> Optional[Sequence[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")


@pulumi.output_type
class URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: str,
                 header_value: str,
                 replace: bool):
        """
        :param str header_name: The name of the header to add.
        :param str header_value: The value of the header to add.
        :param 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) -> str:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> str:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @property
    @pulumi.getter
    def replace(self) -> 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")


@pulumi.output_type
class URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: str,
                 header_value: str,
                 replace: bool):
        """
        :param str header_name: The name of the header to add.
        :param str header_value: The value of the header to add.
        :param 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) -> str:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> str:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @property
    @pulumi.getter
    def replace(self) -> 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")


@pulumi.output_type
class URLMapPathMatcherPathRuleUrlRedirect(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "stripQuery":
            suggest = "strip_query"
        elif key == "hostRedirect":
            suggest = "host_redirect"
        elif key == "httpsRedirect":
            suggest = "https_redirect"
        elif key == "pathRedirect":
            suggest = "path_redirect"
        elif key == "prefixRedirect":
            suggest = "prefix_redirect"
        elif key == "redirectResponseCode":
            suggest = "redirect_response_code"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherPathRuleUrlRedirect. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherPathRuleUrlRedirect.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherPathRuleUrlRedirect.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 strip_query: bool,
                 host_redirect: Optional[str] = None,
                 https_redirect: Optional[bool] = None,
                 path_redirect: Optional[str] = None,
                 prefix_redirect: Optional[str] = None,
                 redirect_response_code: Optional[str] = None):
        """
        :param 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. Defaults to false.
        :param 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 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. Defaults to false.
        :param str path_redirect: The path that will be used in the redirect response instead of the one that was
               supplied in the request. Only one of pathRedirect or prefixRedirect must be
               specified. The value must be between 1 and 1024 characters.
        :param str prefix_redirect: The prefix that replaces the prefixMatch specified in the HttpRouteRuleMatch,
               retaining the remaining portion of the URL before redirecting the request.
        :param 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) -> 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. Defaults to false.
        """
        return pulumi.get(self, "strip_query")

    @property
    @pulumi.getter(name="hostRedirect")
    def host_redirect(self) -> Optional[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")

    @property
    @pulumi.getter(name="httpsRedirect")
    def https_redirect(self) -> Optional[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. Defaults to false.
        """
        return pulumi.get(self, "https_redirect")

    @property
    @pulumi.getter(name="pathRedirect")
    def path_redirect(self) -> Optional[str]:
        """
        The path that will be used in the redirect response instead of the one that was
        supplied in the request. Only one of pathRedirect or prefixRedirect must be
        specified. The value must be between 1 and 1024 characters.
        """
        return pulumi.get(self, "path_redirect")

    @property
    @pulumi.getter(name="prefixRedirect")
    def prefix_redirect(self) -> Optional[str]:
        """
        The prefix that replaces the prefixMatch specified in the HttpRouteRuleMatch,
        retaining the remaining portion of the URL before redirecting the request.
        """
        return pulumi.get(self, "prefix_redirect")

    @property
    @pulumi.getter(name="redirectResponseCode")
    def redirect_response_code(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherRouteRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerAction":
            suggest = "header_action"
        elif key == "matchRules":
            suggest = "match_rules"
        elif key == "routeAction":
            suggest = "route_action"
        elif key == "urlRedirect":
            suggest = "url_redirect"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherRouteRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherRouteRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 priority: int,
                 header_action: Optional['outputs.URLMapPathMatcherRouteRuleHeaderAction'] = None,
                 match_rules: Optional[Sequence['outputs.URLMapPathMatcherRouteRuleMatchRule']] = None,
                 route_action: Optional['outputs.URLMapPathMatcherRouteRuleRouteAction'] = None,
                 service: Optional[str] = None,
                 url_redirect: Optional['outputs.URLMapPathMatcherRouteRuleUrlRedirect'] = None):
        """
        :param 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 'URLMapPathMatcherRouteRuleHeaderActionArgs' header_action: Specifies changes to request and response headers that need to take effect for
               the selected backendService. The headerAction specified here are applied before
               the matching pathMatchers[].headerAction and after pathMatchers[].routeRules[].r
               outeAction.weightedBackendService.backendServiceWeightAction[].headerAction
               Structure is documented below.
        :param Sequence['URLMapPathMatcherRouteRuleMatchRuleArgs'] match_rules: The rules for determining a match.
               Structure is documented below.
        :param '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 str service: The backend service resource to which traffic is
               directed if this rule is matched. If routeAction is additionally specified,
               advanced routing actions like URL Rewrites, etc. take effect prior to sending
               the request to the backend. However, if service is specified, routeAction cannot
               contain any weightedBackendService s. Conversely, if routeAction specifies any
               weightedBackendServices, service must not be specified. Only one of urlRedirect,
               service or routeAction.weightedBackendService must be set.
        :param '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) -> 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")

    @property
    @pulumi.getter(name="headerAction")
    def header_action(self) -> Optional['outputs.URLMapPathMatcherRouteRuleHeaderAction']:
        """
        Specifies changes to request and response headers that need to take effect for
        the selected backendService. The headerAction specified here are applied before
        the matching pathMatchers[].headerAction and after pathMatchers[].routeRules[].r
        outeAction.weightedBackendService.backendServiceWeightAction[].headerAction
        Structure is documented below.
        """
        return pulumi.get(self, "header_action")

    @property
    @pulumi.getter(name="matchRules")
    def match_rules(self) -> Optional[Sequence['outputs.URLMapPathMatcherRouteRuleMatchRule']]:
        """
        The rules for determining a match.
        Structure is documented below.
        """
        return pulumi.get(self, "match_rules")

    @property
    @pulumi.getter(name="routeAction")
    def route_action(self) -> Optional['outputs.URLMapPathMatcherRouteRuleRouteAction']:
        """
        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")

    @property
    @pulumi.getter
    def service(self) -> Optional[str]:
        """
        The backend service resource to which traffic is
        directed if this rule is matched. If routeAction is additionally specified,
        advanced routing actions like URL Rewrites, etc. take effect prior to sending
        the request to the backend. However, if service is specified, routeAction cannot
        contain any weightedBackendService s. Conversely, if routeAction specifies any
        weightedBackendServices, service must not be specified. Only one of urlRedirect,
        service or routeAction.weightedBackendService must be set.
        """
        return pulumi.get(self, "service")

    @property
    @pulumi.getter(name="urlRedirect")
    def url_redirect(self) -> Optional['outputs.URLMapPathMatcherRouteRuleUrlRedirect']:
        """
        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")


@pulumi.output_type
class URLMapPathMatcherRouteRuleHeaderAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "requestHeadersToAdds":
            suggest = "request_headers_to_adds"
        elif key == "requestHeadersToRemoves":
            suggest = "request_headers_to_removes"
        elif key == "responseHeadersToAdds":
            suggest = "response_headers_to_adds"
        elif key == "responseHeadersToRemoves":
            suggest = "response_headers_to_removes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleHeaderAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherRouteRuleHeaderAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherRouteRuleHeaderAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 request_headers_to_adds: Optional[Sequence['outputs.URLMapPathMatcherRouteRuleHeaderActionRequestHeadersToAdd']] = None,
                 request_headers_to_removes: Optional[Sequence[str]] = None,
                 response_headers_to_adds: Optional[Sequence['outputs.URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAdd']] = None,
                 response_headers_to_removes: Optional[Sequence[str]] = None):
        """
        :param Sequence['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 Sequence[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 Sequence['URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs'] response_headers_to_adds: Headers to add the response prior to sending the response back to the client.
               Structure is documented below.
        :param Sequence[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[Sequence['outputs.URLMapPathMatcherRouteRuleHeaderActionRequestHeadersToAdd']]:
        """
        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")

    @property
    @pulumi.getter(name="requestHeadersToRemoves")
    def request_headers_to_removes(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter(name="responseHeadersToAdds")
    def response_headers_to_adds(self) -> Optional[Sequence['outputs.URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAdd']]:
        """
        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")

    @property
    @pulumi.getter(name="responseHeadersToRemoves")
    def response_headers_to_removes(self) -> Optional[Sequence[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")


@pulumi.output_type
class URLMapPathMatcherRouteRuleHeaderActionRequestHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleHeaderActionRequestHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherRouteRuleHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherRouteRuleHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: str,
                 header_value: str,
                 replace: bool):
        """
        :param str header_name: The name of the header to add.
        :param str header_value: The value of the header to add.
        :param 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) -> str:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> str:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @property
    @pulumi.getter
    def replace(self) -> 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")


@pulumi.output_type
class URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: str,
                 header_value: str,
                 replace: bool):
        """
        :param str header_name: The name of the header to add.
        :param str header_value: The value of the header to add.
        :param 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) -> str:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> str:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @property
    @pulumi.getter
    def replace(self) -> 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")


@pulumi.output_type
class URLMapPathMatcherRouteRuleMatchRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fullPathMatch":
            suggest = "full_path_match"
        elif key == "headerMatches":
            suggest = "header_matches"
        elif key == "ignoreCase":
            suggest = "ignore_case"
        elif key == "metadataFilters":
            suggest = "metadata_filters"
        elif key == "prefixMatch":
            suggest = "prefix_match"
        elif key == "queryParameterMatches":
            suggest = "query_parameter_matches"
        elif key == "regexMatch":
            suggest = "regex_match"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleMatchRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherRouteRuleMatchRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherRouteRuleMatchRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 full_path_match: Optional[str] = None,
                 header_matches: Optional[Sequence['outputs.URLMapPathMatcherRouteRuleMatchRuleHeaderMatch']] = None,
                 ignore_case: Optional[bool] = None,
                 metadata_filters: Optional[Sequence['outputs.URLMapPathMatcherRouteRuleMatchRuleMetadataFilter']] = None,
                 prefix_match: Optional[str] = None,
                 query_parameter_matches: Optional[Sequence['outputs.URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatch']] = None,
                 regex_match: Optional[str] = None):
        """
        :param 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 Sequence['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 bool ignore_case: Specifies that prefixMatch and fullPathMatch matches are case sensitive.
               Defaults to false.
        :param Sequence['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 str prefix_match: For satisfying the matchRule condition, the request's path must begin with the
               specified prefixMatch. prefixMatch must begin with a /. The value must be
               between 1 and 1024 characters. Only one of prefixMatch, fullPathMatch or
               regexMatch must be specified.
        :param Sequence['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 str regex_match: For satisfying the matchRule condition, the path of the request must satisfy the
               regular expression specified in regexMatch after removing any query parameters
               and anchor supplied with the original URL. For regular expression grammar please
               see en.cppreference.com/w/cpp/regex/ecmascript  Only one of prefixMatch,
               fullPathMatch or regexMatch must be specified.
        """
        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[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")

    @property
    @pulumi.getter(name="headerMatches")
    def header_matches(self) -> Optional[Sequence['outputs.URLMapPathMatcherRouteRuleMatchRuleHeaderMatch']]:
        """
        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")

    @property
    @pulumi.getter(name="ignoreCase")
    def ignore_case(self) -> Optional[bool]:
        """
        Specifies that prefixMatch and fullPathMatch matches are case sensitive.
        Defaults to false.
        """
        return pulumi.get(self, "ignore_case")

    @property
    @pulumi.getter(name="metadataFilters")
    def metadata_filters(self) -> Optional[Sequence['outputs.URLMapPathMatcherRouteRuleMatchRuleMetadataFilter']]:
        """
        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")

    @property
    @pulumi.getter(name="prefixMatch")
    def prefix_match(self) -> Optional[str]:
        """
        For satisfying the matchRule condition, the request's path must begin with the
        specified prefixMatch. prefixMatch must begin with a /. The value must be
        between 1 and 1024 characters. Only one of prefixMatch, fullPathMatch or
        regexMatch must be specified.
        """
        return pulumi.get(self, "prefix_match")

    @property
    @pulumi.getter(name="queryParameterMatches")
    def query_parameter_matches(self) -> Optional[Sequence['outputs.URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatch']]:
        """
        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")

    @property
    @pulumi.getter(name="regexMatch")
    def regex_match(self) -> Optional[str]:
        """
        For satisfying the matchRule condition, the path of the request must satisfy the
        regular expression specified in regexMatch after removing any query parameters
        and anchor supplied with the original URL. For regular expression grammar please
        see en.cppreference.com/w/cpp/regex/ecmascript  Only one of prefixMatch,
        fullPathMatch or regexMatch must be specified.
        """
        return pulumi.get(self, "regex_match")


@pulumi.output_type
class URLMapPathMatcherRouteRuleMatchRuleHeaderMatch(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "exactMatch":
            suggest = "exact_match"
        elif key == "invertMatch":
            suggest = "invert_match"
        elif key == "prefixMatch":
            suggest = "prefix_match"
        elif key == "presentMatch":
            suggest = "present_match"
        elif key == "rangeMatch":
            suggest = "range_match"
        elif key == "regexMatch":
            suggest = "regex_match"
        elif key == "suffixMatch":
            suggest = "suffix_match"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleMatchRuleHeaderMatch. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherRouteRuleMatchRuleHeaderMatch.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherRouteRuleMatchRuleHeaderMatch.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: str,
                 exact_match: Optional[str] = None,
                 invert_match: Optional[bool] = None,
                 prefix_match: Optional[str] = None,
                 present_match: Optional[bool] = None,
                 range_match: Optional['outputs.URLMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatch'] = None,
                 regex_match: Optional[str] = None,
                 suffix_match: Optional[str] = None):
        """
        :param str header_name: The name of the HTTP header to match. For matching against the HTTP request's
               authority, use a headerMatch with the header name ":authority". For matching a
               request's method, use the headerName ":method".
        :param str exact_match: The value should exactly match contents of exactMatch. Only one of exactMatch,
               prefixMatch, suffixMatch, regexMatch, presentMatch or rangeMatch must be set.
        :param 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 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 bool present_match: A header with the contents of headerName must exist. The match takes place
               whether or not the request's header has a value or not. Only one of exactMatch,
               prefixMatch, suffixMatch, regexMatch, presentMatch or rangeMatch must be set.
        :param '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 str regex_match: The value of the header must match the regular expression specified in
               regexMatch. For regular expression grammar, please see:
               en.cppreference.com/w/cpp/regex/ecmascript  For matching against a port
               specified in the HTTP request, use a headerMatch with headerName set to PORT and
               a regular expression that satisfies the RFC2616 Host header's port specifier.
               Only one of exactMatch, prefixMatch, suffixMatch, regexMatch, presentMatch or
               rangeMatch must be set.
        :param 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) -> str:
        """
        The name of the HTTP header to match. For matching against the HTTP request's
        authority, use a headerMatch with the header name ":authority". For matching a
        request's method, use the headerName ":method".
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="exactMatch")
    def exact_match(self) -> Optional[str]:
        """
        The value should exactly match contents of exactMatch. Only one of exactMatch,
        prefixMatch, suffixMatch, regexMatch, presentMatch or rangeMatch must be set.
        """
        return pulumi.get(self, "exact_match")

    @property
    @pulumi.getter(name="invertMatch")
    def invert_match(self) -> Optional[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")

    @property
    @pulumi.getter(name="prefixMatch")
    def prefix_match(self) -> Optional[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")

    @property
    @pulumi.getter(name="presentMatch")
    def present_match(self) -> Optional[bool]:
        """
        A header with the contents of headerName must exist. The match takes place
        whether or not the request's header has a value or not. Only one of exactMatch,
        prefixMatch, suffixMatch, regexMatch, presentMatch or rangeMatch must be set.
        """
        return pulumi.get(self, "present_match")

    @property
    @pulumi.getter(name="rangeMatch")
    def range_match(self) -> Optional['outputs.URLMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatch']:
        """
        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")

    @property
    @pulumi.getter(name="regexMatch")
    def regex_match(self) -> Optional[str]:
        """
        The value of the header must match the regular expression specified in
        regexMatch. For regular expression grammar, please see:
        en.cppreference.com/w/cpp/regex/ecmascript  For matching against a port
        specified in the HTTP request, use a headerMatch with headerName set to PORT and
        a regular expression that satisfies the RFC2616 Host header's port specifier.
        Only one of exactMatch, prefixMatch, suffixMatch, regexMatch, presentMatch or
        rangeMatch must be set.
        """
        return pulumi.get(self, "regex_match")

    @property
    @pulumi.getter(name="suffixMatch")
    def suffix_match(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatch(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "rangeEnd":
            suggest = "range_end"
        elif key == "rangeStart":
            suggest = "range_start"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatch. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatch.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatch.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 range_end: int,
                 range_start: int):
        """
        :param int range_end: The end of the range (exclusive).
        :param 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) -> int:
        """
        The end of the range (exclusive).
        """
        return pulumi.get(self, "range_end")

    @property
    @pulumi.getter(name="rangeStart")
    def range_start(self) -> int:
        """
        The start of the range (inclusive).
        """
        return pulumi.get(self, "range_start")


@pulumi.output_type
class URLMapPathMatcherRouteRuleMatchRuleMetadataFilter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "filterLabels":
            suggest = "filter_labels"
        elif key == "filterMatchCriteria":
            suggest = "filter_match_criteria"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleMatchRuleMetadataFilter. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherRouteRuleMatchRuleMetadataFilter.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherRouteRuleMatchRuleMetadataFilter.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 filter_labels: Sequence['outputs.URLMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabel'],
                 filter_match_criteria: str):
        """
        :param Sequence['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 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) -> Sequence['outputs.URLMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabel']:
        """
        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")

    @property
    @pulumi.getter(name="filterMatchCriteria")
    def filter_match_criteria(self) -> 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")


@pulumi.output_type
class URLMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabel(dict):
    def __init__(__self__, *,
                 name: str,
                 value: str):
        """
        :param str name: Name of metadata label. The name can have a maximum length of 1024 characters
               and must be at least 1 character long.
        :param 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) -> str:
        """
        Name of metadata label. The name can have a maximum length of 1024 characters
        and must be at least 1 character long.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> 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")


@pulumi.output_type
class URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatch(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "exactMatch":
            suggest = "exact_match"
        elif key == "presentMatch":
            suggest = "present_match"
        elif key == "regexMatch":
            suggest = "regex_match"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatch. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatch.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatch.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 exact_match: Optional[str] = None,
                 present_match: Optional[bool] = None,
                 regex_match: Optional[str] = None):
        """
        :param 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 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 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 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) -> 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")

    @property
    @pulumi.getter(name="exactMatch")
    def exact_match(self) -> Optional[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")

    @property
    @pulumi.getter(name="presentMatch")
    def present_match(self) -> Optional[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")

    @property
    @pulumi.getter(name="regexMatch")
    def regex_match(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherRouteRuleRouteAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "corsPolicy":
            suggest = "cors_policy"
        elif key == "faultInjectionPolicy":
            suggest = "fault_injection_policy"
        elif key == "requestMirrorPolicy":
            suggest = "request_mirror_policy"
        elif key == "retryPolicy":
            suggest = "retry_policy"
        elif key == "urlRewrite":
            suggest = "url_rewrite"
        elif key == "weightedBackendServices":
            suggest = "weighted_backend_services"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleRouteAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherRouteRuleRouteAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherRouteRuleRouteAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cors_policy: Optional['outputs.URLMapPathMatcherRouteRuleRouteActionCorsPolicy'] = None,
                 fault_injection_policy: Optional['outputs.URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicy'] = None,
                 request_mirror_policy: Optional['outputs.URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicy'] = None,
                 retry_policy: Optional['outputs.URLMapPathMatcherRouteRuleRouteActionRetryPolicy'] = None,
                 timeout: Optional['outputs.URLMapPathMatcherRouteRuleRouteActionTimeout'] = None,
                 url_rewrite: Optional['outputs.URLMapPathMatcherRouteRuleRouteActionUrlRewrite'] = None,
                 weighted_backend_services: Optional[Sequence['outputs.URLMapPathMatcherRouteRuleRouteActionWeightedBackendService']] = None):
        """
        :param 'URLMapPathMatcherRouteRuleRouteActionCorsPolicyArgs' 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 '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 retry_policy will be
               ignored by clients that are configured with a fault_injection_policy.
               Structure is documented below.
        :param '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 'URLMapPathMatcherRouteRuleRouteActionRetryPolicyArgs' retry_policy: Specifies the retry policy associated with this route.
               Structure is documented below.
        :param 'URLMapPathMatcherRouteRuleRouteActionTimeoutArgs' 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 '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 Sequence['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['outputs.URLMapPathMatcherRouteRuleRouteActionCorsPolicy']:
        """
        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")

    @property
    @pulumi.getter(name="faultInjectionPolicy")
    def fault_injection_policy(self) -> Optional['outputs.URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicy']:
        """
        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")

    @property
    @pulumi.getter(name="requestMirrorPolicy")
    def request_mirror_policy(self) -> Optional['outputs.URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicy']:
        """
        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")

    @property
    @pulumi.getter(name="retryPolicy")
    def retry_policy(self) -> Optional['outputs.URLMapPathMatcherRouteRuleRouteActionRetryPolicy']:
        """
        Specifies the retry policy associated with this route.
        Structure is documented below.
        """
        return pulumi.get(self, "retry_policy")

    @property
    @pulumi.getter
    def timeout(self) -> Optional['outputs.URLMapPathMatcherRouteRuleRouteActionTimeout']:
        """
        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")

    @property
    @pulumi.getter(name="urlRewrite")
    def url_rewrite(self) -> Optional['outputs.URLMapPathMatcherRouteRuleRouteActionUrlRewrite']:
        """
        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")

    @property
    @pulumi.getter(name="weightedBackendServices")
    def weighted_backend_services(self) -> Optional[Sequence['outputs.URLMapPathMatcherRouteRuleRouteActionWeightedBackendService']]:
        """
        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")


@pulumi.output_type
class URLMapPathMatcherRouteRuleRouteActionCorsPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowCredentials":
            suggest = "allow_credentials"
        elif key == "allowHeaders":
            suggest = "allow_headers"
        elif key == "allowMethods":
            suggest = "allow_methods"
        elif key == "allowOriginRegexes":
            suggest = "allow_origin_regexes"
        elif key == "allowOrigins":
            suggest = "allow_origins"
        elif key == "exposeHeaders":
            suggest = "expose_headers"
        elif key == "maxAge":
            suggest = "max_age"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleRouteActionCorsPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherRouteRuleRouteActionCorsPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherRouteRuleRouteActionCorsPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 allow_credentials: Optional[bool] = None,
                 allow_headers: Optional[Sequence[str]] = None,
                 allow_methods: Optional[Sequence[str]] = None,
                 allow_origin_regexes: Optional[Sequence[str]] = None,
                 allow_origins: Optional[Sequence[str]] = None,
                 disabled: Optional[bool] = None,
                 expose_headers: Optional[Sequence[str]] = None,
                 max_age: Optional[int] = None):
        """
        :param 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 Sequence[str] allow_headers: Specifies the content for the Access-Control-Allow-Headers header.
        :param Sequence[str] allow_methods: Specifies the content for the Access-Control-Allow-Methods header.
        :param Sequence[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 Sequence[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 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 Sequence[str] expose_headers: Specifies the content for the Access-Control-Expose-Headers header.
        :param 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[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")

    @property
    @pulumi.getter(name="allowHeaders")
    def allow_headers(self) -> Optional[Sequence[str]]:
        """
        Specifies the content for the Access-Control-Allow-Headers header.
        """
        return pulumi.get(self, "allow_headers")

    @property
    @pulumi.getter(name="allowMethods")
    def allow_methods(self) -> Optional[Sequence[str]]:
        """
        Specifies the content for the Access-Control-Allow-Methods header.
        """
        return pulumi.get(self, "allow_methods")

    @property
    @pulumi.getter(name="allowOriginRegexes")
    def allow_origin_regexes(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter(name="allowOrigins")
    def allow_origins(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter
    def disabled(self) -> Optional[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")

    @property
    @pulumi.getter(name="exposeHeaders")
    def expose_headers(self) -> Optional[Sequence[str]]:
        """
        Specifies the content for the Access-Control-Expose-Headers header.
        """
        return pulumi.get(self, "expose_headers")

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicy(dict):
    def __init__(__self__, *,
                 abort: Optional['outputs.URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbort'] = None,
                 delay: Optional['outputs.URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelay'] = None):
        """
        :param 'URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbortArgs' abort: The specification for how client requests are aborted as part of fault injection.
               Structure is documented below.
        :param '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['outputs.URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbort']:
        """
        The specification for how client requests are aborted as part of fault injection.
        Structure is documented below.
        """
        return pulumi.get(self, "abort")

    @property
    @pulumi.getter
    def delay(self) -> Optional['outputs.URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelay']:
        """
        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")


@pulumi.output_type
class URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbort(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "httpStatus":
            suggest = "http_status"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbort. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbort.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbort.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 http_status: Optional[int] = None,
                 percentage: Optional[float] = None):
        """
        :param int http_status: The HTTP status code used to abort the request.
               The value must be between 200 and 599 inclusive.
        :param 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[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")

    @property
    @pulumi.getter
    def percentage(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelay(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fixedDelay":
            suggest = "fixed_delay"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelay. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelay.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelay.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 fixed_delay: Optional['outputs.URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelay'] = None,
                 percentage: Optional[float] = None):
        """
        :param 'URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs' fixed_delay: Specifies the value of the fixed delay interval.
               Structure is documented below.
        :param 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['outputs.URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelay']:
        """
        Specifies the value of the fixed delay interval.
        Structure is documented below.
        """
        return pulumi.get(self, "fixed_delay")

    @property
    @pulumi.getter
    def percentage(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelay(dict):
    def __init__(__self__, *,
                 seconds: str,
                 nanos: Optional[int] = None):
        """
        :param 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 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) -> 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")

    @property
    @pulumi.getter
    def nanos(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backendService":
            suggest = "backend_service"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 backend_service: str):
        """
        :param 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) -> str:
        """
        The full or partial URL to the BackendService resource being mirrored to.
        """
        return pulumi.get(self, "backend_service")


@pulumi.output_type
class URLMapPathMatcherRouteRuleRouteActionRetryPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "numRetries":
            suggest = "num_retries"
        elif key == "perTryTimeout":
            suggest = "per_try_timeout"
        elif key == "retryConditions":
            suggest = "retry_conditions"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleRouteActionRetryPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherRouteRuleRouteActionRetryPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherRouteRuleRouteActionRetryPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 num_retries: int,
                 per_try_timeout: Optional['outputs.URLMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeout'] = None,
                 retry_conditions: Optional[Sequence[str]] = None):
        """
        :param int num_retries: Specifies the allowed number retries. This number must be > 0. If not specified, defaults to 1.
        :param '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 Sequence[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) -> int:
        """
        Specifies the allowed number retries. This number must be > 0. If not specified, defaults to 1.
        """
        return pulumi.get(self, "num_retries")

    @property
    @pulumi.getter(name="perTryTimeout")
    def per_try_timeout(self) -> Optional['outputs.URLMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeout']:
        """
        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")

    @property
    @pulumi.getter(name="retryConditions")
    def retry_conditions(self) -> Optional[Sequence[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")


@pulumi.output_type
class URLMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeout(dict):
    def __init__(__self__, *,
                 seconds: str,
                 nanos: Optional[int] = None):
        """
        :param 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 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) -> 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")

    @property
    @pulumi.getter
    def nanos(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherRouteRuleRouteActionTimeout(dict):
    def __init__(__self__, *,
                 seconds: str,
                 nanos: Optional[int] = None):
        """
        :param 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 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) -> 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")

    @property
    @pulumi.getter
    def nanos(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherRouteRuleRouteActionUrlRewrite(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hostRewrite":
            suggest = "host_rewrite"
        elif key == "pathPrefixRewrite":
            suggest = "path_prefix_rewrite"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleRouteActionUrlRewrite. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherRouteRuleRouteActionUrlRewrite.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherRouteRuleRouteActionUrlRewrite.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 host_rewrite: Optional[str] = None,
                 path_prefix_rewrite: Optional[str] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter(name="pathPrefixRewrite")
    def path_prefix_rewrite(self) -> Optional[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")


@pulumi.output_type
class URLMapPathMatcherRouteRuleRouteActionWeightedBackendService(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backendService":
            suggest = "backend_service"
        elif key == "headerAction":
            suggest = "header_action"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleRouteActionWeightedBackendService. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherRouteRuleRouteActionWeightedBackendService.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherRouteRuleRouteActionWeightedBackendService.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 backend_service: str,
                 weight: int,
                 header_action: Optional['outputs.URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderAction'] = None):
        """
        :param str backend_service: The full or partial URL to the default BackendService resource. Before forwarding the
               request to backendService, the loadbalancer applies any relevant headerActions
               specified as part of this backendServiceWeight.
        :param 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 '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) -> str:
        """
        The full or partial URL to the default BackendService 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")

    @property
    @pulumi.getter
    def weight(self) -> 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")

    @property
    @pulumi.getter(name="headerAction")
    def header_action(self) -> Optional['outputs.URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderAction']:
        """
        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")


@pulumi.output_type
class URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "requestHeadersToAdds":
            suggest = "request_headers_to_adds"
        elif key == "requestHeadersToRemoves":
            suggest = "request_headers_to_removes"
        elif key == "responseHeadersToAdds":
            suggest = "response_headers_to_adds"
        elif key == "responseHeadersToRemoves":
            suggest = "response_headers_to_removes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 request_headers_to_adds: Optional[Sequence['outputs.URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd']] = None,
                 request_headers_to_removes: Optional[Sequence[str]] = None,
                 response_headers_to_adds: Optional[Sequence['outputs.URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd']] = None,
                 response_headers_to_removes: Optional[Sequence[str]] = None):
        """
        :param Sequence['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 Sequence[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 Sequence['URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs'] response_headers_to_adds: Headers to add the response prior to sending the response back to the client.
               Structure is documented below.
        :param Sequence[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[Sequence['outputs.URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd']]:
        """
        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")

    @property
    @pulumi.getter(name="requestHeadersToRemoves")
    def request_headers_to_removes(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter(name="responseHeadersToAdds")
    def response_headers_to_adds(self) -> Optional[Sequence['outputs.URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd']]:
        """
        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")

    @property
    @pulumi.getter(name="responseHeadersToRemoves")
    def response_headers_to_removes(self) -> Optional[Sequence[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")


@pulumi.output_type
class URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: str,
                 header_value: str,
                 replace: bool):
        """
        :param str header_name: The name of the header to add.
        :param str header_value: The value of the header to add.
        :param 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) -> str:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> str:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @property
    @pulumi.getter
    def replace(self) -> 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")


@pulumi.output_type
class URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: str,
                 header_value: str,
                 replace: bool):
        """
        :param str header_name: The name of the header to add.
        :param str header_value: The value of the header to add.
        :param 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) -> str:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> str:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @property
    @pulumi.getter
    def replace(self) -> 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")


@pulumi.output_type
class URLMapPathMatcherRouteRuleUrlRedirect(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hostRedirect":
            suggest = "host_redirect"
        elif key == "httpsRedirect":
            suggest = "https_redirect"
        elif key == "pathRedirect":
            suggest = "path_redirect"
        elif key == "prefixRedirect":
            suggest = "prefix_redirect"
        elif key == "redirectResponseCode":
            suggest = "redirect_response_code"
        elif key == "stripQuery":
            suggest = "strip_query"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleUrlRedirect. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        URLMapPathMatcherRouteRuleUrlRedirect.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        URLMapPathMatcherRouteRuleUrlRedirect.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 host_redirect: Optional[str] = None,
                 https_redirect: Optional[bool] = None,
                 path_redirect: Optional[str] = None,
                 prefix_redirect: Optional[str] = None,
                 redirect_response_code: Optional[str] = None,
                 strip_query: Optional[bool] = None):
        """
        :param 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 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. Defaults to false.
        :param str path_redirect: The path that will be used in the redirect response instead of the one that was
               supplied in the request. Only one of pathRedirect or prefixRedirect must be
               specified. The value must be between 1 and 1024 characters.
        :param str prefix_redirect: The prefix that replaces the prefixMatch specified in the HttpRouteRuleMatch,
               retaining the remaining portion of the URL before redirecting the request.
        :param 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 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. Defaults to 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[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")

    @property
    @pulumi.getter(name="httpsRedirect")
    def https_redirect(self) -> Optional[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. Defaults to false.
        """
        return pulumi.get(self, "https_redirect")

    @property
    @pulumi.getter(name="pathRedirect")
    def path_redirect(self) -> Optional[str]:
        """
        The path that will be used in the redirect response instead of the one that was
        supplied in the request. Only one of pathRedirect or prefixRedirect must be
        specified. The value must be between 1 and 1024 characters.
        """
        return pulumi.get(self, "path_redirect")

    @property
    @pulumi.getter(name="prefixRedirect")
    def prefix_redirect(self) -> Optional[str]:
        """
        The prefix that replaces the prefixMatch specified in the HttpRouteRuleMatch,
        retaining the remaining portion of the URL before redirecting the request.
        """
        return pulumi.get(self, "prefix_redirect")

    @property
    @pulumi.getter(name="redirectResponseCode")
    def redirect_response_code(self) -> Optional[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")

    @property
    @pulumi.getter(name="stripQuery")
    def strip_query(self) -> Optional[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. Defaults to false.
        """
        return pulumi.get(self, "strip_query")


@pulumi.output_type
class URLMapTest(dict):
    def __init__(__self__, *,
                 host: str,
                 path: str,
                 service: str,
                 description: Optional[str] = None):
        """
        :param str host: Host portion of the URL.
        :param str path: Path portion of the URL.
        :param str service: The backend service or backend bucket link that should be matched by this test.
        :param 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) -> str:
        """
        Host portion of the URL.
        """
        return pulumi.get(self, "host")

    @property
    @pulumi.getter
    def path(self) -> str:
        """
        Path portion of the URL.
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def service(self) -> str:
        """
        The backend service or backend bucket link that should be matched by this test.
        """
        return pulumi.get(self, "service")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        Description of this test case.
        """
        return pulumi.get(self, "description")


@pulumi.output_type
class GetAddressesAddressResult(dict):
    def __init__(__self__, *,
                 address: str,
                 address_type: str,
                 description: str,
                 labels: Mapping[str, str],
                 name: str,
                 region: str,
                 self_link: str,
                 status: str):
        """
        :param str address: The IP address (for example `1.2.3.4`).
        :param str address_type: The IP address type, can be `EXTERNAL` or `INTERNAL`.
        :param str description: The IP address description.
        :param Mapping[str, str] labels: (Beta only) A map containing IP labels.
        :param str name: The IP address name.
        :param str region: Region that should be considered to search addresses.
               All regions are considered if missing.
        :param str self_link: The URI of the created resource.
        :param str status: Indicates if the address is used. Possible values are: RESERVED or IN_USE.
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "address_type", address_type)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "self_link", self_link)
        pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter
    def address(self) -> str:
        """
        The IP address (for example `1.2.3.4`).
        """
        return pulumi.get(self, "address")

    @property
    @pulumi.getter(name="addressType")
    def address_type(self) -> str:
        """
        The IP address type, can be `EXTERNAL` or `INTERNAL`.
        """
        return pulumi.get(self, "address_type")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        The IP address description.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def labels(self) -> Mapping[str, str]:
        """
        (Beta only) A map containing IP labels.
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The IP address name.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        Region that should be considered to search addresses.
        All regions are considered if missing.
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="selfLink")
    def self_link(self) -> str:
        """
        The URI of the created resource.
        """
        return pulumi.get(self, "self_link")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        Indicates if the address is used. Possible values are: RESERVED or IN_USE.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetBackendBucketCdnPolicyResult(dict):
    def __init__(__self__, *,
                 bypass_cache_on_request_headers: Sequence['outputs.GetBackendBucketCdnPolicyBypassCacheOnRequestHeaderResult'],
                 cache_key_policies: Sequence['outputs.GetBackendBucketCdnPolicyCacheKeyPolicyResult'],
                 cache_mode: str,
                 client_ttl: int,
                 default_ttl: int,
                 max_ttl: int,
                 negative_caching: bool,
                 negative_caching_policies: Sequence['outputs.GetBackendBucketCdnPolicyNegativeCachingPolicyResult'],
                 request_coalescing: bool,
                 serve_while_stale: int,
                 signed_url_cache_max_age_sec: int):
        pulumi.set(__self__, "bypass_cache_on_request_headers", bypass_cache_on_request_headers)
        pulumi.set(__self__, "cache_key_policies", cache_key_policies)
        pulumi.set(__self__, "cache_mode", cache_mode)
        pulumi.set(__self__, "client_ttl", client_ttl)
        pulumi.set(__self__, "default_ttl", default_ttl)
        pulumi.set(__self__, "max_ttl", max_ttl)
        pulumi.set(__self__, "negative_caching", negative_caching)
        pulumi.set(__self__, "negative_caching_policies", negative_caching_policies)
        pulumi.set(__self__, "request_coalescing", request_coalescing)
        pulumi.set(__self__, "serve_while_stale", serve_while_stale)
        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) -> Sequence['outputs.GetBackendBucketCdnPolicyBypassCacheOnRequestHeaderResult']:
        return pulumi.get(self, "bypass_cache_on_request_headers")

    @property
    @pulumi.getter(name="cacheKeyPolicies")
    def cache_key_policies(self) -> Sequence['outputs.GetBackendBucketCdnPolicyCacheKeyPolicyResult']:
        return pulumi.get(self, "cache_key_policies")

    @property
    @pulumi.getter(name="cacheMode")
    def cache_mode(self) -> str:
        return pulumi.get(self, "cache_mode")

    @property
    @pulumi.getter(name="clientTtl")
    def client_ttl(self) -> int:
        return pulumi.get(self, "client_ttl")

    @property
    @pulumi.getter(name="defaultTtl")
    def default_ttl(self) -> int:
        return pulumi.get(self, "default_ttl")

    @property
    @pulumi.getter(name="maxTtl")
    def max_ttl(self) -> int:
        return pulumi.get(self, "max_ttl")

    @property
    @pulumi.getter(name="negativeCaching")
    def negative_caching(self) -> bool:
        return pulumi.get(self, "negative_caching")

    @property
    @pulumi.getter(name="negativeCachingPolicies")
    def negative_caching_policies(self) -> Sequence['outputs.GetBackendBucketCdnPolicyNegativeCachingPolicyResult']:
        return pulumi.get(self, "negative_caching_policies")

    @property
    @pulumi.getter(name="requestCoalescing")
    def request_coalescing(self) -> bool:
        return pulumi.get(self, "request_coalescing")

    @property
    @pulumi.getter(name="serveWhileStale")
    def serve_while_stale(self) -> int:
        return pulumi.get(self, "serve_while_stale")

    @property
    @pulumi.getter(name="signedUrlCacheMaxAgeSec")
    def signed_url_cache_max_age_sec(self) -> int:
        return pulumi.get(self, "signed_url_cache_max_age_sec")


@pulumi.output_type
class GetBackendBucketCdnPolicyBypassCacheOnRequestHeaderResult(dict):
    def __init__(__self__, *,
                 header_name: str):
        pulumi.set(__self__, "header_name", header_name)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> str:
        return pulumi.get(self, "header_name")


@pulumi.output_type
class GetBackendBucketCdnPolicyCacheKeyPolicyResult(dict):
    def __init__(__self__, *,
                 include_http_headers: Sequence[str],
                 query_string_whitelists: Sequence[str]):
        pulumi.set(__self__, "include_http_headers", include_http_headers)
        pulumi.set(__self__, "query_string_whitelists", query_string_whitelists)

    @property
    @pulumi.getter(name="includeHttpHeaders")
    def include_http_headers(self) -> Sequence[str]:
        return pulumi.get(self, "include_http_headers")

    @property
    @pulumi.getter(name="queryStringWhitelists")
    def query_string_whitelists(self) -> Sequence[str]:
        return pulumi.get(self, "query_string_whitelists")


@pulumi.output_type
class GetBackendBucketCdnPolicyNegativeCachingPolicyResult(dict):
    def __init__(__self__, *,
                 code: int,
                 ttl: int):
        pulumi.set(__self__, "code", code)
        pulumi.set(__self__, "ttl", ttl)

    @property
    @pulumi.getter
    def code(self) -> int:
        return pulumi.get(self, "code")

    @property
    @pulumi.getter
    def ttl(self) -> int:
        return pulumi.get(self, "ttl")


@pulumi.output_type
class GetBackendServiceBackendResult(dict):
    def __init__(__self__, *,
                 balancing_mode: str,
                 capacity_scaler: float,
                 description: str,
                 group: str,
                 max_connections: int,
                 max_connections_per_endpoint: int,
                 max_connections_per_instance: int,
                 max_rate: int,
                 max_rate_per_endpoint: float,
                 max_rate_per_instance: float,
                 max_utilization: float):
        """
        :param str description: Textual description for the Backend Service.
        """
        pulumi.set(__self__, "balancing_mode", balancing_mode)
        pulumi.set(__self__, "capacity_scaler", capacity_scaler)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "group", group)
        pulumi.set(__self__, "max_connections", max_connections)
        pulumi.set(__self__, "max_connections_per_endpoint", max_connections_per_endpoint)
        pulumi.set(__self__, "max_connections_per_instance", max_connections_per_instance)
        pulumi.set(__self__, "max_rate", max_rate)
        pulumi.set(__self__, "max_rate_per_endpoint", max_rate_per_endpoint)
        pulumi.set(__self__, "max_rate_per_instance", max_rate_per_instance)
        pulumi.set(__self__, "max_utilization", max_utilization)

    @property
    @pulumi.getter(name="balancingMode")
    def balancing_mode(self) -> str:
        return pulumi.get(self, "balancing_mode")

    @property
    @pulumi.getter(name="capacityScaler")
    def capacity_scaler(self) -> float:
        return pulumi.get(self, "capacity_scaler")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        Textual description for the Backend Service.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def group(self) -> str:
        return pulumi.get(self, "group")

    @property
    @pulumi.getter(name="maxConnections")
    def max_connections(self) -> int:
        return pulumi.get(self, "max_connections")

    @property
    @pulumi.getter(name="maxConnectionsPerEndpoint")
    def max_connections_per_endpoint(self) -> int:
        return pulumi.get(self, "max_connections_per_endpoint")

    @property
    @pulumi.getter(name="maxConnectionsPerInstance")
    def max_connections_per_instance(self) -> int:
        return pulumi.get(self, "max_connections_per_instance")

    @property
    @pulumi.getter(name="maxRate")
    def max_rate(self) -> int:
        return pulumi.get(self, "max_rate")

    @property
    @pulumi.getter(name="maxRatePerEndpoint")
    def max_rate_per_endpoint(self) -> float:
        return pulumi.get(self, "max_rate_per_endpoint")

    @property
    @pulumi.getter(name="maxRatePerInstance")
    def max_rate_per_instance(self) -> float:
        return pulumi.get(self, "max_rate_per_instance")

    @property
    @pulumi.getter(name="maxUtilization")
    def max_utilization(self) -> float:
        return pulumi.get(self, "max_utilization")


@pulumi.output_type
class GetBackendServiceCdnPolicyResult(dict):
    def __init__(__self__, *,
                 cache_key_policies: Sequence['outputs.GetBackendServiceCdnPolicyCacheKeyPolicyResult'],
                 cache_mode: str,
                 client_ttl: int,
                 default_ttl: int,
                 max_ttl: int,
                 negative_caching: bool,
                 negative_caching_policies: Sequence['outputs.GetBackendServiceCdnPolicyNegativeCachingPolicyResult'],
                 serve_while_stale: int,
                 signed_url_cache_max_age_sec: int):
        pulumi.set(__self__, "cache_key_policies", cache_key_policies)
        pulumi.set(__self__, "cache_mode", cache_mode)
        pulumi.set(__self__, "client_ttl", client_ttl)
        pulumi.set(__self__, "default_ttl", default_ttl)
        pulumi.set(__self__, "max_ttl", max_ttl)
        pulumi.set(__self__, "negative_caching", negative_caching)
        pulumi.set(__self__, "negative_caching_policies", negative_caching_policies)
        pulumi.set(__self__, "serve_while_stale", serve_while_stale)
        pulumi.set(__self__, "signed_url_cache_max_age_sec", signed_url_cache_max_age_sec)

    @property
    @pulumi.getter(name="cacheKeyPolicies")
    def cache_key_policies(self) -> Sequence['outputs.GetBackendServiceCdnPolicyCacheKeyPolicyResult']:
        return pulumi.get(self, "cache_key_policies")

    @property
    @pulumi.getter(name="cacheMode")
    def cache_mode(self) -> str:
        return pulumi.get(self, "cache_mode")

    @property
    @pulumi.getter(name="clientTtl")
    def client_ttl(self) -> int:
        return pulumi.get(self, "client_ttl")

    @property
    @pulumi.getter(name="defaultTtl")
    def default_ttl(self) -> int:
        return pulumi.get(self, "default_ttl")

    @property
    @pulumi.getter(name="maxTtl")
    def max_ttl(self) -> int:
        return pulumi.get(self, "max_ttl")

    @property
    @pulumi.getter(name="negativeCaching")
    def negative_caching(self) -> bool:
        return pulumi.get(self, "negative_caching")

    @property
    @pulumi.getter(name="negativeCachingPolicies")
    def negative_caching_policies(self) -> Sequence['outputs.GetBackendServiceCdnPolicyNegativeCachingPolicyResult']:
        return pulumi.get(self, "negative_caching_policies")

    @property
    @pulumi.getter(name="serveWhileStale")
    def serve_while_stale(self) -> int:
        return pulumi.get(self, "serve_while_stale")

    @property
    @pulumi.getter(name="signedUrlCacheMaxAgeSec")
    def signed_url_cache_max_age_sec(self) -> int:
        return pulumi.get(self, "signed_url_cache_max_age_sec")


@pulumi.output_type
class GetBackendServiceCdnPolicyCacheKeyPolicyResult(dict):
    def __init__(__self__, *,
                 include_host: bool,
                 include_http_headers: Sequence[str],
                 include_named_cookies: Sequence[str],
                 include_protocol: bool,
                 include_query_string: bool,
                 query_string_blacklists: Sequence[str],
                 query_string_whitelists: Sequence[str]):
        pulumi.set(__self__, "include_host", include_host)
        pulumi.set(__self__, "include_http_headers", include_http_headers)
        pulumi.set(__self__, "include_named_cookies", include_named_cookies)
        pulumi.set(__self__, "include_protocol", include_protocol)
        pulumi.set(__self__, "include_query_string", include_query_string)
        pulumi.set(__self__, "query_string_blacklists", query_string_blacklists)
        pulumi.set(__self__, "query_string_whitelists", query_string_whitelists)

    @property
    @pulumi.getter(name="includeHost")
    def include_host(self) -> bool:
        return pulumi.get(self, "include_host")

    @property
    @pulumi.getter(name="includeHttpHeaders")
    def include_http_headers(self) -> Sequence[str]:
        return pulumi.get(self, "include_http_headers")

    @property
    @pulumi.getter(name="includeNamedCookies")
    def include_named_cookies(self) -> Sequence[str]:
        return pulumi.get(self, "include_named_cookies")

    @property
    @pulumi.getter(name="includeProtocol")
    def include_protocol(self) -> bool:
        return pulumi.get(self, "include_protocol")

    @property
    @pulumi.getter(name="includeQueryString")
    def include_query_string(self) -> bool:
        return pulumi.get(self, "include_query_string")

    @property
    @pulumi.getter(name="queryStringBlacklists")
    def query_string_blacklists(self) -> Sequence[str]:
        return pulumi.get(self, "query_string_blacklists")

    @property
    @pulumi.getter(name="queryStringWhitelists")
    def query_string_whitelists(self) -> Sequence[str]:
        return pulumi.get(self, "query_string_whitelists")


@pulumi.output_type
class GetBackendServiceCdnPolicyNegativeCachingPolicyResult(dict):
    def __init__(__self__, *,
                 code: int,
                 ttl: int):
        pulumi.set(__self__, "code", code)
        pulumi.set(__self__, "ttl", ttl)

    @property
    @pulumi.getter
    def code(self) -> int:
        return pulumi.get(self, "code")

    @property
    @pulumi.getter
    def ttl(self) -> int:
        return pulumi.get(self, "ttl")


@pulumi.output_type
class GetBackendServiceCircuitBreakerResult(dict):
    def __init__(__self__, *,
                 connect_timeouts: Sequence['outputs.GetBackendServiceCircuitBreakerConnectTimeoutResult'],
                 max_connections: int,
                 max_pending_requests: int,
                 max_requests: int,
                 max_requests_per_connection: int,
                 max_retries: int):
        pulumi.set(__self__, "connect_timeouts", connect_timeouts)
        pulumi.set(__self__, "max_connections", max_connections)
        pulumi.set(__self__, "max_pending_requests", max_pending_requests)
        pulumi.set(__self__, "max_requests", max_requests)
        pulumi.set(__self__, "max_requests_per_connection", max_requests_per_connection)
        pulumi.set(__self__, "max_retries", max_retries)

    @property
    @pulumi.getter(name="connectTimeouts")
    def connect_timeouts(self) -> Sequence['outputs.GetBackendServiceCircuitBreakerConnectTimeoutResult']:
        return pulumi.get(self, "connect_timeouts")

    @property
    @pulumi.getter(name="maxConnections")
    def max_connections(self) -> int:
        return pulumi.get(self, "max_connections")

    @property
    @pulumi.getter(name="maxPendingRequests")
    def max_pending_requests(self) -> int:
        return pulumi.get(self, "max_pending_requests")

    @property
    @pulumi.getter(name="maxRequests")
    def max_requests(self) -> int:
        return pulumi.get(self, "max_requests")

    @property
    @pulumi.getter(name="maxRequestsPerConnection")
    def max_requests_per_connection(self) -> int:
        return pulumi.get(self, "max_requests_per_connection")

    @property
    @pulumi.getter(name="maxRetries")
    def max_retries(self) -> int:
        return pulumi.get(self, "max_retries")


@pulumi.output_type
class GetBackendServiceCircuitBreakerConnectTimeoutResult(dict):
    def __init__(__self__, *,
                 nanos: int,
                 seconds: int):
        pulumi.set(__self__, "nanos", nanos)
        pulumi.set(__self__, "seconds", seconds)

    @property
    @pulumi.getter
    def nanos(self) -> int:
        return pulumi.get(self, "nanos")

    @property
    @pulumi.getter
    def seconds(self) -> int:
        return pulumi.get(self, "seconds")


@pulumi.output_type
class GetBackendServiceConsistentHashResult(dict):
    def __init__(__self__, *,
                 http_cookies: Sequence['outputs.GetBackendServiceConsistentHashHttpCookyResult'],
                 http_header_name: str,
                 minimum_ring_size: int):
        pulumi.set(__self__, "http_cookies", http_cookies)
        pulumi.set(__self__, "http_header_name", http_header_name)
        pulumi.set(__self__, "minimum_ring_size", minimum_ring_size)

    @property
    @pulumi.getter(name="httpCookies")
    def http_cookies(self) -> Sequence['outputs.GetBackendServiceConsistentHashHttpCookyResult']:
        return pulumi.get(self, "http_cookies")

    @property
    @pulumi.getter(name="httpHeaderName")
    def http_header_name(self) -> str:
        return pulumi.get(self, "http_header_name")

    @property
    @pulumi.getter(name="minimumRingSize")
    def minimum_ring_size(self) -> int:
        return pulumi.get(self, "minimum_ring_size")


@pulumi.output_type
class GetBackendServiceConsistentHashHttpCookyResult(dict):
    def __init__(__self__, *,
                 name: str,
                 path: str,
                 ttls: Sequence['outputs.GetBackendServiceConsistentHashHttpCookyTtlResult']):
        """
        :param str name: The name of the Backend Service.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "ttls", ttls)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Backend Service.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def path(self) -> str:
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def ttls(self) -> Sequence['outputs.GetBackendServiceConsistentHashHttpCookyTtlResult']:
        return pulumi.get(self, "ttls")


@pulumi.output_type
class GetBackendServiceConsistentHashHttpCookyTtlResult(dict):
    def __init__(__self__, *,
                 nanos: int,
                 seconds: int):
        pulumi.set(__self__, "nanos", nanos)
        pulumi.set(__self__, "seconds", seconds)

    @property
    @pulumi.getter
    def nanos(self) -> int:
        return pulumi.get(self, "nanos")

    @property
    @pulumi.getter
    def seconds(self) -> int:
        return pulumi.get(self, "seconds")


@pulumi.output_type
class GetBackendServiceIapResult(dict):
    def __init__(__self__, *,
                 oauth2_client_id: str,
                 oauth2_client_secret: str,
                 oauth2_client_secret_sha256: str):
        pulumi.set(__self__, "oauth2_client_id", oauth2_client_id)
        pulumi.set(__self__, "oauth2_client_secret", oauth2_client_secret)
        pulumi.set(__self__, "oauth2_client_secret_sha256", oauth2_client_secret_sha256)

    @property
    @pulumi.getter(name="oauth2ClientId")
    def oauth2_client_id(self) -> str:
        return pulumi.get(self, "oauth2_client_id")

    @property
    @pulumi.getter(name="oauth2ClientSecret")
    def oauth2_client_secret(self) -> str:
        return pulumi.get(self, "oauth2_client_secret")

    @property
    @pulumi.getter(name="oauth2ClientSecretSha256")
    def oauth2_client_secret_sha256(self) -> str:
        return pulumi.get(self, "oauth2_client_secret_sha256")


@pulumi.output_type
class GetBackendServiceLocalityLbPolicyResult(dict):
    def __init__(__self__, *,
                 custom_policies: Sequence['outputs.GetBackendServiceLocalityLbPolicyCustomPolicyResult'],
                 policies: Sequence['outputs.GetBackendServiceLocalityLbPolicyPolicyResult']):
        pulumi.set(__self__, "custom_policies", custom_policies)
        pulumi.set(__self__, "policies", policies)

    @property
    @pulumi.getter(name="customPolicies")
    def custom_policies(self) -> Sequence['outputs.GetBackendServiceLocalityLbPolicyCustomPolicyResult']:
        return pulumi.get(self, "custom_policies")

    @property
    @pulumi.getter
    def policies(self) -> Sequence['outputs.GetBackendServiceLocalityLbPolicyPolicyResult']:
        return pulumi.get(self, "policies")


@pulumi.output_type
class GetBackendServiceLocalityLbPolicyCustomPolicyResult(dict):
    def __init__(__self__, *,
                 data: str,
                 name: str):
        """
        :param str name: The name of the Backend Service.
        """
        pulumi.set(__self__, "data", data)
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def data(self) -> str:
        return pulumi.get(self, "data")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Backend Service.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class GetBackendServiceLocalityLbPolicyPolicyResult(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param str name: The name of the Backend Service.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Backend Service.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class GetBackendServiceLogConfigResult(dict):
    def __init__(__self__, *,
                 enable: bool,
                 sample_rate: float):
        pulumi.set(__self__, "enable", enable)
        pulumi.set(__self__, "sample_rate", sample_rate)

    @property
    @pulumi.getter
    def enable(self) -> bool:
        return pulumi.get(self, "enable")

    @property
    @pulumi.getter(name="sampleRate")
    def sample_rate(self) -> float:
        return pulumi.get(self, "sample_rate")


@pulumi.output_type
class GetBackendServiceOutlierDetectionResult(dict):
    def __init__(__self__, *,
                 base_ejection_times: Sequence['outputs.GetBackendServiceOutlierDetectionBaseEjectionTimeResult'],
                 consecutive_errors: int,
                 consecutive_gateway_failure: int,
                 enforcing_consecutive_errors: int,
                 enforcing_consecutive_gateway_failure: int,
                 enforcing_success_rate: int,
                 intervals: Sequence['outputs.GetBackendServiceOutlierDetectionIntervalResult'],
                 max_ejection_percent: int,
                 success_rate_minimum_hosts: int,
                 success_rate_request_volume: int,
                 success_rate_stdev_factor: int):
        pulumi.set(__self__, "base_ejection_times", base_ejection_times)
        pulumi.set(__self__, "consecutive_errors", consecutive_errors)
        pulumi.set(__self__, "consecutive_gateway_failure", consecutive_gateway_failure)
        pulumi.set(__self__, "enforcing_consecutive_errors", enforcing_consecutive_errors)
        pulumi.set(__self__, "enforcing_consecutive_gateway_failure", enforcing_consecutive_gateway_failure)
        pulumi.set(__self__, "enforcing_success_rate", enforcing_success_rate)
        pulumi.set(__self__, "intervals", intervals)
        pulumi.set(__self__, "max_ejection_percent", max_ejection_percent)
        pulumi.set(__self__, "success_rate_minimum_hosts", success_rate_minimum_hosts)
        pulumi.set(__self__, "success_rate_request_volume", success_rate_request_volume)
        pulumi.set(__self__, "success_rate_stdev_factor", success_rate_stdev_factor)

    @property
    @pulumi.getter(name="baseEjectionTimes")
    def base_ejection_times(self) -> Sequence['outputs.GetBackendServiceOutlierDetectionBaseEjectionTimeResult']:
        return pulumi.get(self, "base_ejection_times")

    @property
    @pulumi.getter(name="consecutiveErrors")
    def consecutive_errors(self) -> int:
        return pulumi.get(self, "consecutive_errors")

    @property
    @pulumi.getter(name="consecutiveGatewayFailure")
    def consecutive_gateway_failure(self) -> int:
        return pulumi.get(self, "consecutive_gateway_failure")

    @property
    @pulumi.getter(name="enforcingConsecutiveErrors")
    def enforcing_consecutive_errors(self) -> int:
        return pulumi.get(self, "enforcing_consecutive_errors")

    @property
    @pulumi.getter(name="enforcingConsecutiveGatewayFailure")
    def enforcing_consecutive_gateway_failure(self) -> int:
        return pulumi.get(self, "enforcing_consecutive_gateway_failure")

    @property
    @pulumi.getter(name="enforcingSuccessRate")
    def enforcing_success_rate(self) -> int:
        return pulumi.get(self, "enforcing_success_rate")

    @property
    @pulumi.getter
    def intervals(self) -> Sequence['outputs.GetBackendServiceOutlierDetectionIntervalResult']:
        return pulumi.get(self, "intervals")

    @property
    @pulumi.getter(name="maxEjectionPercent")
    def max_ejection_percent(self) -> int:
        return pulumi.get(self, "max_ejection_percent")

    @property
    @pulumi.getter(name="successRateMinimumHosts")
    def success_rate_minimum_hosts(self) -> int:
        return pulumi.get(self, "success_rate_minimum_hosts")

    @property
    @pulumi.getter(name="successRateRequestVolume")
    def success_rate_request_volume(self) -> int:
        return pulumi.get(self, "success_rate_request_volume")

    @property
    @pulumi.getter(name="successRateStdevFactor")
    def success_rate_stdev_factor(self) -> int:
        return pulumi.get(self, "success_rate_stdev_factor")


@pulumi.output_type
class GetBackendServiceOutlierDetectionBaseEjectionTimeResult(dict):
    def __init__(__self__, *,
                 nanos: int,
                 seconds: int):
        pulumi.set(__self__, "nanos", nanos)
        pulumi.set(__self__, "seconds", seconds)

    @property
    @pulumi.getter
    def nanos(self) -> int:
        return pulumi.get(self, "nanos")

    @property
    @pulumi.getter
    def seconds(self) -> int:
        return pulumi.get(self, "seconds")


@pulumi.output_type
class GetBackendServiceOutlierDetectionIntervalResult(dict):
    def __init__(__self__, *,
                 nanos: int,
                 seconds: int):
        pulumi.set(__self__, "nanos", nanos)
        pulumi.set(__self__, "seconds", seconds)

    @property
    @pulumi.getter
    def nanos(self) -> int:
        return pulumi.get(self, "nanos")

    @property
    @pulumi.getter
    def seconds(self) -> int:
        return pulumi.get(self, "seconds")


@pulumi.output_type
class GetBackendServiceSecuritySettingResult(dict):
    def __init__(__self__, *,
                 client_tls_policy: str,
                 subject_alt_names: Sequence[str]):
        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) -> str:
        return pulumi.get(self, "client_tls_policy")

    @property
    @pulumi.getter(name="subjectAltNames")
    def subject_alt_names(self) -> Sequence[str]:
        return pulumi.get(self, "subject_alt_names")


@pulumi.output_type
class GetDiskDiskEncryptionKeyResult(dict):
    def __init__(__self__, *,
                 kms_key_self_link: str,
                 kms_key_service_account: str,
                 raw_key: str,
                 rsa_encrypted_key: str,
                 sha256: str):
        pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
        pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
        pulumi.set(__self__, "raw_key", raw_key)
        pulumi.set(__self__, "rsa_encrypted_key", rsa_encrypted_key)
        pulumi.set(__self__, "sha256", sha256)

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

    @property
    @pulumi.getter(name="kmsKeyServiceAccount")
    def kms_key_service_account(self) -> str:
        return pulumi.get(self, "kms_key_service_account")

    @property
    @pulumi.getter(name="rawKey")
    def raw_key(self) -> str:
        return pulumi.get(self, "raw_key")

    @property
    @pulumi.getter(name="rsaEncryptedKey")
    def rsa_encrypted_key(self) -> str:
        return pulumi.get(self, "rsa_encrypted_key")

    @property
    @pulumi.getter
    def sha256(self) -> str:
        return pulumi.get(self, "sha256")


@pulumi.output_type
class GetDiskSourceImageEncryptionKeyResult(dict):
    def __init__(__self__, *,
                 kms_key_self_link: str,
                 kms_key_service_account: str,
                 raw_key: str,
                 sha256: str):
        pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
        pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
        pulumi.set(__self__, "raw_key", raw_key)
        pulumi.set(__self__, "sha256", sha256)

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

    @property
    @pulumi.getter(name="kmsKeyServiceAccount")
    def kms_key_service_account(self) -> str:
        return pulumi.get(self, "kms_key_service_account")

    @property
    @pulumi.getter(name="rawKey")
    def raw_key(self) -> str:
        return pulumi.get(self, "raw_key")

    @property
    @pulumi.getter
    def sha256(self) -> str:
        return pulumi.get(self, "sha256")


@pulumi.output_type
class GetDiskSourceSnapshotEncryptionKeyResult(dict):
    def __init__(__self__, *,
                 kms_key_self_link: str,
                 kms_key_service_account: str,
                 raw_key: str,
                 sha256: str):
        pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
        pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
        pulumi.set(__self__, "raw_key", raw_key)
        pulumi.set(__self__, "sha256", sha256)

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

    @property
    @pulumi.getter(name="kmsKeyServiceAccount")
    def kms_key_service_account(self) -> str:
        return pulumi.get(self, "kms_key_service_account")

    @property
    @pulumi.getter(name="rawKey")
    def raw_key(self) -> str:
        return pulumi.get(self, "raw_key")

    @property
    @pulumi.getter
    def sha256(self) -> str:
        return pulumi.get(self, "sha256")


@pulumi.output_type
class GetForwardingRuleServiceDirectoryRegistrationResult(dict):
    def __init__(__self__, *,
                 namespace: str,
                 service: str):
        pulumi.set(__self__, "namespace", namespace)
        pulumi.set(__self__, "service", service)

    @property
    @pulumi.getter
    def namespace(self) -> str:
        return pulumi.get(self, "namespace")

    @property
    @pulumi.getter
    def service(self) -> str:
        return pulumi.get(self, "service")


@pulumi.output_type
class GetGlobalForwardingRuleMetadataFilterResult(dict):
    def __init__(__self__, *,
                 filter_labels: Sequence['outputs.GetGlobalForwardingRuleMetadataFilterFilterLabelResult'],
                 filter_match_criteria: str):
        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) -> Sequence['outputs.GetGlobalForwardingRuleMetadataFilterFilterLabelResult']:
        return pulumi.get(self, "filter_labels")

    @property
    @pulumi.getter(name="filterMatchCriteria")
    def filter_match_criteria(self) -> str:
        return pulumi.get(self, "filter_match_criteria")


@pulumi.output_type
class GetGlobalForwardingRuleMetadataFilterFilterLabelResult(dict):
    def __init__(__self__, *,
                 name: str,
                 value: str):
        """
        :param str name: The name of the global forwarding rule.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the global forwarding rule.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetHcVpnGatewayVpnInterfaceResult(dict):
    def __init__(__self__, *,
                 id: int,
                 interconnect_attachment: str,
                 ip_address: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "interconnect_attachment", interconnect_attachment)
        pulumi.set(__self__, "ip_address", ip_address)

    @property
    @pulumi.getter
    def id(self) -> int:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="interconnectAttachment")
    def interconnect_attachment(self) -> str:
        return pulumi.get(self, "interconnect_attachment")

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> str:
        return pulumi.get(self, "ip_address")


@pulumi.output_type
class GetHealthCheckGrpcHealthCheckResult(dict):
    def __init__(__self__, *,
                 grpc_service_name: str,
                 port: int,
                 port_name: str,
                 port_specification: str):
        pulumi.set(__self__, "grpc_service_name", grpc_service_name)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "port_name", port_name)
        pulumi.set(__self__, "port_specification", port_specification)

    @property
    @pulumi.getter(name="grpcServiceName")
    def grpc_service_name(self) -> str:
        return pulumi.get(self, "grpc_service_name")

    @property
    @pulumi.getter
    def port(self) -> int:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> str:
        return pulumi.get(self, "port_name")

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> str:
        return pulumi.get(self, "port_specification")


@pulumi.output_type
class GetHealthCheckHttp2HealthCheckResult(dict):
    def __init__(__self__, *,
                 host: str,
                 port: int,
                 port_name: str,
                 port_specification: str,
                 proxy_header: str,
                 request_path: str,
                 response: str):
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "port_name", port_name)
        pulumi.set(__self__, "port_specification", port_specification)
        pulumi.set(__self__, "proxy_header", proxy_header)
        pulumi.set(__self__, "request_path", request_path)
        pulumi.set(__self__, "response", response)

    @property
    @pulumi.getter
    def host(self) -> str:
        return pulumi.get(self, "host")

    @property
    @pulumi.getter
    def port(self) -> int:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> str:
        return pulumi.get(self, "port_name")

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> str:
        return pulumi.get(self, "port_specification")

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> str:
        return pulumi.get(self, "proxy_header")

    @property
    @pulumi.getter(name="requestPath")
    def request_path(self) -> str:
        return pulumi.get(self, "request_path")

    @property
    @pulumi.getter
    def response(self) -> str:
        return pulumi.get(self, "response")


@pulumi.output_type
class GetHealthCheckHttpHealthCheckResult(dict):
    def __init__(__self__, *,
                 host: str,
                 port: int,
                 port_name: str,
                 port_specification: str,
                 proxy_header: str,
                 request_path: str,
                 response: str):
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "port_name", port_name)
        pulumi.set(__self__, "port_specification", port_specification)
        pulumi.set(__self__, "proxy_header", proxy_header)
        pulumi.set(__self__, "request_path", request_path)
        pulumi.set(__self__, "response", response)

    @property
    @pulumi.getter
    def host(self) -> str:
        return pulumi.get(self, "host")

    @property
    @pulumi.getter
    def port(self) -> int:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> str:
        return pulumi.get(self, "port_name")

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> str:
        return pulumi.get(self, "port_specification")

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> str:
        return pulumi.get(self, "proxy_header")

    @property
    @pulumi.getter(name="requestPath")
    def request_path(self) -> str:
        return pulumi.get(self, "request_path")

    @property
    @pulumi.getter
    def response(self) -> str:
        return pulumi.get(self, "response")


@pulumi.output_type
class GetHealthCheckHttpsHealthCheckResult(dict):
    def __init__(__self__, *,
                 host: str,
                 port: int,
                 port_name: str,
                 port_specification: str,
                 proxy_header: str,
                 request_path: str,
                 response: str):
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "port_name", port_name)
        pulumi.set(__self__, "port_specification", port_specification)
        pulumi.set(__self__, "proxy_header", proxy_header)
        pulumi.set(__self__, "request_path", request_path)
        pulumi.set(__self__, "response", response)

    @property
    @pulumi.getter
    def host(self) -> str:
        return pulumi.get(self, "host")

    @property
    @pulumi.getter
    def port(self) -> int:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> str:
        return pulumi.get(self, "port_name")

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> str:
        return pulumi.get(self, "port_specification")

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> str:
        return pulumi.get(self, "proxy_header")

    @property
    @pulumi.getter(name="requestPath")
    def request_path(self) -> str:
        return pulumi.get(self, "request_path")

    @property
    @pulumi.getter
    def response(self) -> str:
        return pulumi.get(self, "response")


@pulumi.output_type
class GetHealthCheckLogConfigResult(dict):
    def __init__(__self__, *,
                 enable: bool):
        pulumi.set(__self__, "enable", enable)

    @property
    @pulumi.getter
    def enable(self) -> bool:
        return pulumi.get(self, "enable")


@pulumi.output_type
class GetHealthCheckSslHealthCheckResult(dict):
    def __init__(__self__, *,
                 port: int,
                 port_name: str,
                 port_specification: str,
                 proxy_header: str,
                 request: str,
                 response: str):
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "port_name", port_name)
        pulumi.set(__self__, "port_specification", port_specification)
        pulumi.set(__self__, "proxy_header", proxy_header)
        pulumi.set(__self__, "request", request)
        pulumi.set(__self__, "response", response)

    @property
    @pulumi.getter
    def port(self) -> int:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> str:
        return pulumi.get(self, "port_name")

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> str:
        return pulumi.get(self, "port_specification")

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> str:
        return pulumi.get(self, "proxy_header")

    @property
    @pulumi.getter
    def request(self) -> str:
        return pulumi.get(self, "request")

    @property
    @pulumi.getter
    def response(self) -> str:
        return pulumi.get(self, "response")


@pulumi.output_type
class GetHealthCheckTcpHealthCheckResult(dict):
    def __init__(__self__, *,
                 port: int,
                 port_name: str,
                 port_specification: str,
                 proxy_header: str,
                 request: str,
                 response: str):
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "port_name", port_name)
        pulumi.set(__self__, "port_specification", port_specification)
        pulumi.set(__self__, "proxy_header", proxy_header)
        pulumi.set(__self__, "request", request)
        pulumi.set(__self__, "response", response)

    @property
    @pulumi.getter
    def port(self) -> int:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="portName")
    def port_name(self) -> str:
        return pulumi.get(self, "port_name")

    @property
    @pulumi.getter(name="portSpecification")
    def port_specification(self) -> str:
        return pulumi.get(self, "port_specification")

    @property
    @pulumi.getter(name="proxyHeader")
    def proxy_header(self) -> str:
        return pulumi.get(self, "proxy_header")

    @property
    @pulumi.getter
    def request(self) -> str:
        return pulumi.get(self, "request")

    @property
    @pulumi.getter
    def response(self) -> str:
        return pulumi.get(self, "response")


@pulumi.output_type
class GetInstanceAdvancedMachineFeatureResult(dict):
    def __init__(__self__, *,
                 enable_nested_virtualization: bool,
                 threads_per_core: int,
                 visible_core_count: int):
        pulumi.set(__self__, "enable_nested_virtualization", enable_nested_virtualization)
        pulumi.set(__self__, "threads_per_core", threads_per_core)
        pulumi.set(__self__, "visible_core_count", visible_core_count)

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

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

    @property
    @pulumi.getter(name="visibleCoreCount")
    def visible_core_count(self) -> int:
        return pulumi.get(self, "visible_core_count")


@pulumi.output_type
class GetInstanceAttachedDiskResult(dict):
    def __init__(__self__, *,
                 device_name: str,
                 disk_encryption_key_raw: str,
                 disk_encryption_key_sha256: str,
                 kms_key_self_link: str,
                 mode: str,
                 source: str):
        """
        :param str device_name: Name with which the attached disk is accessible
               under `/dev/disk/by-id/`
        :param str mode: Read/write mode for the disk. One of `"READ_ONLY"` or `"READ_WRITE"`.
        :param str source: The name or self_link of the disk attached to this instance.
        """
        pulumi.set(__self__, "device_name", device_name)
        pulumi.set(__self__, "disk_encryption_key_raw", disk_encryption_key_raw)
        pulumi.set(__self__, "disk_encryption_key_sha256", disk_encryption_key_sha256)
        pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "source", source)

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> str:
        """
        Name with which the attached disk is accessible
        under `/dev/disk/by-id/`
        """
        return pulumi.get(self, "device_name")

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

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

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

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        Read/write mode for the disk. One of `"READ_ONLY"` or `"READ_WRITE"`.
        """
        return pulumi.get(self, "mode")

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


@pulumi.output_type
class GetInstanceBootDiskResult(dict):
    def __init__(__self__, *,
                 auto_delete: bool,
                 device_name: str,
                 disk_encryption_key_raw: str,
                 disk_encryption_key_sha256: str,
                 initialize_params: Sequence['outputs.GetInstanceBootDiskInitializeParamResult'],
                 kms_key_self_link: str,
                 mode: str,
                 source: str):
        """
        :param bool auto_delete: Whether the disk will be auto-deleted when the instance is deleted.
        :param str device_name: Name with which the attached disk is accessible
               under `/dev/disk/by-id/`
        :param Sequence['GetInstanceBootDiskInitializeParamArgs'] initialize_params: Parameters with which a disk was created alongside the instance.
               Structure is documented below.
        :param str mode: Read/write mode for the disk. One of `"READ_ONLY"` or `"READ_WRITE"`.
        :param str source: The name or self_link of the disk attached to this instance.
        """
        pulumi.set(__self__, "auto_delete", auto_delete)
        pulumi.set(__self__, "device_name", device_name)
        pulumi.set(__self__, "disk_encryption_key_raw", disk_encryption_key_raw)
        pulumi.set(__self__, "disk_encryption_key_sha256", disk_encryption_key_sha256)
        pulumi.set(__self__, "initialize_params", initialize_params)
        pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "source", source)

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

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> str:
        """
        Name with which the attached disk is accessible
        under `/dev/disk/by-id/`
        """
        return pulumi.get(self, "device_name")

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

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

    @property
    @pulumi.getter(name="initializeParams")
    def initialize_params(self) -> Sequence['outputs.GetInstanceBootDiskInitializeParamResult']:
        """
        Parameters with which a disk was created alongside the instance.
        Structure is documented below.
        """
        return pulumi.get(self, "initialize_params")

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

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        Read/write mode for the disk. One of `"READ_ONLY"` or `"READ_WRITE"`.
        """
        return pulumi.get(self, "mode")

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


@pulumi.output_type
class GetInstanceBootDiskInitializeParamResult(dict):
    def __init__(__self__, *,
                 image: str,
                 labels: Mapping[str, Any],
                 size: int,
                 type: str):
        """
        :param str image: The image from which this disk was initialised.
        :param Mapping[str, Any] labels: A set of key/value label pairs assigned to the disk.
        :param int size: The size of the image in gigabytes.
        :param str type: The accelerator type resource exposed to this instance. E.g. `nvidia-tesla-k80`.
        """
        pulumi.set(__self__, "image", image)
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "size", size)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def image(self) -> str:
        """
        The image from which this disk was initialised.
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def labels(self) -> Mapping[str, Any]:
        """
        A set of key/value label pairs assigned to the disk.
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter
    def size(self) -> int:
        """
        The size of the image in gigabytes.
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The accelerator type resource exposed to this instance. E.g. `nvidia-tesla-k80`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetInstanceConfidentialInstanceConfigResult(dict):
    def __init__(__self__, *,
                 enable_confidential_compute: bool):
        pulumi.set(__self__, "enable_confidential_compute", enable_confidential_compute)

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


@pulumi.output_type
class GetInstanceGroupManagerAllInstancesConfigResult(dict):
    def __init__(__self__, *,
                 labels: Mapping[str, str],
                 metadata: Mapping[str, str]):
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "metadata", metadata)

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

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


@pulumi.output_type
class GetInstanceGroupManagerAutoHealingPolicyResult(dict):
    def __init__(__self__, *,
                 health_check: str,
                 initial_delay_sec: int):
        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) -> str:
        return pulumi.get(self, "health_check")

    @property
    @pulumi.getter(name="initialDelaySec")
    def initial_delay_sec(self) -> int:
        return pulumi.get(self, "initial_delay_sec")


@pulumi.output_type
class GetInstanceGroupManagerInstanceLifecyclePolicyResult(dict):
    def __init__(__self__, *,
                 force_update_on_repair: str):
        pulumi.set(__self__, "force_update_on_repair", force_update_on_repair)

    @property
    @pulumi.getter(name="forceUpdateOnRepair")
    def force_update_on_repair(self) -> str:
        return pulumi.get(self, "force_update_on_repair")


@pulumi.output_type
class GetInstanceGroupManagerNamedPortResult(dict):
    def __init__(__self__, *,
                 name: str,
                 port: int):
        """
        :param str name: The name of the instance group. Either `name` or `self_link` must be provided.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the instance group. Either `name` or `self_link` must be provided.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def port(self) -> int:
        return pulumi.get(self, "port")


@pulumi.output_type
class GetInstanceGroupManagerStatefulDiskResult(dict):
    def __init__(__self__, *,
                 delete_rule: str,
                 device_name: str):
        pulumi.set(__self__, "delete_rule", delete_rule)
        pulumi.set(__self__, "device_name", device_name)

    @property
    @pulumi.getter(name="deleteRule")
    def delete_rule(self) -> str:
        return pulumi.get(self, "delete_rule")

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


@pulumi.output_type
class GetInstanceGroupManagerStatefulExternalIpResult(dict):
    def __init__(__self__, *,
                 delete_rule: str,
                 interface_name: str):
        pulumi.set(__self__, "delete_rule", delete_rule)
        pulumi.set(__self__, "interface_name", interface_name)

    @property
    @pulumi.getter(name="deleteRule")
    def delete_rule(self) -> str:
        return pulumi.get(self, "delete_rule")

    @property
    @pulumi.getter(name="interfaceName")
    def interface_name(self) -> str:
        return pulumi.get(self, "interface_name")


@pulumi.output_type
class GetInstanceGroupManagerStatefulInternalIpResult(dict):
    def __init__(__self__, *,
                 delete_rule: str,
                 interface_name: str):
        pulumi.set(__self__, "delete_rule", delete_rule)
        pulumi.set(__self__, "interface_name", interface_name)

    @property
    @pulumi.getter(name="deleteRule")
    def delete_rule(self) -> str:
        return pulumi.get(self, "delete_rule")

    @property
    @pulumi.getter(name="interfaceName")
    def interface_name(self) -> str:
        return pulumi.get(self, "interface_name")


@pulumi.output_type
class GetInstanceGroupManagerStatusResult(dict):
    def __init__(__self__, *,
                 all_instances_configs: Sequence['outputs.GetInstanceGroupManagerStatusAllInstancesConfigResult'],
                 is_stable: bool,
                 statefuls: Sequence['outputs.GetInstanceGroupManagerStatusStatefulResult'],
                 version_targets: Sequence['outputs.GetInstanceGroupManagerStatusVersionTargetResult']):
        pulumi.set(__self__, "all_instances_configs", all_instances_configs)
        pulumi.set(__self__, "is_stable", is_stable)
        pulumi.set(__self__, "statefuls", statefuls)
        pulumi.set(__self__, "version_targets", version_targets)

    @property
    @pulumi.getter(name="allInstancesConfigs")
    def all_instances_configs(self) -> Sequence['outputs.GetInstanceGroupManagerStatusAllInstancesConfigResult']:
        return pulumi.get(self, "all_instances_configs")

    @property
    @pulumi.getter(name="isStable")
    def is_stable(self) -> bool:
        return pulumi.get(self, "is_stable")

    @property
    @pulumi.getter
    def statefuls(self) -> Sequence['outputs.GetInstanceGroupManagerStatusStatefulResult']:
        return pulumi.get(self, "statefuls")

    @property
    @pulumi.getter(name="versionTargets")
    def version_targets(self) -> Sequence['outputs.GetInstanceGroupManagerStatusVersionTargetResult']:
        return pulumi.get(self, "version_targets")


@pulumi.output_type
class GetInstanceGroupManagerStatusAllInstancesConfigResult(dict):
    def __init__(__self__, *,
                 effective: bool):
        pulumi.set(__self__, "effective", effective)

    @property
    @pulumi.getter
    def effective(self) -> bool:
        return pulumi.get(self, "effective")


@pulumi.output_type
class GetInstanceGroupManagerStatusStatefulResult(dict):
    def __init__(__self__, *,
                 has_stateful_config: bool,
                 per_instance_configs: Sequence['outputs.GetInstanceGroupManagerStatusStatefulPerInstanceConfigResult']):
        pulumi.set(__self__, "has_stateful_config", has_stateful_config)
        pulumi.set(__self__, "per_instance_configs", per_instance_configs)

    @property
    @pulumi.getter(name="hasStatefulConfig")
    def has_stateful_config(self) -> bool:
        return pulumi.get(self, "has_stateful_config")

    @property
    @pulumi.getter(name="perInstanceConfigs")
    def per_instance_configs(self) -> Sequence['outputs.GetInstanceGroupManagerStatusStatefulPerInstanceConfigResult']:
        return pulumi.get(self, "per_instance_configs")


@pulumi.output_type
class GetInstanceGroupManagerStatusStatefulPerInstanceConfigResult(dict):
    def __init__(__self__, *,
                 all_effective: bool):
        pulumi.set(__self__, "all_effective", all_effective)

    @property
    @pulumi.getter(name="allEffective")
    def all_effective(self) -> bool:
        return pulumi.get(self, "all_effective")


@pulumi.output_type
class GetInstanceGroupManagerStatusVersionTargetResult(dict):
    def __init__(__self__, *,
                 is_reached: bool):
        pulumi.set(__self__, "is_reached", is_reached)

    @property
    @pulumi.getter(name="isReached")
    def is_reached(self) -> bool:
        return pulumi.get(self, "is_reached")


@pulumi.output_type
class GetInstanceGroupManagerUpdatePolicyResult(dict):
    def __init__(__self__, *,
                 max_surge_fixed: int,
                 max_surge_percent: int,
                 max_unavailable_fixed: int,
                 max_unavailable_percent: int,
                 min_ready_sec: int,
                 minimal_action: str,
                 most_disruptive_allowed_action: str,
                 replacement_method: str,
                 type: str):
        pulumi.set(__self__, "max_surge_fixed", max_surge_fixed)
        pulumi.set(__self__, "max_surge_percent", max_surge_percent)
        pulumi.set(__self__, "max_unavailable_fixed", max_unavailable_fixed)
        pulumi.set(__self__, "max_unavailable_percent", max_unavailable_percent)
        pulumi.set(__self__, "min_ready_sec", min_ready_sec)
        pulumi.set(__self__, "minimal_action", minimal_action)
        pulumi.set(__self__, "most_disruptive_allowed_action", most_disruptive_allowed_action)
        pulumi.set(__self__, "replacement_method", replacement_method)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="maxSurgeFixed")
    def max_surge_fixed(self) -> int:
        return pulumi.get(self, "max_surge_fixed")

    @property
    @pulumi.getter(name="maxSurgePercent")
    def max_surge_percent(self) -> int:
        return pulumi.get(self, "max_surge_percent")

    @property
    @pulumi.getter(name="maxUnavailableFixed")
    def max_unavailable_fixed(self) -> int:
        return pulumi.get(self, "max_unavailable_fixed")

    @property
    @pulumi.getter(name="maxUnavailablePercent")
    def max_unavailable_percent(self) -> int:
        return pulumi.get(self, "max_unavailable_percent")

    @property
    @pulumi.getter(name="minReadySec")
    def min_ready_sec(self) -> int:
        return pulumi.get(self, "min_ready_sec")

    @property
    @pulumi.getter(name="minimalAction")
    def minimal_action(self) -> str:
        return pulumi.get(self, "minimal_action")

    @property
    @pulumi.getter(name="mostDisruptiveAllowedAction")
    def most_disruptive_allowed_action(self) -> str:
        return pulumi.get(self, "most_disruptive_allowed_action")

    @property
    @pulumi.getter(name="replacementMethod")
    def replacement_method(self) -> str:
        return pulumi.get(self, "replacement_method")

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


@pulumi.output_type
class GetInstanceGroupManagerVersionResult(dict):
    def __init__(__self__, *,
                 instance_template: str,
                 name: str,
                 target_sizes: Sequence['outputs.GetInstanceGroupManagerVersionTargetSizeResult']):
        """
        :param str name: The name of the instance group. Either `name` or `self_link` must be provided.
        """
        pulumi.set(__self__, "instance_template", instance_template)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "target_sizes", target_sizes)

    @property
    @pulumi.getter(name="instanceTemplate")
    def instance_template(self) -> str:
        return pulumi.get(self, "instance_template")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the instance group. Either `name` or `self_link` must be provided.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="targetSizes")
    def target_sizes(self) -> Sequence['outputs.GetInstanceGroupManagerVersionTargetSizeResult']:
        return pulumi.get(self, "target_sizes")


@pulumi.output_type
class GetInstanceGroupManagerVersionTargetSizeResult(dict):
    def __init__(__self__, *,
                 fixed: int,
                 percent: int):
        pulumi.set(__self__, "fixed", fixed)
        pulumi.set(__self__, "percent", percent)

    @property
    @pulumi.getter
    def fixed(self) -> int:
        return pulumi.get(self, "fixed")

    @property
    @pulumi.getter
    def percent(self) -> int:
        return pulumi.get(self, "percent")


@pulumi.output_type
class GetInstanceGroupNamedPortResult(dict):
    def __init__(__self__, *,
                 name: str,
                 port: int):
        """
        :param str name: The name of the instance group. Either `name` or `self_link` must be provided.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the instance group. Either `name` or `self_link` must be provided.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def port(self) -> int:
        return pulumi.get(self, "port")


@pulumi.output_type
class GetInstanceGuestAcceleratorResult(dict):
    def __init__(__self__, *,
                 count: int,
                 type: str):
        """
        :param int count: The number of the guest accelerator cards exposed to this instance.
        :param str type: The accelerator type resource exposed to this instance. E.g. `nvidia-tesla-k80`.
        """
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def count(self) -> int:
        """
        The number of the guest accelerator cards exposed to this instance.
        """
        return pulumi.get(self, "count")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The accelerator type resource exposed to this instance. E.g. `nvidia-tesla-k80`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetInstanceNetworkInterfaceResult(dict):
    def __init__(__self__, *,
                 access_configs: Sequence['outputs.GetInstanceNetworkInterfaceAccessConfigResult'],
                 alias_ip_ranges: Sequence['outputs.GetInstanceNetworkInterfaceAliasIpRangeResult'],
                 ipv6_access_configs: Sequence['outputs.GetInstanceNetworkInterfaceIpv6AccessConfigResult'],
                 ipv6_access_type: str,
                 name: str,
                 network: str,
                 network_ip: str,
                 nic_type: str,
                 queue_count: int,
                 stack_type: str,
                 subnetwork: str,
                 subnetwork_project: str):
        """
        :param Sequence['GetInstanceNetworkInterfaceAccessConfigArgs'] access_configs: Access configurations, i.e. IPs via which this
               instance can be accessed via the Internet. Structure documented below.
        :param Sequence['GetInstanceNetworkInterfaceAliasIpRangeArgs'] alias_ip_ranges: An array of alias IP ranges for this network interface. Structure documented below.
        :param str name: The name of the instance. One of `name` or `self_link` must be provided.
        :param str network: The name or self_link of the network attached to this interface.
        :param str network_ip: The private IP address assigned to the instance.
        :param str subnetwork: The name or self_link of the subnetwork attached to this interface.
        :param str subnetwork_project: The project in which the subnetwork belongs.
        """
        pulumi.set(__self__, "access_configs", access_configs)
        pulumi.set(__self__, "alias_ip_ranges", alias_ip_ranges)
        pulumi.set(__self__, "ipv6_access_configs", ipv6_access_configs)
        pulumi.set(__self__, "ipv6_access_type", ipv6_access_type)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "network_ip", network_ip)
        pulumi.set(__self__, "nic_type", nic_type)
        pulumi.set(__self__, "queue_count", queue_count)
        pulumi.set(__self__, "stack_type", stack_type)
        pulumi.set(__self__, "subnetwork", subnetwork)
        pulumi.set(__self__, "subnetwork_project", subnetwork_project)

    @property
    @pulumi.getter(name="accessConfigs")
    def access_configs(self) -> Sequence['outputs.GetInstanceNetworkInterfaceAccessConfigResult']:
        """
        Access configurations, i.e. IPs via which this
        instance can be accessed via the Internet. Structure documented below.
        """
        return pulumi.get(self, "access_configs")

    @property
    @pulumi.getter(name="aliasIpRanges")
    def alias_ip_ranges(self) -> Sequence['outputs.GetInstanceNetworkInterfaceAliasIpRangeResult']:
        """
        An array of alias IP ranges for this network interface. Structure documented below.
        """
        return pulumi.get(self, "alias_ip_ranges")

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

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

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the instance. One of `name` or `self_link` must be provided.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def network(self) -> str:
        """
        The name or self_link of the network attached to this interface.
        """
        return pulumi.get(self, "network")

    @property
    @pulumi.getter(name="networkIp")
    def network_ip(self) -> str:
        """
        The private IP address assigned to the instance.
        """
        return pulumi.get(self, "network_ip")

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

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

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

    @property
    @pulumi.getter
    def subnetwork(self) -> str:
        """
        The name or self_link of the subnetwork attached to this interface.
        """
        return pulumi.get(self, "subnetwork")

    @property
    @pulumi.getter(name="subnetworkProject")
    def subnetwork_project(self) -> str:
        """
        The project in which the subnetwork belongs.
        """
        return pulumi.get(self, "subnetwork_project")


@pulumi.output_type
class GetInstanceNetworkInterfaceAccessConfigResult(dict):
    def __init__(__self__, *,
                 nat_ip: str,
                 network_tier: str,
                 public_ptr_domain_name: str):
        """
        :param str nat_ip: The IP address that is be 1:1 mapped to the instance's
               network ip.
        :param str network_tier: The [networking tier][network-tier] used for configuring this instance. One of `PREMIUM` or `STANDARD`.
        :param str public_ptr_domain_name: The DNS domain name for the public PTR record.
        """
        pulumi.set(__self__, "nat_ip", nat_ip)
        pulumi.set(__self__, "network_tier", network_tier)
        pulumi.set(__self__, "public_ptr_domain_name", public_ptr_domain_name)

    @property
    @pulumi.getter(name="natIp")
    def nat_ip(self) -> str:
        """
        The IP address that is be 1:1 mapped to the instance's
        network ip.
        """
        return pulumi.get(self, "nat_ip")

    @property
    @pulumi.getter(name="networkTier")
    def network_tier(self) -> str:
        """
        The [networking tier][network-tier] used for configuring this instance. One of `PREMIUM` or `STANDARD`.
        """
        return pulumi.get(self, "network_tier")

    @property
    @pulumi.getter(name="publicPtrDomainName")
    def public_ptr_domain_name(self) -> str:
        """
        The DNS domain name for the public PTR record.
        """
        return pulumi.get(self, "public_ptr_domain_name")


@pulumi.output_type
class GetInstanceNetworkInterfaceAliasIpRangeResult(dict):
    def __init__(__self__, *,
                 ip_cidr_range: str,
                 subnetwork_range_name: str):
        """
        :param str ip_cidr_range: The IP CIDR range represented by this alias IP range.
        :param 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.
        """
        pulumi.set(__self__, "ip_cidr_range", ip_cidr_range)
        pulumi.set(__self__, "subnetwork_range_name", subnetwork_range_name)

    @property
    @pulumi.getter(name="ipCidrRange")
    def ip_cidr_range(self) -> str:
        """
        The IP CIDR range represented by this alias IP range.
        """
        return pulumi.get(self, "ip_cidr_range")

    @property
    @pulumi.getter(name="subnetworkRangeName")
    def subnetwork_range_name(self) -> str:
        """
        The subnetwork secondary range name specifying
        the secondary range from which to allocate the IP CIDR range for this alias IP
        range.
        """
        return pulumi.get(self, "subnetwork_range_name")


@pulumi.output_type
class GetInstanceNetworkInterfaceIpv6AccessConfigResult(dict):
    def __init__(__self__, *,
                 external_ipv6: str,
                 external_ipv6_prefix_length: str,
                 network_tier: str,
                 public_ptr_domain_name: str):
        """
        :param str network_tier: The [networking tier][network-tier] used for configuring this instance. One of `PREMIUM` or `STANDARD`.
        :param str public_ptr_domain_name: The DNS domain name for the public PTR record.
        """
        pulumi.set(__self__, "external_ipv6", external_ipv6)
        pulumi.set(__self__, "external_ipv6_prefix_length", external_ipv6_prefix_length)
        pulumi.set(__self__, "network_tier", network_tier)
        pulumi.set(__self__, "public_ptr_domain_name", public_ptr_domain_name)

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

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

    @property
    @pulumi.getter(name="networkTier")
    def network_tier(self) -> str:
        """
        The [networking tier][network-tier] used for configuring this instance. One of `PREMIUM` or `STANDARD`.
        """
        return pulumi.get(self, "network_tier")

    @property
    @pulumi.getter(name="publicPtrDomainName")
    def public_ptr_domain_name(self) -> str:
        """
        The DNS domain name for the public PTR record.
        """
        return pulumi.get(self, "public_ptr_domain_name")


@pulumi.output_type
class GetInstanceNetworkPerformanceConfigResult(dict):
    def __init__(__self__, *,
                 total_egress_bandwidth_tier: str):
        """
        :param str total_egress_bandwidth_tier: The egress bandwidth tier for the instance.
        """
        pulumi.set(__self__, "total_egress_bandwidth_tier", total_egress_bandwidth_tier)

    @property
    @pulumi.getter(name="totalEgressBandwidthTier")
    def total_egress_bandwidth_tier(self) -> str:
        """
        The egress bandwidth tier for the instance.
        """
        return pulumi.get(self, "total_egress_bandwidth_tier")


@pulumi.output_type
class GetInstanceReservationAffinityResult(dict):
    def __init__(__self__, *,
                 specific_reservations: Sequence['outputs.GetInstanceReservationAffinitySpecificReservationResult'],
                 type: str):
        """
        :param str type: The accelerator type resource exposed to this instance. E.g. `nvidia-tesla-k80`.
        """
        pulumi.set(__self__, "specific_reservations", specific_reservations)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="specificReservations")
    def specific_reservations(self) -> Sequence['outputs.GetInstanceReservationAffinitySpecificReservationResult']:
        return pulumi.get(self, "specific_reservations")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The accelerator type resource exposed to this instance. E.g. `nvidia-tesla-k80`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetInstanceReservationAffinitySpecificReservationResult(dict):
    def __init__(__self__, *,
                 key: str,
                 values: Sequence[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "values", values)

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

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


@pulumi.output_type
class GetInstanceSchedulingResult(dict):
    def __init__(__self__, *,
                 automatic_restart: bool,
                 instance_termination_action: str,
                 max_run_durations: Sequence['outputs.GetInstanceSchedulingMaxRunDurationResult'],
                 min_node_cpus: int,
                 node_affinities: Sequence['outputs.GetInstanceSchedulingNodeAffinityResult'],
                 on_host_maintenance: str,
                 preemptible: bool,
                 provisioning_model: str):
        """
        :param bool automatic_restart: Specifies if the instance should be
               restarted if it was terminated by Compute Engine (not a user).
        :param 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 str on_host_maintenance: Describes maintenance behavior for the
               instance. One of `MIGRATE` or `TERMINATE`, for more info, read
               [here](https://cloud.google.com/compute/docs/instances/setting-instance-scheduling-options)
        :param bool preemptible: Whether the instance is preemptible.
        :param str provisioning_model: Describe the type of preemptible VM.
        """
        pulumi.set(__self__, "automatic_restart", automatic_restart)
        pulumi.set(__self__, "instance_termination_action", instance_termination_action)
        pulumi.set(__self__, "max_run_durations", max_run_durations)
        pulumi.set(__self__, "min_node_cpus", min_node_cpus)
        pulumi.set(__self__, "node_affinities", node_affinities)
        pulumi.set(__self__, "on_host_maintenance", on_host_maintenance)
        pulumi.set(__self__, "preemptible", preemptible)
        pulumi.set(__self__, "provisioning_model", provisioning_model)

    @property
    @pulumi.getter(name="automaticRestart")
    def automatic_restart(self) -> bool:
        """
        Specifies if the instance should be
        restarted if it was terminated by Compute Engine (not a user).
        """
        return pulumi.get(self, "automatic_restart")

    @property
    @pulumi.getter(name="instanceTerminationAction")
    def instance_termination_action(self) -> 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")

    @property
    @pulumi.getter(name="maxRunDurations")
    def max_run_durations(self) -> Sequence['outputs.GetInstanceSchedulingMaxRunDurationResult']:
        return pulumi.get(self, "max_run_durations")

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

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

    @property
    @pulumi.getter(name="onHostMaintenance")
    def on_host_maintenance(self) -> str:
        """
        Describes maintenance behavior for the
        instance. One of `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")

    @property
    @pulumi.getter
    def preemptible(self) -> bool:
        """
        Whether the instance is preemptible.
        """
        return pulumi.get(self, "preemptible")

    @property
    @pulumi.getter(name="provisioningModel")
    def provisioning_model(self) -> str:
        """
        Describe the type of preemptible VM.
        """
        return pulumi.get(self, "provisioning_model")


@pulumi.output_type
class GetInstanceSchedulingMaxRunDurationResult(dict):
    def __init__(__self__, *,
                 nanos: int,
                 seconds: int):
        pulumi.set(__self__, "nanos", nanos)
        pulumi.set(__self__, "seconds", seconds)

    @property
    @pulumi.getter
    def nanos(self) -> int:
        return pulumi.get(self, "nanos")

    @property
    @pulumi.getter
    def seconds(self) -> int:
        return pulumi.get(self, "seconds")


@pulumi.output_type
class GetInstanceSchedulingNodeAffinityResult(dict):
    def __init__(__self__, *,
                 key: str,
                 operator: str,
                 values: Sequence[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

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

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

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


@pulumi.output_type
class GetInstanceScratchDiskResult(dict):
    def __init__(__self__, *,
                 interface: str):
        """
        :param str interface: The disk interface used for attaching this disk. One of `SCSI` or `NVME`.
        """
        pulumi.set(__self__, "interface", interface)

    @property
    @pulumi.getter
    def interface(self) -> str:
        """
        The disk interface used for attaching this disk. One of `SCSI` or `NVME`.
        """
        return pulumi.get(self, "interface")


@pulumi.output_type
class GetInstanceServiceAccountResult(dict):
    def __init__(__self__, *,
                 email: str,
                 scopes: Sequence[str]):
        """
        :param str email: The service account e-mail address.
        :param Sequence[str] scopes: A list of service scopes.
        """
        pulumi.set(__self__, "email", email)
        pulumi.set(__self__, "scopes", scopes)

    @property
    @pulumi.getter
    def email(self) -> str:
        """
        The service account e-mail address.
        """
        return pulumi.get(self, "email")

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


@pulumi.output_type
class GetInstanceShieldedInstanceConfigResult(dict):
    def __init__(__self__, *,
                 enable_integrity_monitoring: bool,
                 enable_secure_boot: bool,
                 enable_vtpm: bool):
        """
        :param bool enable_integrity_monitoring: - Whether integrity monitoring is enabled for the instance.
        :param bool enable_secure_boot: - Whether secure boot is enabled for the instance.
        :param bool enable_vtpm: - Whether the instance uses vTPM.
        """
        pulumi.set(__self__, "enable_integrity_monitoring", enable_integrity_monitoring)
        pulumi.set(__self__, "enable_secure_boot", enable_secure_boot)
        pulumi.set(__self__, "enable_vtpm", enable_vtpm)

    @property
    @pulumi.getter(name="enableIntegrityMonitoring")
    def enable_integrity_monitoring(self) -> bool:
        """
        - Whether integrity monitoring is enabled for the instance.
        """
        return pulumi.get(self, "enable_integrity_monitoring")

    @property
    @pulumi.getter(name="enableSecureBoot")
    def enable_secure_boot(self) -> bool:
        """
        - Whether secure boot is enabled for the instance.
        """
        return pulumi.get(self, "enable_secure_boot")

    @property
    @pulumi.getter(name="enableVtpm")
    def enable_vtpm(self) -> bool:
        """
        - Whether the instance uses vTPM.
        """
        return pulumi.get(self, "enable_vtpm")


@pulumi.output_type
class GetInstanceTemplateAdvancedMachineFeatureResult(dict):
    def __init__(__self__, *,
                 enable_nested_virtualization: bool,
                 threads_per_core: int,
                 visible_core_count: int):
        pulumi.set(__self__, "enable_nested_virtualization", enable_nested_virtualization)
        pulumi.set(__self__, "threads_per_core", threads_per_core)
        pulumi.set(__self__, "visible_core_count", visible_core_count)

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

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

    @property
    @pulumi.getter(name="visibleCoreCount")
    def visible_core_count(self) -> int:
        return pulumi.get(self, "visible_core_count")


@pulumi.output_type
class GetInstanceTemplateConfidentialInstanceConfigResult(dict):
    def __init__(__self__, *,
                 enable_confidential_compute: bool):
        """
        :param 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) -> 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")


@pulumi.output_type
class GetInstanceTemplateDiskResult(dict):
    def __init__(__self__, *,
                 auto_delete: bool,
                 boot: bool,
                 device_name: str,
                 disk_encryption_keys: Sequence['outputs.GetInstanceTemplateDiskDiskEncryptionKeyResult'],
                 disk_name: str,
                 disk_size_gb: int,
                 disk_type: str,
                 interface: str,
                 labels: Mapping[str, str],
                 mode: str,
                 resource_policies: Sequence[str],
                 source: str,
                 source_image: str,
                 source_image_encryption_keys: Sequence['outputs.GetInstanceTemplateDiskSourceImageEncryptionKeyResult'],
                 source_snapshot: str,
                 source_snapshot_encryption_keys: Sequence['outputs.GetInstanceTemplateDiskSourceSnapshotEncryptionKeyResult'],
                 type: str):
        """
        :param bool auto_delete: Whether or not the disk should be auto-deleted.
               This defaults to true.
        :param bool boot: Indicates that this is a boot disk.
        :param 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 Sequence['GetInstanceTemplateDiskDiskEncryptionKeyArgs'] disk_encryption_keys: Encrypts or decrypts a disk using a customer-supplied encryption key.
        :param str disk_name: Name of the disk. When not provided, this defaults
               to the name of the instance.
        :param 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 str disk_type: The GCE disk type. Such as `"pd-ssd"`, `"local-ssd"`,
               `"pd-balanced"` or `"pd-standard"`.
        :param 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 Mapping[str, str] labels: (Optional) A set of ket/value label pairs to assign to disk created from
               this template
        :param 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 Sequence[str] resource_policies: (Optional) -- A list of short names of resource policies to attach to this disk for automatic snapshot creations. Currently a max of 1 resource policy is supported.
        :param 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 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 str type: The accelerator type resource to expose to this instance. E.g. `nvidia-tesla-k80`.
        """
        pulumi.set(__self__, "auto_delete", auto_delete)
        pulumi.set(__self__, "boot", boot)
        pulumi.set(__self__, "device_name", device_name)
        pulumi.set(__self__, "disk_encryption_keys", disk_encryption_keys)
        pulumi.set(__self__, "disk_name", disk_name)
        pulumi.set(__self__, "disk_size_gb", disk_size_gb)
        pulumi.set(__self__, "disk_type", disk_type)
        pulumi.set(__self__, "interface", interface)
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "resource_policies", resource_policies)
        pulumi.set(__self__, "source", source)
        pulumi.set(__self__, "source_image", source_image)
        pulumi.set(__self__, "source_image_encryption_keys", source_image_encryption_keys)
        pulumi.set(__self__, "source_snapshot", source_snapshot)
        pulumi.set(__self__, "source_snapshot_encryption_keys", source_snapshot_encryption_keys)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="autoDelete")
    def auto_delete(self) -> bool:
        """
        Whether or not the disk should be auto-deleted.
        This defaults to true.
        """
        return pulumi.get(self, "auto_delete")

    @property
    @pulumi.getter
    def boot(self) -> bool:
        """
        Indicates that this is a boot disk.
        """
        return pulumi.get(self, "boot")

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> 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")

    @property
    @pulumi.getter(name="diskEncryptionKeys")
    def disk_encryption_keys(self) -> Sequence['outputs.GetInstanceTemplateDiskDiskEncryptionKeyResult']:
        """
        Encrypts or decrypts a disk using a customer-supplied encryption key.
        """
        return pulumi.get(self, "disk_encryption_keys")

    @property
    @pulumi.getter(name="diskName")
    def disk_name(self) -> str:
        """
        Name of the disk. When not provided, this defaults
        to the name of the instance.
        """
        return pulumi.get(self, "disk_name")

    @property
    @pulumi.getter(name="diskSizeGb")
    def disk_size_gb(self) -> 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")

    @property
    @pulumi.getter(name="diskType")
    def disk_type(self) -> str:
        """
        The GCE disk type. Such as `"pd-ssd"`, `"local-ssd"`,
        `"pd-balanced"` or `"pd-standard"`.
        """
        return pulumi.get(self, "disk_type")

    @property
    @pulumi.getter
    def interface(self) -> 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")

    @property
    @pulumi.getter
    def labels(self) -> Mapping[str, str]:
        """
        (Optional) A set of ket/value label pairs to assign to disk created from
        this template
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter
    def mode(self) -> 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")

    @property
    @pulumi.getter(name="resourcePolicies")
    def resource_policies(self) -> Sequence[str]:
        """
        (Optional) -- A list of short names 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")

    @property
    @pulumi.getter
    def source(self) -> 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")

    @property
    @pulumi.getter(name="sourceImage")
    def source_image(self) -> 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")

    @property
    @pulumi.getter(name="sourceImageEncryptionKeys")
    def source_image_encryption_keys(self) -> Sequence['outputs.GetInstanceTemplateDiskSourceImageEncryptionKeyResult']:
        return pulumi.get(self, "source_image_encryption_keys")

    @property
    @pulumi.getter(name="sourceSnapshot")
    def source_snapshot(self) -> str:
        return pulumi.get(self, "source_snapshot")

    @property
    @pulumi.getter(name="sourceSnapshotEncryptionKeys")
    def source_snapshot_encryption_keys(self) -> Sequence['outputs.GetInstanceTemplateDiskSourceSnapshotEncryptionKeyResult']:
        return pulumi.get(self, "source_snapshot_encryption_keys")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The accelerator type resource to expose to this instance. E.g. `nvidia-tesla-k80`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetInstanceTemplateDiskDiskEncryptionKeyResult(dict):
    def __init__(__self__, *,
                 kms_key_self_link: str):
        """
        :param 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) -> str:
        """
        The self link of the encryption key that is stored in Google Cloud KMS
        """
        return pulumi.get(self, "kms_key_self_link")


@pulumi.output_type
class GetInstanceTemplateDiskSourceImageEncryptionKeyResult(dict):
    def __init__(__self__, *,
                 kms_key_self_link: str,
                 kms_key_service_account: str):
        """
        :param 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)
        pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)

    @property
    @pulumi.getter(name="kmsKeySelfLink")
    def kms_key_self_link(self) -> str:
        """
        The self link of the encryption key that is stored in Google Cloud KMS
        """
        return pulumi.get(self, "kms_key_self_link")

    @property
    @pulumi.getter(name="kmsKeyServiceAccount")
    def kms_key_service_account(self) -> str:
        return pulumi.get(self, "kms_key_service_account")


@pulumi.output_type
class GetInstanceTemplateDiskSourceSnapshotEncryptionKeyResult(dict):
    def __init__(__self__, *,
                 kms_key_self_link: str,
                 kms_key_service_account: str):
        """
        :param 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)
        pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)

    @property
    @pulumi.getter(name="kmsKeySelfLink")
    def kms_key_self_link(self) -> str:
        """
        The self link of the encryption key that is stored in Google Cloud KMS
        """
        return pulumi.get(self, "kms_key_self_link")

    @property
    @pulumi.getter(name="kmsKeyServiceAccount")
    def kms_key_service_account(self) -> str:
        return pulumi.get(self, "kms_key_service_account")


@pulumi.output_type
class GetInstanceTemplateGuestAcceleratorResult(dict):
    def __init__(__self__, *,
                 count: int,
                 type: str):
        """
        :param int count: The number of the guest accelerator cards exposed to this instance.
        :param str type: The accelerator type resource to expose to this instance. E.g. `nvidia-tesla-k80`.
        """
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def count(self) -> int:
        """
        The number of the guest accelerator cards exposed to this instance.
        """
        return pulumi.get(self, "count")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The accelerator type resource to expose to this instance. E.g. `nvidia-tesla-k80`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetInstanceTemplateNetworkInterfaceResult(dict):
    def __init__(__self__, *,
                 access_configs: Sequence['outputs.GetInstanceTemplateNetworkInterfaceAccessConfigResult'],
                 alias_ip_ranges: Sequence['outputs.GetInstanceTemplateNetworkInterfaceAliasIpRangeResult'],
                 ipv6_access_configs: Sequence['outputs.GetInstanceTemplateNetworkInterfaceIpv6AccessConfigResult'],
                 ipv6_access_type: str,
                 name: str,
                 network: str,
                 network_ip: str,
                 nic_type: str,
                 queue_count: int,
                 stack_type: str,
                 subnetwork: str,
                 subnetwork_project: str):
        """
        :param Sequence['GetInstanceTemplateNetworkInterfaceAccessConfigArgs'] 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 are running the prvovider 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 Sequence['GetInstanceTemplateNetworkInterfaceAliasIpRangeArgs'] 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 str name: The name of the instance template. One of `name` or `filter` must be provided.
        :param 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 str network_ip: The private IP address to assign to the instance. If
               empty, the address will be automatically assigned.
        :param 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 str subnetwork_project: The ID of the project in which the subnetwork belongs.
               If it is not provided, the provider project is used.
        """
        pulumi.set(__self__, "access_configs", access_configs)
        pulumi.set(__self__, "alias_ip_ranges", alias_ip_ranges)
        pulumi.set(__self__, "ipv6_access_configs", ipv6_access_configs)
        pulumi.set(__self__, "ipv6_access_type", ipv6_access_type)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "network_ip", network_ip)
        pulumi.set(__self__, "nic_type", nic_type)
        pulumi.set(__self__, "queue_count", queue_count)
        pulumi.set(__self__, "stack_type", stack_type)
        pulumi.set(__self__, "subnetwork", subnetwork)
        pulumi.set(__self__, "subnetwork_project", subnetwork_project)

    @property
    @pulumi.getter(name="accessConfigs")
    def access_configs(self) -> Sequence['outputs.GetInstanceTemplateNetworkInterfaceAccessConfigResult']:
        """
        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 are running the prvovider 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")

    @property
    @pulumi.getter(name="aliasIpRanges")
    def alias_ip_ranges(self) -> Sequence['outputs.GetInstanceTemplateNetworkInterfaceAliasIpRangeResult']:
        """
        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")

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

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

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the instance template. One of `name` or `filter` must be provided.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def network(self) -> 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")

    @property
    @pulumi.getter(name="networkIp")
    def network_ip(self) -> str:
        """
        The private IP address to assign to the instance. If
        empty, the address will be automatically assigned.
        """
        return pulumi.get(self, "network_ip")

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

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

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

    @property
    @pulumi.getter
    def subnetwork(self) -> 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")

    @property
    @pulumi.getter(name="subnetworkProject")
    def subnetwork_project(self) -> 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")


@pulumi.output_type
class GetInstanceTemplateNetworkInterfaceAccessConfigResult(dict):
    def __init__(__self__, *,
                 nat_ip: str,
                 network_tier: str,
                 public_ptr_domain_name: str):
        """
        :param 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 str network_tier: The [networking tier][network-tier] used for configuring
               this instance template. This field can take the following values: PREMIUM or
               STANDARD. If this field is not specified, it is assumed to be PREMIUM.
        """
        pulumi.set(__self__, "nat_ip", nat_ip)
        pulumi.set(__self__, "network_tier", network_tier)
        pulumi.set(__self__, "public_ptr_domain_name", public_ptr_domain_name)

    @property
    @pulumi.getter(name="natIp")
    def nat_ip(self) -> 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")

    @property
    @pulumi.getter(name="networkTier")
    def network_tier(self) -> str:
        """
        The [networking tier][network-tier] used for configuring
        this instance template. This field can take the following values: PREMIUM or
        STANDARD. If this field is not specified, it is assumed to be PREMIUM.
        """
        return pulumi.get(self, "network_tier")

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


@pulumi.output_type
class GetInstanceTemplateNetworkInterfaceAliasIpRangeResult(dict):
    def __init__(__self__, *,
                 ip_cidr_range: str,
                 subnetwork_range_name: str):
        """
        :param 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 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)
        pulumi.set(__self__, "subnetwork_range_name", subnetwork_range_name)

    @property
    @pulumi.getter(name="ipCidrRange")
    def ip_cidr_range(self) -> 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")

    @property
    @pulumi.getter(name="subnetworkRangeName")
    def subnetwork_range_name(self) -> 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")


@pulumi.output_type
class GetInstanceTemplateNetworkInterfaceIpv6AccessConfigResult(dict):
    def __init__(__self__, *,
                 external_ipv6: str,
                 external_ipv6_prefix_length: str,
                 network_tier: str,
                 public_ptr_domain_name: str):
        """
        :param str network_tier: The [networking tier][network-tier] used for configuring
               this instance template. This field can take the following values: PREMIUM or
               STANDARD. If this field is not specified, it is assumed to be PREMIUM.
        """
        pulumi.set(__self__, "external_ipv6", external_ipv6)
        pulumi.set(__self__, "external_ipv6_prefix_length", external_ipv6_prefix_length)
        pulumi.set(__self__, "network_tier", network_tier)
        pulumi.set(__self__, "public_ptr_domain_name", public_ptr_domain_name)

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

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

    @property
    @pulumi.getter(name="networkTier")
    def network_tier(self) -> str:
        """
        The [networking tier][network-tier] used for configuring
        this instance template. This field can take the following values: PREMIUM or
        STANDARD. If this field is not specified, it is assumed to be PREMIUM.
        """
        return pulumi.get(self, "network_tier")

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


@pulumi.output_type
class GetInstanceTemplateNetworkPerformanceConfigResult(dict):
    def __init__(__self__, *,
                 total_egress_bandwidth_tier: str):
        """
        :param str total_egress_bandwidth_tier: The egress bandwidth tier for the instance.
        """
        pulumi.set(__self__, "total_egress_bandwidth_tier", total_egress_bandwidth_tier)

    @property
    @pulumi.getter(name="totalEgressBandwidthTier")
    def total_egress_bandwidth_tier(self) -> str:
        """
        The egress bandwidth tier for the instance.
        """
        return pulumi.get(self, "total_egress_bandwidth_tier")


@pulumi.output_type
class GetInstanceTemplateReservationAffinityResult(dict):
    def __init__(__self__, *,
                 specific_reservations: Sequence['outputs.GetInstanceTemplateReservationAffinitySpecificReservationResult'],
                 type: str):
        """
        :param str type: The accelerator type resource to expose to this instance. E.g. `nvidia-tesla-k80`.
        """
        pulumi.set(__self__, "specific_reservations", specific_reservations)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="specificReservations")
    def specific_reservations(self) -> Sequence['outputs.GetInstanceTemplateReservationAffinitySpecificReservationResult']:
        return pulumi.get(self, "specific_reservations")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The accelerator type resource to expose to this instance. E.g. `nvidia-tesla-k80`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetInstanceTemplateReservationAffinitySpecificReservationResult(dict):
    def __init__(__self__, *,
                 key: str,
                 values: Sequence[str]):
        """
        :param str key: The key for the node affinity label.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The key for the node affinity label.
        """
        return pulumi.get(self, "key")

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


@pulumi.output_type
class GetInstanceTemplateSchedulingResult(dict):
    def __init__(__self__, *,
                 automatic_restart: bool,
                 instance_termination_action: str,
                 max_run_durations: Sequence['outputs.GetInstanceTemplateSchedulingMaxRunDurationResult'],
                 min_node_cpus: int,
                 node_affinities: Sequence['outputs.GetInstanceTemplateSchedulingNodeAffinityResult'],
                 on_host_maintenance: str,
                 preemptible: bool,
                 provisioning_model: str):
        """
        :param 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 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 Sequence['GetInstanceTemplateSchedulingNodeAffinityArgs'] 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 str on_host_maintenance: Defines the maintenance behavior for this
               instance.
        :param 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 str provisioning_model: Describe the type of preemptible VM.
        """
        pulumi.set(__self__, "automatic_restart", automatic_restart)
        pulumi.set(__self__, "instance_termination_action", instance_termination_action)
        pulumi.set(__self__, "max_run_durations", max_run_durations)
        pulumi.set(__self__, "min_node_cpus", min_node_cpus)
        pulumi.set(__self__, "node_affinities", node_affinities)
        pulumi.set(__self__, "on_host_maintenance", on_host_maintenance)
        pulumi.set(__self__, "preemptible", preemptible)
        pulumi.set(__self__, "provisioning_model", provisioning_model)

    @property
    @pulumi.getter(name="automaticRestart")
    def automatic_restart(self) -> 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")

    @property
    @pulumi.getter(name="instanceTerminationAction")
    def instance_termination_action(self) -> 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")

    @property
    @pulumi.getter(name="maxRunDurations")
    def max_run_durations(self) -> Sequence['outputs.GetInstanceTemplateSchedulingMaxRunDurationResult']:
        return pulumi.get(self, "max_run_durations")

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

    @property
    @pulumi.getter(name="nodeAffinities")
    def node_affinities(self) -> Sequence['outputs.GetInstanceTemplateSchedulingNodeAffinityResult']:
        """
        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")

    @property
    @pulumi.getter(name="onHostMaintenance")
    def on_host_maintenance(self) -> str:
        """
        Defines the maintenance behavior for this
        instance.
        """
        return pulumi.get(self, "on_host_maintenance")

    @property
    @pulumi.getter
    def preemptible(self) -> 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")

    @property
    @pulumi.getter(name="provisioningModel")
    def provisioning_model(self) -> str:
        """
        Describe the type of preemptible VM.
        """
        return pulumi.get(self, "provisioning_model")


@pulumi.output_type
class GetInstanceTemplateSchedulingMaxRunDurationResult(dict):
    def __init__(__self__, *,
                 nanos: int,
                 seconds: int):
        pulumi.set(__self__, "nanos", nanos)
        pulumi.set(__self__, "seconds", seconds)

    @property
    @pulumi.getter
    def nanos(self) -> int:
        return pulumi.get(self, "nanos")

    @property
    @pulumi.getter
    def seconds(self) -> int:
        return pulumi.get(self, "seconds")


@pulumi.output_type
class GetInstanceTemplateSchedulingNodeAffinityResult(dict):
    def __init__(__self__, *,
                 key: str,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str key: The key for the node affinity label.
        :param str operator: The operator. Can be `IN` for node-affinities
               or `NOT_IN` for anti-affinities.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The key for the node affinity label.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The operator. Can be `IN` for node-affinities
        or `NOT_IN` for anti-affinities.
        """
        return pulumi.get(self, "operator")

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


@pulumi.output_type
class GetInstanceTemplateServiceAccountResult(dict):
    def __init__(__self__, *,
                 email: str,
                 scopes: Sequence[str]):
        """
        :param str email: The service account e-mail address. If not given, the
               default Google Compute Engine service account is used.
        :param Sequence[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).
        """
        pulumi.set(__self__, "email", email)
        pulumi.set(__self__, "scopes", scopes)

    @property
    @pulumi.getter
    def email(self) -> str:
        """
        The service account e-mail address. If not given, the
        default Google Compute Engine service account is used.
        """
        return pulumi.get(self, "email")

    @property
    @pulumi.getter
    def scopes(self) -> Sequence[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")


@pulumi.output_type
class GetInstanceTemplateShieldedInstanceConfigResult(dict):
    def __init__(__self__, *,
                 enable_integrity_monitoring: bool,
                 enable_secure_boot: bool,
                 enable_vtpm: bool):
        """
        :param 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 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 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.
        """
        pulumi.set(__self__, "enable_integrity_monitoring", enable_integrity_monitoring)
        pulumi.set(__self__, "enable_secure_boot", enable_secure_boot)
        pulumi.set(__self__, "enable_vtpm", enable_vtpm)

    @property
    @pulumi.getter(name="enableIntegrityMonitoring")
    def enable_integrity_monitoring(self) -> 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")

    @property
    @pulumi.getter(name="enableSecureBoot")
    def enable_secure_boot(self) -> 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")

    @property
    @pulumi.getter(name="enableVtpm")
    def enable_vtpm(self) -> 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")


@pulumi.output_type
class GetRegionInstanceGroupInstanceResult(dict):
    def __init__(__self__, *,
                 instance: str,
                 named_ports: Sequence['outputs.GetRegionInstanceGroupInstanceNamedPortResult'],
                 status: str):
        """
        :param str instance: URL to the instance.
        :param Sequence['GetRegionInstanceGroupInstanceNamedPortArgs'] named_ports: List of named ports in the group, as a list of resources, each containing:
        :param str status: String description of current state of the instance.
        """
        pulumi.set(__self__, "instance", instance)
        pulumi.set(__self__, "named_ports", named_ports)
        pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter
    def instance(self) -> str:
        """
        URL to the instance.
        """
        return pulumi.get(self, "instance")

    @property
    @pulumi.getter(name="namedPorts")
    def named_ports(self) -> Sequence['outputs.GetRegionInstanceGroupInstanceNamedPortResult']:
        """
        List of named ports in the group, as a list of resources, each containing:
        """
        return pulumi.get(self, "named_ports")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        String description of current state of the instance.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetRegionInstanceGroupInstanceNamedPortResult(dict):
    def __init__(__self__, *,
                 name: str,
                 port: int):
        """
        :param str name: The name of the instance group.  One of `name` or `self_link` must be provided.
        :param int port: Integer port number
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the instance group.  One of `name` or `self_link` must be provided.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        Integer port number
        """
        return pulumi.get(self, "port")


@pulumi.output_type
class GetRegionNetworkEndpointGroupAppEngineResult(dict):
    def __init__(__self__, *,
                 service: str,
                 url_mask: str,
                 version: str):
        pulumi.set(__self__, "service", service)
        pulumi.set(__self__, "url_mask", url_mask)
        pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def service(self) -> str:
        return pulumi.get(self, "service")

    @property
    @pulumi.getter(name="urlMask")
    def url_mask(self) -> str:
        return pulumi.get(self, "url_mask")

    @property
    @pulumi.getter
    def version(self) -> str:
        return pulumi.get(self, "version")


@pulumi.output_type
class GetRegionNetworkEndpointGroupCloudFunctionResult(dict):
    def __init__(__self__, *,
                 function: str,
                 url_mask: str):
        pulumi.set(__self__, "function", function)
        pulumi.set(__self__, "url_mask", url_mask)

    @property
    @pulumi.getter
    def function(self) -> str:
        return pulumi.get(self, "function")

    @property
    @pulumi.getter(name="urlMask")
    def url_mask(self) -> str:
        return pulumi.get(self, "url_mask")


@pulumi.output_type
class GetRegionNetworkEndpointGroupCloudRunResult(dict):
    def __init__(__self__, *,
                 service: str,
                 tag: str,
                 url_mask: str):
        pulumi.set(__self__, "service", service)
        pulumi.set(__self__, "tag", tag)
        pulumi.set(__self__, "url_mask", url_mask)

    @property
    @pulumi.getter
    def service(self) -> str:
        return pulumi.get(self, "service")

    @property
    @pulumi.getter
    def tag(self) -> str:
        return pulumi.get(self, "tag")

    @property
    @pulumi.getter(name="urlMask")
    def url_mask(self) -> str:
        return pulumi.get(self, "url_mask")


@pulumi.output_type
class GetRegionNetworkEndpointGroupServerlessDeploymentResult(dict):
    def __init__(__self__, *,
                 platform: str,
                 resource: str,
                 url_mask: str,
                 version: str):
        pulumi.set(__self__, "platform", platform)
        pulumi.set(__self__, "resource", resource)
        pulumi.set(__self__, "url_mask", url_mask)
        pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def platform(self) -> str:
        return pulumi.get(self, "platform")

    @property
    @pulumi.getter
    def resource(self) -> str:
        return pulumi.get(self, "resource")

    @property
    @pulumi.getter(name="urlMask")
    def url_mask(self) -> str:
        return pulumi.get(self, "url_mask")

    @property
    @pulumi.getter
    def version(self) -> str:
        return pulumi.get(self, "version")


@pulumi.output_type
class GetResourcePolicyGroupPlacementPolicyResult(dict):
    def __init__(__self__, *,
                 availability_domain_count: int,
                 collocation: str,
                 max_distance: int,
                 vm_count: int):
        pulumi.set(__self__, "availability_domain_count", availability_domain_count)
        pulumi.set(__self__, "collocation", collocation)
        pulumi.set(__self__, "max_distance", max_distance)
        pulumi.set(__self__, "vm_count", vm_count)

    @property
    @pulumi.getter(name="availabilityDomainCount")
    def availability_domain_count(self) -> int:
        return pulumi.get(self, "availability_domain_count")

    @property
    @pulumi.getter
    def collocation(self) -> str:
        return pulumi.get(self, "collocation")

    @property
    @pulumi.getter(name="maxDistance")
    def max_distance(self) -> int:
        return pulumi.get(self, "max_distance")

    @property
    @pulumi.getter(name="vmCount")
    def vm_count(self) -> int:
        return pulumi.get(self, "vm_count")


@pulumi.output_type
class GetResourcePolicyInstanceSchedulePolicyResult(dict):
    def __init__(__self__, *,
                 expiration_time: str,
                 start_time: str,
                 time_zone: str,
                 vm_start_schedules: Sequence['outputs.GetResourcePolicyInstanceSchedulePolicyVmStartScheduleResult'],
                 vm_stop_schedules: Sequence['outputs.GetResourcePolicyInstanceSchedulePolicyVmStopScheduleResult']):
        pulumi.set(__self__, "expiration_time", expiration_time)
        pulumi.set(__self__, "start_time", start_time)
        pulumi.set(__self__, "time_zone", time_zone)
        pulumi.set(__self__, "vm_start_schedules", vm_start_schedules)
        pulumi.set(__self__, "vm_stop_schedules", vm_stop_schedules)

    @property
    @pulumi.getter(name="expirationTime")
    def expiration_time(self) -> str:
        return pulumi.get(self, "expiration_time")

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> str:
        return pulumi.get(self, "start_time")

    @property
    @pulumi.getter(name="timeZone")
    def time_zone(self) -> str:
        return pulumi.get(self, "time_zone")

    @property
    @pulumi.getter(name="vmStartSchedules")
    def vm_start_schedules(self) -> Sequence['outputs.GetResourcePolicyInstanceSchedulePolicyVmStartScheduleResult']:
        return pulumi.get(self, "vm_start_schedules")

    @property
    @pulumi.getter(name="vmStopSchedules")
    def vm_stop_schedules(self) -> Sequence['outputs.GetResourcePolicyInstanceSchedulePolicyVmStopScheduleResult']:
        return pulumi.get(self, "vm_stop_schedules")


@pulumi.output_type
class GetResourcePolicyInstanceSchedulePolicyVmStartScheduleResult(dict):
    def __init__(__self__, *,
                 schedule: str):
        pulumi.set(__self__, "schedule", schedule)

    @property
    @pulumi.getter
    def schedule(self) -> str:
        return pulumi.get(self, "schedule")


@pulumi.output_type
class GetResourcePolicyInstanceSchedulePolicyVmStopScheduleResult(dict):
    def __init__(__self__, *,
                 schedule: str):
        pulumi.set(__self__, "schedule", schedule)

    @property
    @pulumi.getter
    def schedule(self) -> str:
        return pulumi.get(self, "schedule")


@pulumi.output_type
class GetResourcePolicySnapshotSchedulePolicyResult(dict):
    def __init__(__self__, *,
                 retention_policies: Sequence['outputs.GetResourcePolicySnapshotSchedulePolicyRetentionPolicyResult'],
                 schedules: Sequence['outputs.GetResourcePolicySnapshotSchedulePolicyScheduleResult'],
                 snapshot_properties: Sequence['outputs.GetResourcePolicySnapshotSchedulePolicySnapshotPropertyResult']):
        pulumi.set(__self__, "retention_policies", retention_policies)
        pulumi.set(__self__, "schedules", schedules)
        pulumi.set(__self__, "snapshot_properties", snapshot_properties)

    @property
    @pulumi.getter(name="retentionPolicies")
    def retention_policies(self) -> Sequence['outputs.GetResourcePolicySnapshotSchedulePolicyRetentionPolicyResult']:
        return pulumi.get(self, "retention_policies")

    @property
    @pulumi.getter
    def schedules(self) -> Sequence['outputs.GetResourcePolicySnapshotSchedulePolicyScheduleResult']:
        return pulumi.get(self, "schedules")

    @property
    @pulumi.getter(name="snapshotProperties")
    def snapshot_properties(self) -> Sequence['outputs.GetResourcePolicySnapshotSchedulePolicySnapshotPropertyResult']:
        return pulumi.get(self, "snapshot_properties")


@pulumi.output_type
class GetResourcePolicySnapshotSchedulePolicyRetentionPolicyResult(dict):
    def __init__(__self__, *,
                 max_retention_days: int,
                 on_source_disk_delete: str):
        pulumi.set(__self__, "max_retention_days", max_retention_days)
        pulumi.set(__self__, "on_source_disk_delete", on_source_disk_delete)

    @property
    @pulumi.getter(name="maxRetentionDays")
    def max_retention_days(self) -> int:
        return pulumi.get(self, "max_retention_days")

    @property
    @pulumi.getter(name="onSourceDiskDelete")
    def on_source_disk_delete(self) -> str:
        return pulumi.get(self, "on_source_disk_delete")


@pulumi.output_type
class GetResourcePolicySnapshotSchedulePolicyScheduleResult(dict):
    def __init__(__self__, *,
                 daily_schedules: Sequence['outputs.GetResourcePolicySnapshotSchedulePolicyScheduleDailyScheduleResult'],
                 hourly_schedules: Sequence['outputs.GetResourcePolicySnapshotSchedulePolicyScheduleHourlyScheduleResult'],
                 weekly_schedules: Sequence['outputs.GetResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleResult']):
        pulumi.set(__self__, "daily_schedules", daily_schedules)
        pulumi.set(__self__, "hourly_schedules", hourly_schedules)
        pulumi.set(__self__, "weekly_schedules", weekly_schedules)

    @property
    @pulumi.getter(name="dailySchedules")
    def daily_schedules(self) -> Sequence['outputs.GetResourcePolicySnapshotSchedulePolicyScheduleDailyScheduleResult']:
        return pulumi.get(self, "daily_schedules")

    @property
    @pulumi.getter(name="hourlySchedules")
    def hourly_schedules(self) -> Sequence['outputs.GetResourcePolicySnapshotSchedulePolicyScheduleHourlyScheduleResult']:
        return pulumi.get(self, "hourly_schedules")

    @property
    @pulumi.getter(name="weeklySchedules")
    def weekly_schedules(self) -> Sequence['outputs.GetResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleResult']:
        return pulumi.get(self, "weekly_schedules")


@pulumi.output_type
class GetResourcePolicySnapshotSchedulePolicyScheduleDailyScheduleResult(dict):
    def __init__(__self__, *,
                 days_in_cycle: int,
                 start_time: str):
        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) -> int:
        return pulumi.get(self, "days_in_cycle")

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> str:
        return pulumi.get(self, "start_time")


@pulumi.output_type
class GetResourcePolicySnapshotSchedulePolicyScheduleHourlyScheduleResult(dict):
    def __init__(__self__, *,
                 hours_in_cycle: int,
                 start_time: str):
        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) -> int:
        return pulumi.get(self, "hours_in_cycle")

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> str:
        return pulumi.get(self, "start_time")


@pulumi.output_type
class GetResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleResult(dict):
    def __init__(__self__, *,
                 day_of_weeks: Sequence['outputs.GetResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleDayOfWeekResult']):
        pulumi.set(__self__, "day_of_weeks", day_of_weeks)

    @property
    @pulumi.getter(name="dayOfWeeks")
    def day_of_weeks(self) -> Sequence['outputs.GetResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleDayOfWeekResult']:
        return pulumi.get(self, "day_of_weeks")


@pulumi.output_type
class GetResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleDayOfWeekResult(dict):
    def __init__(__self__, *,
                 day: str,
                 start_time: str):
        pulumi.set(__self__, "day", day)
        pulumi.set(__self__, "start_time", start_time)

    @property
    @pulumi.getter
    def day(self) -> str:
        return pulumi.get(self, "day")

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> str:
        return pulumi.get(self, "start_time")


@pulumi.output_type
class GetResourcePolicySnapshotSchedulePolicySnapshotPropertyResult(dict):
    def __init__(__self__, *,
                 chain_name: str,
                 guest_flush: bool,
                 labels: Mapping[str, str],
                 storage_locations: Sequence[str]):
        pulumi.set(__self__, "chain_name", chain_name)
        pulumi.set(__self__, "guest_flush", guest_flush)
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "storage_locations", storage_locations)

    @property
    @pulumi.getter(name="chainName")
    def chain_name(self) -> str:
        return pulumi.get(self, "chain_name")

    @property
    @pulumi.getter(name="guestFlush")
    def guest_flush(self) -> bool:
        return pulumi.get(self, "guest_flush")

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

    @property
    @pulumi.getter(name="storageLocations")
    def storage_locations(self) -> Sequence[str]:
        return pulumi.get(self, "storage_locations")


@pulumi.output_type
class GetRouterBgpResult(dict):
    def __init__(__self__, *,
                 advertise_mode: str,
                 advertised_groups: Sequence[str],
                 advertised_ip_ranges: Sequence['outputs.GetRouterBgpAdvertisedIpRangeResult'],
                 asn: int,
                 keepalive_interval: int):
        pulumi.set(__self__, "advertise_mode", advertise_mode)
        pulumi.set(__self__, "advertised_groups", advertised_groups)
        pulumi.set(__self__, "advertised_ip_ranges", advertised_ip_ranges)
        pulumi.set(__self__, "asn", asn)
        pulumi.set(__self__, "keepalive_interval", keepalive_interval)

    @property
    @pulumi.getter(name="advertiseMode")
    def advertise_mode(self) -> str:
        return pulumi.get(self, "advertise_mode")

    @property
    @pulumi.getter(name="advertisedGroups")
    def advertised_groups(self) -> Sequence[str]:
        return pulumi.get(self, "advertised_groups")

    @property
    @pulumi.getter(name="advertisedIpRanges")
    def advertised_ip_ranges(self) -> Sequence['outputs.GetRouterBgpAdvertisedIpRangeResult']:
        return pulumi.get(self, "advertised_ip_ranges")

    @property
    @pulumi.getter
    def asn(self) -> int:
        return pulumi.get(self, "asn")

    @property
    @pulumi.getter(name="keepaliveInterval")
    def keepalive_interval(self) -> int:
        return pulumi.get(self, "keepalive_interval")


@pulumi.output_type
class GetRouterBgpAdvertisedIpRangeResult(dict):
    def __init__(__self__, *,
                 description: str,
                 range: str):
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "range", range)

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

    @property
    @pulumi.getter
    def range(self) -> str:
        return pulumi.get(self, "range")


@pulumi.output_type
class GetRouterNatLogConfigResult(dict):
    def __init__(__self__, *,
                 enable: bool,
                 filter: str):
        pulumi.set(__self__, "enable", enable)
        pulumi.set(__self__, "filter", filter)

    @property
    @pulumi.getter
    def enable(self) -> bool:
        return pulumi.get(self, "enable")

    @property
    @pulumi.getter
    def filter(self) -> str:
        return pulumi.get(self, "filter")


@pulumi.output_type
class GetRouterNatRuleResult(dict):
    def __init__(__self__, *,
                 actions: Sequence['outputs.GetRouterNatRuleActionResult'],
                 description: str,
                 match: str,
                 rule_number: int):
        pulumi.set(__self__, "actions", actions)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "match", match)
        pulumi.set(__self__, "rule_number", rule_number)

    @property
    @pulumi.getter
    def actions(self) -> Sequence['outputs.GetRouterNatRuleActionResult']:
        return pulumi.get(self, "actions")

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

    @property
    @pulumi.getter
    def match(self) -> str:
        return pulumi.get(self, "match")

    @property
    @pulumi.getter(name="ruleNumber")
    def rule_number(self) -> int:
        return pulumi.get(self, "rule_number")


@pulumi.output_type
class GetRouterNatRuleActionResult(dict):
    def __init__(__self__, *,
                 source_nat_active_ips: Sequence[str],
                 source_nat_drain_ips: Sequence[str]):
        pulumi.set(__self__, "source_nat_active_ips", source_nat_active_ips)
        pulumi.set(__self__, "source_nat_drain_ips", source_nat_drain_ips)

    @property
    @pulumi.getter(name="sourceNatActiveIps")
    def source_nat_active_ips(self) -> Sequence[str]:
        return pulumi.get(self, "source_nat_active_ips")

    @property
    @pulumi.getter(name="sourceNatDrainIps")
    def source_nat_drain_ips(self) -> Sequence[str]:
        return pulumi.get(self, "source_nat_drain_ips")


@pulumi.output_type
class GetRouterNatSubnetworkResult(dict):
    def __init__(__self__, *,
                 name: str,
                 secondary_ip_range_names: Sequence[str],
                 source_ip_ranges_to_nats: Sequence[str]):
        """
        :param str name: Name of the NAT service. The name must be 1-63 characters long and
               comply with RFC1035.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "secondary_ip_range_names", secondary_ip_range_names)
        pulumi.set(__self__, "source_ip_ranges_to_nats", source_ip_ranges_to_nats)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the NAT service. The name must be 1-63 characters long and
        comply with RFC1035.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="secondaryIpRangeNames")
    def secondary_ip_range_names(self) -> Sequence[str]:
        return pulumi.get(self, "secondary_ip_range_names")

    @property
    @pulumi.getter(name="sourceIpRangesToNats")
    def source_ip_ranges_to_nats(self) -> Sequence[str]:
        return pulumi.get(self, "source_ip_ranges_to_nats")


@pulumi.output_type
class GetRouterStatusBestRouteResult(dict):
    def __init__(__self__, *,
                 description: str,
                 dest_range: str,
                 name: str,
                 network: str,
                 next_hop_gateway: str,
                 next_hop_ilb: str,
                 next_hop_instance: str,
                 next_hop_instance_zone: str,
                 next_hop_ip: str,
                 next_hop_network: str,
                 next_hop_vpn_tunnel: str,
                 priority: int,
                 project: str,
                 self_link: str,
                 tags: Sequence[str]):
        """
        :param str name: The name of the router.
        :param str network: The network name or resource link to the parent
               network of this subnetwork.
        :param str project: The ID of the project in which the resource
               belongs. If it is not provided, the provider project is used.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "dest_range", dest_range)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "next_hop_gateway", next_hop_gateway)
        pulumi.set(__self__, "next_hop_ilb", next_hop_ilb)
        pulumi.set(__self__, "next_hop_instance", next_hop_instance)
        pulumi.set(__self__, "next_hop_instance_zone", next_hop_instance_zone)
        pulumi.set(__self__, "next_hop_ip", next_hop_ip)
        pulumi.set(__self__, "next_hop_network", next_hop_network)
        pulumi.set(__self__, "next_hop_vpn_tunnel", next_hop_vpn_tunnel)
        pulumi.set(__self__, "priority", priority)
        pulumi.set(__self__, "project", project)
        pulumi.set(__self__, "self_link", self_link)
        pulumi.set(__self__, "tags", tags)

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

    @property
    @pulumi.getter(name="destRange")
    def dest_range(self) -> str:
        return pulumi.get(self, "dest_range")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the router.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def network(self) -> str:
        """
        The network name or resource link to the parent
        network of this subnetwork.
        """
        return pulumi.get(self, "network")

    @property
    @pulumi.getter(name="nextHopGateway")
    def next_hop_gateway(self) -> str:
        return pulumi.get(self, "next_hop_gateway")

    @property
    @pulumi.getter(name="nextHopIlb")
    def next_hop_ilb(self) -> str:
        return pulumi.get(self, "next_hop_ilb")

    @property
    @pulumi.getter(name="nextHopInstance")
    def next_hop_instance(self) -> str:
        return pulumi.get(self, "next_hop_instance")

    @property
    @pulumi.getter(name="nextHopInstanceZone")
    def next_hop_instance_zone(self) -> str:
        return pulumi.get(self, "next_hop_instance_zone")

    @property
    @pulumi.getter(name="nextHopIp")
    def next_hop_ip(self) -> str:
        return pulumi.get(self, "next_hop_ip")

    @property
    @pulumi.getter(name="nextHopNetwork")
    def next_hop_network(self) -> str:
        return pulumi.get(self, "next_hop_network")

    @property
    @pulumi.getter(name="nextHopVpnTunnel")
    def next_hop_vpn_tunnel(self) -> str:
        return pulumi.get(self, "next_hop_vpn_tunnel")

    @property
    @pulumi.getter
    def priority(self) -> int:
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter
    def project(self) -> str:
        """
        The ID of the project in which the resource
        belongs. If it is not provided, the provider project is used.
        """
        return pulumi.get(self, "project")

    @property
    @pulumi.getter(name="selfLink")
    def self_link(self) -> str:
        return pulumi.get(self, "self_link")

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


@pulumi.output_type
class GetRouterStatusBestRoutesForRouterResult(dict):
    def __init__(__self__, *,
                 description: str,
                 dest_range: str,
                 name: str,
                 network: str,
                 next_hop_gateway: str,
                 next_hop_ilb: str,
                 next_hop_instance: str,
                 next_hop_instance_zone: str,
                 next_hop_ip: str,
                 next_hop_network: str,
                 next_hop_vpn_tunnel: str,
                 priority: int,
                 project: str,
                 self_link: str,
                 tags: Sequence[str]):
        """
        :param str name: The name of the router.
        :param str network: The network name or resource link to the parent
               network of this subnetwork.
        :param str project: The ID of the project in which the resource
               belongs. If it is not provided, the provider project is used.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "dest_range", dest_range)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "next_hop_gateway", next_hop_gateway)
        pulumi.set(__self__, "next_hop_ilb", next_hop_ilb)
        pulumi.set(__self__, "next_hop_instance", next_hop_instance)
        pulumi.set(__self__, "next_hop_instance_zone", next_hop_instance_zone)
        pulumi.set(__self__, "next_hop_ip", next_hop_ip)
        pulumi.set(__self__, "next_hop_network", next_hop_network)
        pulumi.set(__self__, "next_hop_vpn_tunnel", next_hop_vpn_tunnel)
        pulumi.set(__self__, "priority", priority)
        pulumi.set(__self__, "project", project)
        pulumi.set(__self__, "self_link", self_link)
        pulumi.set(__self__, "tags", tags)

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

    @property
    @pulumi.getter(name="destRange")
    def dest_range(self) -> str:
        return pulumi.get(self, "dest_range")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the router.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def network(self) -> str:
        """
        The network name or resource link to the parent
        network of this subnetwork.
        """
        return pulumi.get(self, "network")

    @property
    @pulumi.getter(name="nextHopGateway")
    def next_hop_gateway(self) -> str:
        return pulumi.get(self, "next_hop_gateway")

    @property
    @pulumi.getter(name="nextHopIlb")
    def next_hop_ilb(self) -> str:
        return pulumi.get(self, "next_hop_ilb")

    @property
    @pulumi.getter(name="nextHopInstance")
    def next_hop_instance(self) -> str:
        return pulumi.get(self, "next_hop_instance")

    @property
    @pulumi.getter(name="nextHopInstanceZone")
    def next_hop_instance_zone(self) -> str:
        return pulumi.get(self, "next_hop_instance_zone")

    @property
    @pulumi.getter(name="nextHopIp")
    def next_hop_ip(self) -> str:
        return pulumi.get(self, "next_hop_ip")

    @property
    @pulumi.getter(name="nextHopNetwork")
    def next_hop_network(self) -> str:
        return pulumi.get(self, "next_hop_network")

    @property
    @pulumi.getter(name="nextHopVpnTunnel")
    def next_hop_vpn_tunnel(self) -> str:
        return pulumi.get(self, "next_hop_vpn_tunnel")

    @property
    @pulumi.getter
    def priority(self) -> int:
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter
    def project(self) -> str:
        """
        The ID of the project in which the resource
        belongs. If it is not provided, the provider project is used.
        """
        return pulumi.get(self, "project")

    @property
    @pulumi.getter(name="selfLink")
    def self_link(self) -> str:
        return pulumi.get(self, "self_link")

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


@pulumi.output_type
class GetSnapshotSnapshotEncryptionKeyResult(dict):
    def __init__(__self__, *,
                 kms_key_self_link: str,
                 kms_key_service_account: str,
                 raw_key: str,
                 sha256: str):
        pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
        pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
        pulumi.set(__self__, "raw_key", raw_key)
        pulumi.set(__self__, "sha256", sha256)

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

    @property
    @pulumi.getter(name="kmsKeyServiceAccount")
    def kms_key_service_account(self) -> str:
        return pulumi.get(self, "kms_key_service_account")

    @property
    @pulumi.getter(name="rawKey")
    def raw_key(self) -> str:
        return pulumi.get(self, "raw_key")

    @property
    @pulumi.getter
    def sha256(self) -> str:
        return pulumi.get(self, "sha256")


@pulumi.output_type
class GetSnapshotSourceDiskEncryptionKeyResult(dict):
    def __init__(__self__, *,
                 kms_key_service_account: str,
                 raw_key: str):
        pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
        pulumi.set(__self__, "raw_key", raw_key)

    @property
    @pulumi.getter(name="kmsKeyServiceAccount")
    def kms_key_service_account(self) -> str:
        return pulumi.get(self, "kms_key_service_account")

    @property
    @pulumi.getter(name="rawKey")
    def raw_key(self) -> str:
        return pulumi.get(self, "raw_key")


@pulumi.output_type
class GetSubnetworkSecondaryIpRangeResult(dict):
    def __init__(__self__, *,
                 ip_cidr_range: str,
                 range_name: str):
        """
        :param str ip_cidr_range: The range of IP addresses belonging to this subnetwork
               secondary range.
        :param str range_name: The name associated with this subnetwork secondary range, used
               when adding an alias IP range to a VM instance.
        """
        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) -> str:
        """
        The range of IP addresses belonging to this subnetwork
        secondary range.
        """
        return pulumi.get(self, "ip_cidr_range")

    @property
    @pulumi.getter(name="rangeName")
    def range_name(self) -> str:
        """
        The name associated with this subnetwork secondary range, used
        when adding an alias IP range to a VM instance.
        """
        return pulumi.get(self, "range_name")


