export declare const AccessConfigNetworkTier: { /** * Public internet quality with fixed bandwidth. */ readonly FixedStandard: "FIXED_STANDARD"; /** * High quality, Google-grade network tier, support for all networking products. */ readonly Premium: "PREMIUM"; /** * Public internet quality, only limited support for other networking products. */ readonly Standard: "STANDARD"; /** * (Output only) Temporary tier for FIXED_STANDARD when fixed standard tier is expired or not configured. */ readonly StandardOverridesFixedStandard: "STANDARD_OVERRIDES_FIXED_STANDARD"; }; /** * This signifies the networking tier used for configuring this access configuration and can only take the following values: PREMIUM, STANDARD. If an AccessConfig is specified without a valid external IP address, an ephemeral IP will be created with this networkTier. If an AccessConfig with a valid external IP address is specified, it must match that of the networkTier associated with the Address resource owning that IP. */ export type AccessConfigNetworkTier = (typeof AccessConfigNetworkTier)[keyof typeof AccessConfigNetworkTier]; export declare const AccessConfigType: { readonly DirectIpv6: "DIRECT_IPV6"; readonly OneToOneNat: "ONE_TO_ONE_NAT"; }; /** * The type of configuration. In accessConfigs (IPv4), the default and only option is ONE_TO_ONE_NAT. In ipv6AccessConfigs, the default and only option is DIRECT_IPV6. */ export type AccessConfigType = (typeof AccessConfigType)[keyof typeof AccessConfigType]; export declare const AddressAddressType: { /** * A publicly visible external IP address. */ readonly External: "EXTERNAL"; /** * A private network IP address, for use with an Instance or Internal Load Balancer forwarding rule. */ readonly Internal: "INTERNAL"; readonly UnspecifiedType: "UNSPECIFIED_TYPE"; }; /** * The type of address to reserve, either INTERNAL or EXTERNAL. If unspecified, defaults to EXTERNAL. */ export type AddressAddressType = (typeof AddressAddressType)[keyof typeof AddressAddressType]; export declare const AddressIpVersion: { readonly Ipv4: "IPV4"; readonly Ipv6: "IPV6"; readonly UnspecifiedVersion: "UNSPECIFIED_VERSION"; }; /** * The IP version that will be used by this address. Valid options are IPV4 or IPV6. */ export type AddressIpVersion = (typeof AddressIpVersion)[keyof typeof AddressIpVersion]; export declare const AddressIpv6EndpointType: { /** * Reserved IPv6 address can be used on network load balancer. */ readonly Netlb: "NETLB"; /** * Reserved IPv6 address can be used on VM. */ readonly Vm: "VM"; }; /** * The endpoint type of this address, which should be VM or NETLB. This is used for deciding which type of endpoint this address can be used after the external IPv6 address reservation. */ export type AddressIpv6EndpointType = (typeof AddressIpv6EndpointType)[keyof typeof AddressIpv6EndpointType]; export declare const AddressNetworkTier: { /** * Public internet quality with fixed bandwidth. */ readonly FixedStandard: "FIXED_STANDARD"; /** * High quality, Google-grade network tier, support for all networking products. */ readonly Premium: "PREMIUM"; /** * Public internet quality, only limited support for other networking products. */ readonly Standard: "STANDARD"; /** * (Output only) Temporary tier for FIXED_STANDARD when fixed standard tier is expired or not configured. */ readonly StandardOverridesFixedStandard: "STANDARD_OVERRIDES_FIXED_STANDARD"; }; /** * This signifies the networking tier used for configuring this address and can only take the following values: PREMIUM or STANDARD. Internal IP addresses are always Premium Tier; global external IP addresses are always Premium Tier; regional external IP addresses can be either Standard or Premium Tier. If this field is not specified, it is assumed to be PREMIUM. */ export type AddressNetworkTier = (typeof AddressNetworkTier)[keyof typeof AddressNetworkTier]; export declare const AddressPurpose: { /** * DNS resolver address in the subnetwork. */ readonly DnsResolver: "DNS_RESOLVER"; /** * VM internal/alias IP, Internal LB service IP, etc. */ readonly GceEndpoint: "GCE_ENDPOINT"; /** * A regional internal IP address range reserved for the VLAN attachment that is used in HA VPN over Cloud Interconnect. This regional internal IP address range must not overlap with any IP address range of subnet/route in the VPC network and its peering networks. After the VLAN attachment is created with the reserved IP address range, when creating a new VPN gateway, its interface IP address is allocated from the associated VLAN attachment’s IP address range. */ readonly IpsecInterconnect: "IPSEC_INTERCONNECT"; /** * External IP automatically reserved for Cloud NAT. */ readonly NatAuto: "NAT_AUTO"; /** * A private network IP address that can be used to configure Private Service Connect. This purpose can be specified only for GLOBAL addresses of Type INTERNAL */ readonly PrivateServiceConnect: "PRIVATE_SERVICE_CONNECT"; /** * A regional internal IP address range reserved for Serverless. */ readonly Serverless: "SERVERLESS"; /** * A private network IP address that can be shared by multiple Internal Load Balancer forwarding rules. */ readonly SharedLoadbalancerVip: "SHARED_LOADBALANCER_VIP"; /** * IP range for peer networks. */ readonly VpcPeering: "VPC_PEERING"; }; /** * The purpose of this resource, which can be one of the following values: - GCE_ENDPOINT for addresses that are used by VM instances, alias IP ranges, load balancers, and similar resources. - DNS_RESOLVER for a DNS resolver address in a subnetwork for a Cloud DNS inbound forwarder IP addresses (regional internal IP address in a subnet of a VPC network) - VPC_PEERING for global internal IP addresses used for private services access allocated ranges. - NAT_AUTO for the regional external IP addresses used by Cloud NAT when allocating addresses using automatic NAT IP address allocation. - IPSEC_INTERCONNECT for addresses created from a private IP range that are reserved for a VLAN attachment in an *HA VPN over Cloud Interconnect* configuration. These addresses are regional resources. - `SHARED_LOADBALANCER_VIP` for an internal IP address that is assigned to multiple internal forwarding rules. - `PRIVATE_SERVICE_CONNECT` for a private network address that is used to configure Private Service Connect. Only global internal addresses can use this purpose. */ export type AddressPurpose = (typeof AddressPurpose)[keyof typeof AddressPurpose]; export declare const AllocationAggregateReservationVmFamily: { readonly VmFamilyCloudTpuLiteDeviceCt5l: "VM_FAMILY_CLOUD_TPU_LITE_DEVICE_CT5L"; readonly VmFamilyCloudTpuLitePodSliceCt5lp: "VM_FAMILY_CLOUD_TPU_LITE_POD_SLICE_CT5LP"; readonly VmFamilyCloudTpuPodSliceCt4p: "VM_FAMILY_CLOUD_TPU_POD_SLICE_CT4P"; }; /** * The VM family that all instances scheduled against this reservation must belong to. */ export type AllocationAggregateReservationVmFamily = (typeof AllocationAggregateReservationVmFamily)[keyof typeof AllocationAggregateReservationVmFamily]; export declare const AllocationAggregateReservationWorkloadType: { /** * Reserved resources will be optimized for BATCH workloads, such as ML training. */ readonly Batch: "BATCH"; /** * Reserved resources will be optimized for SERVING workloads, such as ML inference. */ readonly Serving: "SERVING"; readonly Unspecified: "UNSPECIFIED"; }; /** * The workload type of the instances that will target this reservation. */ export type AllocationAggregateReservationWorkloadType = (typeof AllocationAggregateReservationWorkloadType)[keyof typeof AllocationAggregateReservationWorkloadType]; export declare const AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDiskInterface: { readonly Nvme: "NVME"; readonly Scsi: "SCSI"; }; /** * Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME. The default is SCSI. For performance characteristics of SCSI over NVMe, see Local SSD performance. */ export type AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDiskInterface = (typeof AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDiskInterface)[keyof typeof AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDiskInterface]; export declare const AllocationSpecificSKUAllocationReservedInstancePropertiesMaintenanceInterval: { /** * VMs are eligible to receive infrastructure and hypervisor updates as they become available. This may result in more maintenance operations (live migrations or terminations) for the VM than the PERIODIC and RECURRENT options. */ readonly AsNeeded: "AS_NEEDED"; /** * VMs receive infrastructure and hypervisor updates on a periodic basis, minimizing the number of maintenance operations (live migrations or terminations) on an individual VM. This may mean a VM will take longer to receive an update than if it was configured for AS_NEEDED. Security updates will still be applied as soon as they are available. */ readonly Periodic: "PERIODIC"; /** * VMs receive infrastructure and hypervisor updates on a periodic basis, minimizing the number of maintenance operations (live migrations or terminations) on an individual VM. This may mean a VM will take longer to receive an update than if it was configured for AS_NEEDED. Security updates will still be applied as soon as they are available. RECURRENT is used for GEN3 and Slice of Hardware VMs. */ readonly Recurrent: "RECURRENT"; }; /** * Specifies the frequency of planned maintenance events. The accepted values are: `PERIODIC`. */ export type AllocationSpecificSKUAllocationReservedInstancePropertiesMaintenanceInterval = (typeof AllocationSpecificSKUAllocationReservedInstancePropertiesMaintenanceInterval)[keyof typeof AllocationSpecificSKUAllocationReservedInstancePropertiesMaintenanceInterval]; export declare const AttachedDiskInitializeParamsArchitecture: { /** * Default value indicating Architecture is not set. */ readonly ArchitectureUnspecified: "ARCHITECTURE_UNSPECIFIED"; /** * Machines with architecture ARM64 */ readonly Arm64: "ARM64"; /** * Machines with architecture X86_64 */ readonly X8664: "X86_64"; }; /** * The architecture of the attached disk. Valid values are arm64 or x86_64. */ export type AttachedDiskInitializeParamsArchitecture = (typeof AttachedDiskInitializeParamsArchitecture)[keyof typeof AttachedDiskInitializeParamsArchitecture]; export declare const AttachedDiskInitializeParamsOnUpdateAction: { /** * Always recreate the disk. */ readonly RecreateDisk: "RECREATE_DISK"; /** * Recreate the disk if source (image, snapshot) of this disk is different from source of existing disk. */ readonly RecreateDiskIfSourceChanged: "RECREATE_DISK_IF_SOURCE_CHANGED"; /** * Use the existing disk, this is the default behaviour. */ readonly UseExistingDisk: "USE_EXISTING_DISK"; }; /** * Specifies which action to take on instance update with this disk. Default is to use the existing disk. */ export type AttachedDiskInitializeParamsOnUpdateAction = (typeof AttachedDiskInitializeParamsOnUpdateAction)[keyof typeof AttachedDiskInitializeParamsOnUpdateAction]; export declare const AttachedDiskInterface: { readonly Nvme: "NVME"; readonly Scsi: "SCSI"; }; /** * Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME. For most machine types, the default is SCSI. Local SSDs can use either NVME or SCSI. In certain configurations, persistent disks can use NVMe. For more information, see About persistent disks. */ export type AttachedDiskInterface = (typeof AttachedDiskInterface)[keyof typeof AttachedDiskInterface]; export declare const AttachedDiskMode: { /** * Attaches this disk in read-only mode. Multiple virtual machines can use a disk in read-only mode at a time. */ readonly ReadOnly: "READ_ONLY"; /** * *[Default]* Attaches this disk in read-write mode. Only one virtual machine at a time can be attached to a disk in read-write mode. */ readonly ReadWrite: "READ_WRITE"; }; /** * 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. */ export type AttachedDiskMode = (typeof AttachedDiskMode)[keyof typeof AttachedDiskMode]; export declare const AttachedDiskSavedState: { /** * *[Default]* Disk state has not been preserved. */ readonly DiskSavedStateUnspecified: "DISK_SAVED_STATE_UNSPECIFIED"; /** * Disk state has been preserved. */ readonly Preserved: "PRESERVED"; }; /** * For LocalSSD disks on VM Instances in STOPPED or SUSPENDED state, this field is set to PRESERVED if the LocalSSD data has been saved to a persistent location by customer request. (see the discard_local_ssd option on Stop/Suspend). Read-only in the api. */ export type AttachedDiskSavedState = (typeof AttachedDiskSavedState)[keyof typeof AttachedDiskSavedState]; export declare const AttachedDiskType: { readonly Persistent: "PERSISTENT"; readonly Scratch: "SCRATCH"; }; /** * Specifies the type of the disk, either SCRATCH or PERSISTENT. If not specified, the default is PERSISTENT. */ export type AttachedDiskType = (typeof AttachedDiskType)[keyof typeof AttachedDiskType]; export declare const AuditLogConfigLogType: { /** * Admin reads. Example: CloudIAM getIamPolicy */ readonly AdminRead: "ADMIN_READ"; /** * Data reads. Example: CloudSQL Users list */ readonly DataRead: "DATA_READ"; /** * Data writes. Example: CloudSQL Users create */ readonly DataWrite: "DATA_WRITE"; /** * Default case. Should never be this. */ readonly LogTypeUnspecified: "LOG_TYPE_UNSPECIFIED"; }; /** * The log type that this config enables. */ export type AuditLogConfigLogType = (typeof AuditLogConfigLogType)[keyof typeof AuditLogConfigLogType]; export declare const AuthorizationLoggingOptionsPermissionType: { /** * This is deprecated and has no effect. Do not use. */ readonly AdminRead: "ADMIN_READ"; /** * This is deprecated and has no effect. Do not use. */ readonly AdminWrite: "ADMIN_WRITE"; /** * This is deprecated and has no effect. Do not use. */ readonly DataRead: "DATA_READ"; /** * This is deprecated and has no effect. Do not use. */ readonly DataWrite: "DATA_WRITE"; /** * This is deprecated and has no effect. Do not use. */ readonly PermissionTypeUnspecified: "PERMISSION_TYPE_UNSPECIFIED"; }; /** * This is deprecated and has no effect. Do not use. */ export type AuthorizationLoggingOptionsPermissionType = (typeof AuthorizationLoggingOptionsPermissionType)[keyof typeof AuthorizationLoggingOptionsPermissionType]; export declare const AutoscalingPolicyCpuUtilizationPredictiveMethod: { /** * No predictive method is used. The autoscaler scales the group to meet current demand based on real-time metrics */ readonly None: "NONE"; /** * Predictive autoscaling improves availability by monitoring daily and weekly load patterns and scaling out ahead of anticipated demand. */ readonly OptimizeAvailability: "OPTIMIZE_AVAILABILITY"; readonly PredictiveMethodUnspecified: "PREDICTIVE_METHOD_UNSPECIFIED"; }; /** * 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. */ export type AutoscalingPolicyCpuUtilizationPredictiveMethod = (typeof AutoscalingPolicyCpuUtilizationPredictiveMethod)[keyof typeof AutoscalingPolicyCpuUtilizationPredictiveMethod]; export declare const AutoscalingPolicyCustomMetricUtilizationUtilizationTargetType: { /** * Sets the utilization target value for a cumulative or delta metric, expressed as the rate of growth per minute. */ readonly DeltaPerMinute: "DELTA_PER_MINUTE"; /** * Sets the utilization target value for a cumulative or delta metric, expressed as the rate of growth per second. */ readonly DeltaPerSecond: "DELTA_PER_SECOND"; /** * Sets the utilization target value for a gauge metric. The autoscaler will collect the average utilization of the virtual machines from the last couple of minutes, and compare the value to the utilization target value to perform autoscaling. */ readonly Gauge: "GAUGE"; }; /** * Defines how target utilization value is expressed for a Stackdriver Monitoring metric. Either GAUGE, DELTA_PER_SECOND, or DELTA_PER_MINUTE. */ export type AutoscalingPolicyCustomMetricUtilizationUtilizationTargetType = (typeof AutoscalingPolicyCustomMetricUtilizationUtilizationTargetType)[keyof typeof AutoscalingPolicyCustomMetricUtilizationUtilizationTargetType]; export declare const AutoscalingPolicyMode: { /** * Do not automatically scale the MIG in or out. The recommended_size field contains the size of MIG that would be set if the actuation mode was enabled. */ readonly Off: "OFF"; /** * Automatically scale the MIG in and out according to the policy. */ readonly On: "ON"; /** * Automatically create VMs according to the policy, but do not scale the MIG in. */ readonly OnlyScaleOut: "ONLY_SCALE_OUT"; /** * Automatically create VMs according to the policy, but do not scale the MIG in. */ readonly OnlyUp: "ONLY_UP"; }; /** * Defines the operating mode for this policy. The following modes are available: - OFF: Disables the autoscaler but maintains its configuration. - ONLY_SCALE_OUT: Restricts the autoscaler to add VM instances only. - ON: Enables all autoscaler activities according to its policy. For more information, see "Turning off or restricting an autoscaler" */ export type AutoscalingPolicyMode = (typeof AutoscalingPolicyMode)[keyof typeof AutoscalingPolicyMode]; export declare const BackendBalancingMode: { /** * Balance based on the number of simultaneous connections. */ readonly Connection: "CONNECTION"; /** * Balance based on requests per second (RPS). */ readonly Rate: "RATE"; /** * Balance based on the backend utilization. */ readonly Utilization: "UTILIZATION"; }; /** * Specifies how to determine whether the backend of a load balancer can handle additional traffic or is fully loaded. For usage guidelines, see Connection balancing mode. Backends must use compatible balancing modes. For more information, see Supported balancing modes and target capacity settings and Restrictions and guidance for instance groups. Note: Currently, if you use the API to configure incompatible balancing modes, the configuration might be accepted even though it has no impact and is ignored. Specifically, Backend.maxUtilization is ignored when Backend.balancingMode is RATE. In the future, this incompatible combination will be rejected. */ export type BackendBalancingMode = (typeof BackendBalancingMode)[keyof typeof BackendBalancingMode]; export declare const BackendBucketCdnPolicyCacheMode: { /** * Automatically cache static content, including common image formats, media (video and audio), and web assets (JavaScript and CSS). Requests and responses that are marked as uncacheable, as well as dynamic content (including HTML), will not be cached. */ readonly CacheAllStatic: "CACHE_ALL_STATIC"; /** * Cache all content, ignoring any "private", "no-store" or "no-cache" directives in Cache-Control response headers. Warning: this may result in Cloud CDN caching private, per-user (user identifiable) content. */ readonly ForceCacheAll: "FORCE_CACHE_ALL"; readonly InvalidCacheMode: "INVALID_CACHE_MODE"; /** * Requires the origin to set valid caching headers to cache content. Responses without these headers will not be cached at Google's edge, and will require a full trip to the origin on every request, potentially impacting performance and increasing load on the origin server. */ readonly UseOriginHeaders: "USE_ORIGIN_HEADERS"; }; /** * Specifies the cache setting for all responses from this backend. The possible values are: USE_ORIGIN_HEADERS Requires the origin to set valid caching headers to cache content. Responses without these headers will not be cached at Google's edge, and will require a full trip to the origin on every request, potentially impacting performance and increasing load on the origin server. FORCE_CACHE_ALL Cache all content, ignoring any "private", "no-store" or "no-cache" directives in Cache-Control response headers. Warning: this may result in Cloud CDN caching private, per-user (user identifiable) content. CACHE_ALL_STATIC Automatically cache static content, including common image formats, media (video and audio), and web assets (JavaScript and CSS). Requests and responses that are marked as uncacheable, as well as dynamic content (including HTML), will not be cached. */ export type BackendBucketCdnPolicyCacheMode = (typeof BackendBucketCdnPolicyCacheMode)[keyof typeof BackendBucketCdnPolicyCacheMode]; export declare const BackendBucketCompressionMode: { /** * Automatically uses the best compression based on the Accept-Encoding header sent by the client. */ readonly Automatic: "AUTOMATIC"; /** * Disables compression. Existing compressed responses cached by Cloud CDN will not be served to clients. */ readonly Disabled: "DISABLED"; }; /** * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header. */ export type BackendBucketCompressionMode = (typeof BackendBucketCompressionMode)[keyof typeof BackendBucketCompressionMode]; export declare const BackendPreference: { /** * No preference. */ readonly Default: "DEFAULT"; /** * If preference is unspecified, we set it to the DEFAULT value */ readonly PreferenceUnspecified: "PREFERENCE_UNSPECIFIED"; /** * Traffic will be sent to this backend first. */ readonly Preferred: "PREFERRED"; }; /** * This field indicates whether this backend should be fully utilized before sending traffic to backends with default preference. The possible values are: - PREFERRED: Backends with this preference level will be filled up to their capacity limits first, based on RTT. - DEFAULT: If preferred backends don't have enough capacity, backends in this layer would be used and traffic would be assigned based on the load balancing algorithm you use. This is the default */ export type BackendPreference = (typeof BackendPreference)[keyof typeof BackendPreference]; export declare const BackendServiceCdnPolicyCacheMode: { /** * Automatically cache static content, including common image formats, media (video and audio), and web assets (JavaScript and CSS). Requests and responses that are marked as uncacheable, as well as dynamic content (including HTML), will not be cached. */ readonly CacheAllStatic: "CACHE_ALL_STATIC"; /** * Cache all content, ignoring any "private", "no-store" or "no-cache" directives in Cache-Control response headers. Warning: this may result in Cloud CDN caching private, per-user (user identifiable) content. */ readonly ForceCacheAll: "FORCE_CACHE_ALL"; readonly InvalidCacheMode: "INVALID_CACHE_MODE"; /** * Requires the origin to set valid caching headers to cache content. Responses without these headers will not be cached at Google's edge, and will require a full trip to the origin on every request, potentially impacting performance and increasing load on the origin server. */ readonly UseOriginHeaders: "USE_ORIGIN_HEADERS"; }; /** * Specifies the cache setting for all responses from this backend. The possible values are: USE_ORIGIN_HEADERS Requires the origin to set valid caching headers to cache content. Responses without these headers will not be cached at Google's edge, and will require a full trip to the origin on every request, potentially impacting performance and increasing load on the origin server. FORCE_CACHE_ALL Cache all content, ignoring any "private", "no-store" or "no-cache" directives in Cache-Control response headers. Warning: this may result in Cloud CDN caching private, per-user (user identifiable) content. CACHE_ALL_STATIC Automatically cache static content, including common image formats, media (video and audio), and web assets (JavaScript and CSS). Requests and responses that are marked as uncacheable, as well as dynamic content (including HTML), will not be cached. */ export type BackendServiceCdnPolicyCacheMode = (typeof BackendServiceCdnPolicyCacheMode)[keyof typeof BackendServiceCdnPolicyCacheMode]; export declare const BackendServiceCompressionMode: { /** * Automatically uses the best compression based on the Accept-Encoding header sent by the client. */ readonly Automatic: "AUTOMATIC"; /** * Disables compression. Existing compressed responses cached by Cloud CDN will not be served to clients. */ readonly Disabled: "DISABLED"; }; /** * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header. */ export type BackendServiceCompressionMode = (typeof BackendServiceCompressionMode)[keyof typeof BackendServiceCompressionMode]; export declare const BackendServiceConnectionTrackingPolicyConnectionPersistenceOnUnhealthyBackends: { readonly AlwaysPersist: "ALWAYS_PERSIST"; readonly DefaultForProtocol: "DEFAULT_FOR_PROTOCOL"; readonly NeverPersist: "NEVER_PERSIST"; }; /** * Specifies connection persistence when backends are unhealthy. The default value is DEFAULT_FOR_PROTOCOL. 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. For more details, see [Connection Persistence for Network Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-backend-service#connection-persistence) and [Connection Persistence for Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal#connection-persistence). */ export type BackendServiceConnectionTrackingPolicyConnectionPersistenceOnUnhealthyBackends = (typeof BackendServiceConnectionTrackingPolicyConnectionPersistenceOnUnhealthyBackends)[keyof typeof BackendServiceConnectionTrackingPolicyConnectionPersistenceOnUnhealthyBackends]; export declare const BackendServiceConnectionTrackingPolicyTrackingMode: { readonly InvalidTrackingMode: "INVALID_TRACKING_MODE"; readonly PerConnection: "PER_CONNECTION"; readonly PerSession: "PER_SESSION"; }; /** * Specifies the key used for connection tracking. There are two options: - PER_CONNECTION: This is the default mode. 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. For more details, see [Tracking Mode for Network Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-backend-service#tracking-mode) and [Tracking Mode for Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal#tracking-mode). */ export type BackendServiceConnectionTrackingPolicyTrackingMode = (typeof BackendServiceConnectionTrackingPolicyTrackingMode)[keyof typeof BackendServiceConnectionTrackingPolicyTrackingMode]; export declare const BackendServiceIpAddressSelectionPolicy: { /** * Only send IPv4 traffic to the backends of the Backend Service (Instance Group, Managed Instance Group, Network Endpoint Group) regardless of traffic from the client to the proxy. Only IPv4 health-checks are used to check the health of the backends. This is the default setting. */ readonly Ipv4Only: "IPV4_ONLY"; /** * Only send IPv6 traffic to the backends of the Backend Service (Instance Group, Managed Instance Group, Network Endpoint Group) regardless of traffic from the client to the proxy. Only IPv6 health-checks are used to check the health of the backends. */ readonly Ipv6Only: "IPV6_ONLY"; /** * Unspecified IP address selection policy. */ readonly IpAddressSelectionPolicyUnspecified: "IP_ADDRESS_SELECTION_POLICY_UNSPECIFIED"; /** * Prioritize the connection to the endpoints IPv6 address over its IPv4 address (provided there is a healthy IPv6 address). */ readonly PreferIpv6: "PREFER_IPV6"; }; /** * Specifies a preference for traffic sent from the proxy to the backend (or from the client to the backend for proxyless gRPC). The possible values are: - IPV4_ONLY: Only send IPv4 traffic to the backends of the backend service (Instance Group, Managed Instance Group, Network Endpoint Group), regardless of traffic from the client to the proxy. Only IPv4 health checks are used to check the health of the backends. This is the default setting. - PREFER_IPV6: Prioritize the connection to the endpoint's IPv6 address over its IPv4 address (provided there is a healthy IPv6 address). - IPV6_ONLY: Only send IPv6 traffic to the backends of the backend service (Instance Group, Managed Instance Group, Network Endpoint Group), regardless of traffic from the client to the proxy. Only IPv6 health checks are used to check the health of the backends. This field is applicable to either: - Advanced Global External HTTPS Load Balancing (load balancing scheme EXTERNAL_MANAGED), - Regional External HTTPS Load Balancing, - Internal TCP Proxy (load balancing scheme INTERNAL_MANAGED), - Regional Internal HTTPS Load Balancing (load balancing scheme INTERNAL_MANAGED), - Traffic Director with Envoy proxies and proxyless gRPC (load balancing scheme INTERNAL_SELF_MANAGED). */ export type BackendServiceIpAddressSelectionPolicy = (typeof BackendServiceIpAddressSelectionPolicy)[keyof typeof BackendServiceIpAddressSelectionPolicy]; export declare const BackendServiceLoadBalancingScheme: { /** * Signifies that this will be used for external HTTP(S), SSL Proxy, TCP Proxy, or Network Load Balancing */ readonly External: "EXTERNAL"; /** * Signifies that this will be used for External Managed HTTP(S) Load Balancing. */ readonly ExternalManaged: "EXTERNAL_MANAGED"; /** * Signifies that this will be used for Internal TCP/UDP Load Balancing. */ readonly Internal: "INTERNAL"; /** * Signifies that this will be used for Internal HTTP(S) Load Balancing. */ readonly InternalManaged: "INTERNAL_MANAGED"; /** * Signifies that this will be used by Traffic Director. */ readonly InternalSelfManaged: "INTERNAL_SELF_MANAGED"; readonly InvalidLoadBalancingScheme: "INVALID_LOAD_BALANCING_SCHEME"; }; /** * Specifies the load balancer type. A backend service created for one type of load balancer cannot be used with another. For more information, refer to Choosing a load balancer. */ export type BackendServiceLoadBalancingScheme = (typeof BackendServiceLoadBalancingScheme)[keyof typeof BackendServiceLoadBalancingScheme]; export declare const BackendServiceLocalityLbPolicy: { readonly InvalidLbPolicy: "INVALID_LB_POLICY"; /** * An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. */ readonly LeastRequest: "LEAST_REQUEST"; /** * This algorithm implements consistent hashing to backends. Maglev can be used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 */ readonly Maglev: "MAGLEV"; /** * Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. */ readonly OriginalDestination: "ORIGINAL_DESTINATION"; /** * The load balancer selects a random healthy host. */ readonly Random: "RANDOM"; /** * The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. */ readonly RingHash: "RING_HASH"; /** * This is a simple policy in which each healthy backend is selected in round robin order. This is the default. */ readonly RoundRobin: "ROUND_ROBIN"; /** * Per-instance weighted Load Balancing via health check reported weights. If set, the Backend Service must configure a non legacy HTTP-based Health Check, and health check replies are expected to contain non-standard HTTP response header field X-Load-Balancing-Endpoint-Weight to specify the per-instance weights. If set, Load Balancing is weighted based on the per-instance weights reported in the last processed health check replies, as long as every instance either reported a valid weight or had UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains equal-weight. This option is only supported in Network Load Balancing. */ readonly WeightedMaglev: "WEIGHTED_MAGLEV"; }; /** * The load balancing algorithm used within the scope of the locality. The possible values are: - ROUND_ROBIN: This is a simple policy in which each healthy backend is selected in round robin order. This is the default. - LEAST_REQUEST: An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. - RING_HASH: The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. - RANDOM: The load balancer selects a random healthy host. - ORIGINAL_DESTINATION: Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. - MAGLEV: used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED, INTERNAL_MANAGED, or EXTERNAL_MANAGED. If sessionAffinity is not NONE, and this field is not set to MAGLEV or RING_HASH, session affinity settings will not take effect. Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. */ export type BackendServiceLocalityLbPolicy = (typeof BackendServiceLocalityLbPolicy)[keyof typeof BackendServiceLocalityLbPolicy]; export declare const BackendServiceLocalityLoadBalancingPolicyConfigPolicyName: { readonly InvalidLbPolicy: "INVALID_LB_POLICY"; /** * An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. */ readonly LeastRequest: "LEAST_REQUEST"; /** * This algorithm implements consistent hashing to backends. Maglev can be used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 */ readonly Maglev: "MAGLEV"; /** * Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. */ readonly OriginalDestination: "ORIGINAL_DESTINATION"; /** * The load balancer selects a random healthy host. */ readonly Random: "RANDOM"; /** * The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. */ readonly RingHash: "RING_HASH"; /** * This is a simple policy in which each healthy backend is selected in round robin order. This is the default. */ readonly RoundRobin: "ROUND_ROBIN"; /** * Per-instance weighted Load Balancing via health check reported weights. If set, the Backend Service must configure a non legacy HTTP-based Health Check, and health check replies are expected to contain non-standard HTTP response header field X-Load-Balancing-Endpoint-Weight to specify the per-instance weights. If set, Load Balancing is weighted based on the per-instance weights reported in the last processed health check replies, as long as every instance either reported a valid weight or had UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains equal-weight. This option is only supported in Network Load Balancing. */ readonly WeightedMaglev: "WEIGHTED_MAGLEV"; }; /** * The name of a locality load-balancing policy. Valid values include ROUND_ROBIN and, for Java clients, LEAST_REQUEST. For information about these values, see the description of localityLbPolicy. Do not specify the same policy more than once for a backend. If you do, the configuration is rejected. */ export type BackendServiceLocalityLoadBalancingPolicyConfigPolicyName = (typeof BackendServiceLocalityLoadBalancingPolicyConfigPolicyName)[keyof typeof BackendServiceLocalityLoadBalancingPolicyConfigPolicyName]; export declare const BackendServiceLogConfigOptionalMode: { /** * A subset of optional fields. */ readonly Custom: "CUSTOM"; /** * None optional fields. */ readonly ExcludeAllOptional: "EXCLUDE_ALL_OPTIONAL"; /** * All optional fields. */ readonly IncludeAllOptional: "INCLUDE_ALL_OPTIONAL"; }; /** * This field can only be specified if logging is enabled for this backend service. Configures whether all, none or a subset of optional fields should be added to the reported logs. One of [INCLUDE_ALL_OPTIONAL, EXCLUDE_ALL_OPTIONAL, CUSTOM]. Default is EXCLUDE_ALL_OPTIONAL. */ export type BackendServiceLogConfigOptionalMode = (typeof BackendServiceLogConfigOptionalMode)[keyof typeof BackendServiceLogConfigOptionalMode]; export declare const BackendServiceProtocol: { /** * gRPC (available for Traffic Director). */ readonly Grpc: "GRPC"; readonly Http: "HTTP"; /** * HTTP/2 with SSL. */ readonly Http2: "HTTP2"; readonly Https: "HTTPS"; /** * TCP proxying with SSL. */ readonly Ssl: "SSL"; /** * TCP proxying or TCP pass-through. */ readonly Tcp: "TCP"; /** * UDP. */ readonly Udp: "UDP"; /** * If a Backend Service has UNSPECIFIED as its protocol, it can be used with any L3/L4 Forwarding Rules. */ readonly Unspecified: "UNSPECIFIED"; }; /** * The protocol this BackendService uses to communicate with backends. Possible values are HTTP, HTTPS, HTTP2, TCP, SSL, UDP or GRPC. depending on the chosen load balancer or Traffic Director configuration. Refer to the documentation for the load balancers or for Traffic Director for more information. Must be set to GRPC when the backend service is referenced by a URL map that is bound to target gRPC proxy. */ export type BackendServiceProtocol = (typeof BackendServiceProtocol)[keyof typeof BackendServiceProtocol]; export declare const BackendServiceSessionAffinity: { /** * 2-tuple hash on packet's source and destination IP addresses. Connections from the same source IP address to the same destination IP address will be served by the same backend VM while that VM remains healthy. */ readonly ClientIp: "CLIENT_IP"; /** * 1-tuple hash only on packet's source IP address. Connections from the same source IP address will be served by the same backend VM while that VM remains healthy. This option can only be used for Internal TCP/UDP Load Balancing. */ readonly ClientIpNoDestination: "CLIENT_IP_NO_DESTINATION"; /** * 5-tuple hash on packet's source and destination IP addresses, IP protocol, and source and destination ports. Connections for the same IP protocol from the same source IP address and port to the same destination IP address and port will be served by the same backend VM while that VM remains healthy. This option cannot be used for HTTP(S) load balancing. */ readonly ClientIpPortProto: "CLIENT_IP_PORT_PROTO"; /** * 3-tuple hash on packet's source and destination IP addresses, and IP protocol. Connections for the same IP protocol from the same source IP address to the same destination IP address will be served by the same backend VM while that VM remains healthy. This option cannot be used for HTTP(S) load balancing. */ readonly ClientIpProto: "CLIENT_IP_PROTO"; /** * Hash based on a cookie generated by the L7 loadbalancer. Only valid for HTTP(S) load balancing. */ readonly GeneratedCookie: "GENERATED_COOKIE"; /** * The hash is based on a user specified header field. */ readonly HeaderField: "HEADER_FIELD"; /** * The hash is based on a user provided cookie. */ readonly HttpCookie: "HTTP_COOKIE"; /** * No session affinity. Connections from the same client IP may go to any instance in the pool. */ readonly None: "NONE"; }; /** * Type of session affinity to use. The default is NONE. Only NONE and HEADER_FIELD are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. For more details, see: [Session Affinity](https://cloud.google.com/load-balancing/docs/backend-service#session_affinity). */ export type BackendServiceSessionAffinity = (typeof BackendServiceSessionAffinity)[keyof typeof BackendServiceSessionAffinity]; export declare const ConditionIam: { /** * This is deprecated and has no effect. Do not use. */ readonly Approver: "APPROVER"; /** * This is deprecated and has no effect. Do not use. */ readonly Attribution: "ATTRIBUTION"; /** * This is deprecated and has no effect. Do not use. */ readonly Authority: "AUTHORITY"; /** * This is deprecated and has no effect. Do not use. */ readonly CredentialsType: "CREDENTIALS_TYPE"; /** * This is deprecated and has no effect. Do not use. */ readonly CredsAssertion: "CREDS_ASSERTION"; /** * This is deprecated and has no effect. Do not use. */ readonly JustificationType: "JUSTIFICATION_TYPE"; /** * This is deprecated and has no effect. Do not use. */ readonly NoAttr: "NO_ATTR"; /** * This is deprecated and has no effect. Do not use. */ readonly SecurityRealm: "SECURITY_REALM"; }; /** * This is deprecated and has no effect. Do not use. */ export type ConditionIam = (typeof ConditionIam)[keyof typeof ConditionIam]; export declare const ConditionOp: { /** * This is deprecated and has no effect. Do not use. */ readonly Discharged: "DISCHARGED"; /** * This is deprecated and has no effect. Do not use. */ readonly Equals: "EQUALS"; /** * This is deprecated and has no effect. Do not use. */ readonly In: "IN"; /** * This is deprecated and has no effect. Do not use. */ readonly NotEquals: "NOT_EQUALS"; /** * This is deprecated and has no effect. Do not use. */ readonly NotIn: "NOT_IN"; /** * This is deprecated and has no effect. Do not use. */ readonly NoOp: "NO_OP"; }; /** * This is deprecated and has no effect. Do not use. */ export type ConditionOp = (typeof ConditionOp)[keyof typeof ConditionOp]; export declare const ConditionSys: { /** * This is deprecated and has no effect. Do not use. */ readonly Ip: "IP"; /** * This is deprecated and has no effect. Do not use. */ readonly Name: "NAME"; /** * This is deprecated and has no effect. Do not use. */ readonly NoAttr: "NO_ATTR"; /** * This is deprecated and has no effect. Do not use. */ readonly Region: "REGION"; /** * This is deprecated and has no effect. Do not use. */ readonly Service: "SERVICE"; }; /** * This is deprecated and has no effect. Do not use. */ export type ConditionSys = (typeof ConditionSys)[keyof typeof ConditionSys]; export declare const ConfidentialInstanceConfigConfidentialInstanceType: { /** * No type specified. Do not use this value. */ readonly ConfidentialInstanceTypeUnspecified: "CONFIDENTIAL_INSTANCE_TYPE_UNSPECIFIED"; /** * AMD Secure Encrypted Virtualization. */ readonly Sev: "SEV"; /** * AMD Secure Encrypted Virtualization - Secure Nested Paging. */ readonly SevSnp: "SEV_SNP"; }; /** * Defines the type of technology used by the confidential instance. */ export type ConfidentialInstanceConfigConfidentialInstanceType = (typeof ConfidentialInstanceConfigConfidentialInstanceType)[keyof typeof ConfidentialInstanceConfigConfidentialInstanceType]; export declare const DeprecationStatusState: { readonly Active: "ACTIVE"; readonly Deleted: "DELETED"; readonly Deprecated: "DEPRECATED"; readonly Obsolete: "OBSOLETE"; }; /** * The deprecation state of this resource. This can be ACTIVE, DEPRECATED, OBSOLETE, or DELETED. Operations which communicate the end of life date for an image, can use ACTIVE. Operations which create a new resource using a DEPRECATED resource will return successfully, but with a warning indicating the deprecated resource and recommending its replacement. Operations which use OBSOLETE or DELETED resources will be rejected and result in an error. */ export type DeprecationStatusState = (typeof DeprecationStatusState)[keyof typeof DeprecationStatusState]; export declare const DiskArchitecture: { /** * Default value indicating Architecture is not set. */ readonly ArchitectureUnspecified: "ARCHITECTURE_UNSPECIFIED"; /** * Machines with architecture ARM64 */ readonly Arm64: "ARM64"; /** * Machines with architecture X86_64 */ readonly X8664: "X86_64"; }; /** * The architecture of the disk. Valid values are ARM64 or X86_64. */ export type DiskArchitecture = (typeof DiskArchitecture)[keyof typeof DiskArchitecture]; export declare const DiskInstantiationConfigInstantiateFrom: { /** * Attach the existing disk in read-only mode. The request will fail if the disk was attached in read-write mode on the source instance. Applicable to: read-only disks. */ readonly AttachReadOnly: "ATTACH_READ_ONLY"; /** * Create a blank disk. The disk will be created unformatted. Applicable to: additional read-write disks, local SSDs. */ readonly Blank: "BLANK"; /** * Use the custom image specified in the custom_image field. Applicable to: boot disk, additional read-write disks. */ readonly CustomImage: "CUSTOM_IMAGE"; /** * Use the default instantiation option for the corresponding type of disk. For boot disk and any other R/W disks, new custom images will be created from each disk. For read-only disks, they will be attached in read-only mode. Local SSD disks will be created as blank volumes. */ readonly Default: "DEFAULT"; /** * Do not include the disk in the instance template. Applicable to: additional read-write disks, local SSDs, read-only disks. */ readonly DoNotInclude: "DO_NOT_INCLUDE"; /** * Use the same source image used for creation of the source instance's corresponding disk. The request will fail if the source VM's disk was created from a snapshot. Applicable to: boot disk, additional read-write disks. */ readonly SourceImage: "SOURCE_IMAGE"; /** * Use the same source image family used for creation of the source instance's corresponding disk. The request will fail if the source image of the source disk does not belong to any image family. Applicable to: boot disk, additional read-write disks. */ readonly SourceImageFamily: "SOURCE_IMAGE_FAMILY"; }; /** * Specifies whether to include the disk and what image to use. Possible values are: - source-image: to use the same image that was used to create the source instance's corresponding disk. Applicable to the boot disk and additional read-write disks. - source-image-family: to use the same image family that was used to create the source instance's corresponding disk. Applicable to the boot disk and additional read-write disks. - custom-image: to use a user-provided image url for disk creation. Applicable to the boot disk and additional read-write disks. - attach-read-only: to attach a read-only disk. Applicable to read-only disks. - do-not-include: to exclude a disk from the template. Applicable to additional read-write disks, local SSDs, and read-only disks. */ export type DiskInstantiationConfigInstantiateFrom = (typeof DiskInstantiationConfigInstantiateFrom)[keyof typeof DiskInstantiationConfigInstantiateFrom]; export declare const DiskInterface: { readonly Nvme: "NVME"; readonly Scsi: "SCSI"; readonly Unspecified: "UNSPECIFIED"; }; /** * [Deprecated] Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME. The default is SCSI. */ export type DiskInterface = (typeof DiskInterface)[keyof typeof DiskInterface]; export declare const DiskStorageType: { readonly Hdd: "HDD"; readonly Ssd: "SSD"; }; /** * [Deprecated] Storage type of the persistent disk. */ export type DiskStorageType = (typeof DiskStorageType)[keyof typeof DiskStorageType]; export declare const DistributionPolicyTargetShape: { /** * The group picks zones for creating VM instances to fulfill the requested number of VMs within present resource constraints and to maximize utilization of unused zonal reservations. Recommended for batch workloads that do not require high availability. */ readonly Any: "ANY"; /** * The group creates all VM instances within a single zone. The zone is selected based on the present resource constraints and to maximize utilization of unused zonal reservations. Recommended for batch workloads with heavy interprocess communication. */ readonly AnySingleZone: "ANY_SINGLE_ZONE"; /** * The group prioritizes acquisition of resources, scheduling VMs in zones where resources are available while distributing VMs as evenly as possible across selected zones to minimize the impact of zonal failure. Recommended for highly available serving workloads. */ readonly Balanced: "BALANCED"; /** * The group schedules VM instance creation and deletion to achieve and maintain an even number of managed instances across the selected zones. The distribution is even when the number of managed instances does not differ by more than 1 between any two zones. Recommended for highly available serving workloads. */ readonly Even: "EVEN"; }; /** * The distribution shape to which the group converges either proactively or on resize events (depending on the value set in updatePolicy.instanceRedistributionType). */ export type DistributionPolicyTargetShape = (typeof DistributionPolicyTargetShape)[keyof typeof DistributionPolicyTargetShape]; export declare const ExternalVpnGatewayRedundancyType: { /** * The external VPN gateway has four public IP addresses; at the time of writing this API, the AWS virtual private gateway is an example which has four public IP addresses for high availability connections; there should be two VPN connections in the AWS virtual private gateway , each AWS VPN connection has two public IP addresses; please make sure to put two public IP addresses from one AWS VPN connection into interfaces 0 and 1 of this external VPN gateway, and put the other two public IP addresses from another AWS VPN connection into interfaces 2 and 3 of this external VPN gateway. When displaying highly available configuration status for the VPN tunnels connected to FOUR_IPS_REDUNDANCY external VPN gateway, Google will always detect whether interfaces 0 and 1 are connected on one interface of HA Cloud VPN gateway, and detect whether interfaces 2 and 3 are connected to another interface of the HA Cloud VPN gateway. */ readonly FourIpsRedundancy: "FOUR_IPS_REDUNDANCY"; /** * The external VPN gateway has only one public IP address which internally provide redundancy or failover. */ readonly SingleIpInternallyRedundant: "SINGLE_IP_INTERNALLY_REDUNDANT"; /** * The external VPN gateway has two public IP addresses which are redundant with each other, the following two types of setup on your on-premises side would have this type of redundancy: (1) Two separate on-premises gateways, each with one public IP address, the two on-premises gateways are redundant with each other. (2) A single on-premise gateway with two public IP addresses that are redundant with eatch other. */ readonly TwoIpsRedundancy: "TWO_IPS_REDUNDANCY"; }; /** * Indicates the user-supplied redundancy type of this external VPN gateway. */ export type ExternalVpnGatewayRedundancyType = (typeof ExternalVpnGatewayRedundancyType)[keyof typeof ExternalVpnGatewayRedundancyType]; export declare const FileContentBufferFileType: { readonly Bin: "BIN"; readonly Undefined: "UNDEFINED"; readonly X509: "X509"; }; /** * The file type of source file. */ export type FileContentBufferFileType = (typeof FileContentBufferFileType)[keyof typeof FileContentBufferFileType]; export declare const FirewallDirection: { /** * Indicates that firewall should apply to outgoing traffic. */ readonly Egress: "EGRESS"; /** * Indicates that firewall should apply to incoming traffic. */ readonly Ingress: "INGRESS"; }; /** * Direction of traffic to which this firewall applies, either `INGRESS` or `EGRESS`. The default is `INGRESS`. For `EGRESS` traffic, you cannot specify the sourceTags fields. */ export type FirewallDirection = (typeof FirewallDirection)[keyof typeof FirewallDirection]; export declare const FirewallLogConfigMetadata: { readonly ExcludeAllMetadata: "EXCLUDE_ALL_METADATA"; readonly IncludeAllMetadata: "INCLUDE_ALL_METADATA"; }; /** * This field can only be specified for a particular firewall rule if logging is enabled for that rule. This field denotes whether to include or exclude metadata for firewall logs. */ export type FirewallLogConfigMetadata = (typeof FirewallLogConfigMetadata)[keyof typeof FirewallLogConfigMetadata]; export declare const FirewallPolicyRuleDirection: { readonly Egress: "EGRESS"; readonly Ingress: "INGRESS"; }; /** * The direction in which this rule applies. */ export type FirewallPolicyRuleDirection = (typeof FirewallPolicyRuleDirection)[keyof typeof FirewallPolicyRuleDirection]; export declare const ForwardingRuleIpProtocol: { readonly Ah: "AH"; readonly Esp: "ESP"; readonly Icmp: "ICMP"; readonly L3Default: "L3_DEFAULT"; readonly Sctp: "SCTP"; readonly Tcp: "TCP"; readonly Udp: "UDP"; }; /** * The IP protocol to which this rule applies. For protocol forwarding, valid options are TCP, UDP, ESP, AH, SCTP, ICMP and L3_DEFAULT. The valid IP protocols are different for different load balancing products as described in [Load balancing features](https://cloud.google.com/load-balancing/docs/features#protocols_from_the_load_balancer_to_the_backends). */ export type ForwardingRuleIpProtocol = (typeof ForwardingRuleIpProtocol)[keyof typeof ForwardingRuleIpProtocol]; export declare const ForwardingRuleIpVersion: { readonly Ipv4: "IPV4"; readonly Ipv6: "IPV6"; readonly UnspecifiedVersion: "UNSPECIFIED_VERSION"; }; /** * The IP Version that will be used by this forwarding rule. Valid options are IPV4 or IPV6. */ export type ForwardingRuleIpVersion = (typeof ForwardingRuleIpVersion)[keyof typeof ForwardingRuleIpVersion]; export declare const ForwardingRuleLoadBalancingScheme: { readonly External: "EXTERNAL"; readonly ExternalManaged: "EXTERNAL_MANAGED"; readonly Internal: "INTERNAL"; readonly InternalManaged: "INTERNAL_MANAGED"; readonly InternalSelfManaged: "INTERNAL_SELF_MANAGED"; readonly Invalid: "INVALID"; }; /** * Specifies the forwarding rule type. For more information about forwarding rules, refer to Forwarding rule concepts. */ export type ForwardingRuleLoadBalancingScheme = (typeof ForwardingRuleLoadBalancingScheme)[keyof typeof ForwardingRuleLoadBalancingScheme]; export declare const ForwardingRuleNetworkTier: { /** * Public internet quality with fixed bandwidth. */ readonly FixedStandard: "FIXED_STANDARD"; /** * High quality, Google-grade network tier, support for all networking products. */ readonly Premium: "PREMIUM"; /** * Public internet quality, only limited support for other networking products. */ readonly Standard: "STANDARD"; /** * (Output only) Temporary tier for FIXED_STANDARD when fixed standard tier is expired or not configured. */ readonly StandardOverridesFixedStandard: "STANDARD_OVERRIDES_FIXED_STANDARD"; }; /** * This signifies the networking tier used for configuring this load balancer and can only take the following values: PREMIUM, STANDARD. For regional ForwardingRule, the valid values are PREMIUM and STANDARD. For GlobalForwardingRule, the valid value is PREMIUM. If this field is not specified, it is assumed to be PREMIUM. If IPAddress is specified, this value must be equal to the networkTier of the Address. */ export type ForwardingRuleNetworkTier = (typeof ForwardingRuleNetworkTier)[keyof typeof ForwardingRuleNetworkTier]; export declare const ForwardingRulePscConnectionStatus: { /** * The connection has been accepted by the producer. */ readonly Accepted: "ACCEPTED"; /** * The connection has been closed by the producer and will not serve traffic going forward. */ readonly Closed: "CLOSED"; /** * The connection has been accepted by the producer, but the producer needs to take further action before the forwarding rule can serve traffic. */ readonly NeedsAttention: "NEEDS_ATTENTION"; /** * The connection is pending acceptance by the producer. */ readonly Pending: "PENDING"; /** * The connection has been rejected by the producer. */ readonly Rejected: "REJECTED"; readonly StatusUnspecified: "STATUS_UNSPECIFIED"; }; export type ForwardingRulePscConnectionStatus = (typeof ForwardingRulePscConnectionStatus)[keyof typeof ForwardingRulePscConnectionStatus]; export declare const FutureReservationPlanningStatus: { /** * Future Reservation is being drafted. */ readonly Draft: "DRAFT"; readonly PlanningStatusUnspecified: "PLANNING_STATUS_UNSPECIFIED"; /** * Future Reservation has been submitted for evaluation by GCP. */ readonly Submitted: "SUBMITTED"; }; /** * Planning state before being submitted for evaluation */ export type FutureReservationPlanningStatus = (typeof FutureReservationPlanningStatus)[keyof typeof FutureReservationPlanningStatus]; export declare const GRPCHealthCheckPortSpecification: { /** * The port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends. */ readonly UseFixedPort: "USE_FIXED_PORT"; /** * Not supported. */ readonly UseNamedPort: "USE_NAMED_PORT"; /** * For network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports. */ readonly UseServingPort: "USE_SERVING_PORT"; }; /** * Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports. */ export type GRPCHealthCheckPortSpecification = (typeof GRPCHealthCheckPortSpecification)[keyof typeof GRPCHealthCheckPortSpecification]; export declare const GlobalAddressAddressType: { /** * A publicly visible external IP address. */ readonly External: "EXTERNAL"; /** * A private network IP address, for use with an Instance or Internal Load Balancer forwarding rule. */ readonly Internal: "INTERNAL"; readonly UnspecifiedType: "UNSPECIFIED_TYPE"; }; /** * The type of address to reserve, either INTERNAL or EXTERNAL. If unspecified, defaults to EXTERNAL. */ export type GlobalAddressAddressType = (typeof GlobalAddressAddressType)[keyof typeof GlobalAddressAddressType]; export declare const GlobalAddressIpVersion: { readonly Ipv4: "IPV4"; readonly Ipv6: "IPV6"; readonly UnspecifiedVersion: "UNSPECIFIED_VERSION"; }; /** * The IP version that will be used by this address. Valid options are IPV4 or IPV6. */ export type GlobalAddressIpVersion = (typeof GlobalAddressIpVersion)[keyof typeof GlobalAddressIpVersion]; export declare const GlobalAddressIpv6EndpointType: { /** * Reserved IPv6 address can be used on network load balancer. */ readonly Netlb: "NETLB"; /** * Reserved IPv6 address can be used on VM. */ readonly Vm: "VM"; }; /** * The endpoint type of this address, which should be VM or NETLB. This is used for deciding which type of endpoint this address can be used after the external IPv6 address reservation. */ export type GlobalAddressIpv6EndpointType = (typeof GlobalAddressIpv6EndpointType)[keyof typeof GlobalAddressIpv6EndpointType]; export declare const GlobalAddressNetworkTier: { /** * Public internet quality with fixed bandwidth. */ readonly FixedStandard: "FIXED_STANDARD"; /** * High quality, Google-grade network tier, support for all networking products. */ readonly Premium: "PREMIUM"; /** * Public internet quality, only limited support for other networking products. */ readonly Standard: "STANDARD"; /** * (Output only) Temporary tier for FIXED_STANDARD when fixed standard tier is expired or not configured. */ readonly StandardOverridesFixedStandard: "STANDARD_OVERRIDES_FIXED_STANDARD"; }; /** * This signifies the networking tier used for configuring this address and can only take the following values: PREMIUM or STANDARD. Internal IP addresses are always Premium Tier; global external IP addresses are always Premium Tier; regional external IP addresses can be either Standard or Premium Tier. If this field is not specified, it is assumed to be PREMIUM. */ export type GlobalAddressNetworkTier = (typeof GlobalAddressNetworkTier)[keyof typeof GlobalAddressNetworkTier]; export declare const GlobalAddressPurpose: { /** * DNS resolver address in the subnetwork. */ readonly DnsResolver: "DNS_RESOLVER"; /** * VM internal/alias IP, Internal LB service IP, etc. */ readonly GceEndpoint: "GCE_ENDPOINT"; /** * A regional internal IP address range reserved for the VLAN attachment that is used in HA VPN over Cloud Interconnect. This regional internal IP address range must not overlap with any IP address range of subnet/route in the VPC network and its peering networks. After the VLAN attachment is created with the reserved IP address range, when creating a new VPN gateway, its interface IP address is allocated from the associated VLAN attachment’s IP address range. */ readonly IpsecInterconnect: "IPSEC_INTERCONNECT"; /** * External IP automatically reserved for Cloud NAT. */ readonly NatAuto: "NAT_AUTO"; /** * A private network IP address that can be used to configure Private Service Connect. This purpose can be specified only for GLOBAL addresses of Type INTERNAL */ readonly PrivateServiceConnect: "PRIVATE_SERVICE_CONNECT"; /** * A regional internal IP address range reserved for Serverless. */ readonly Serverless: "SERVERLESS"; /** * A private network IP address that can be shared by multiple Internal Load Balancer forwarding rules. */ readonly SharedLoadbalancerVip: "SHARED_LOADBALANCER_VIP"; /** * IP range for peer networks. */ readonly VpcPeering: "VPC_PEERING"; }; /** * The purpose of this resource, which can be one of the following values: - GCE_ENDPOINT for addresses that are used by VM instances, alias IP ranges, load balancers, and similar resources. - DNS_RESOLVER for a DNS resolver address in a subnetwork for a Cloud DNS inbound forwarder IP addresses (regional internal IP address in a subnet of a VPC network) - VPC_PEERING for global internal IP addresses used for private services access allocated ranges. - NAT_AUTO for the regional external IP addresses used by Cloud NAT when allocating addresses using automatic NAT IP address allocation. - IPSEC_INTERCONNECT for addresses created from a private IP range that are reserved for a VLAN attachment in an *HA VPN over Cloud Interconnect* configuration. These addresses are regional resources. - `SHARED_LOADBALANCER_VIP` for an internal IP address that is assigned to multiple internal forwarding rules. - `PRIVATE_SERVICE_CONNECT` for a private network address that is used to configure Private Service Connect. Only global internal addresses can use this purpose. */ export type GlobalAddressPurpose = (typeof GlobalAddressPurpose)[keyof typeof GlobalAddressPurpose]; export declare const GlobalForwardingRuleIpProtocol: { readonly Ah: "AH"; readonly Esp: "ESP"; readonly Icmp: "ICMP"; readonly L3Default: "L3_DEFAULT"; readonly Sctp: "SCTP"; readonly Tcp: "TCP"; readonly Udp: "UDP"; }; /** * The IP protocol to which this rule applies. For protocol forwarding, valid options are TCP, UDP, ESP, AH, SCTP, ICMP and L3_DEFAULT. The valid IP protocols are different for different load balancing products as described in [Load balancing features](https://cloud.google.com/load-balancing/docs/features#protocols_from_the_load_balancer_to_the_backends). */ export type GlobalForwardingRuleIpProtocol = (typeof GlobalForwardingRuleIpProtocol)[keyof typeof GlobalForwardingRuleIpProtocol]; export declare const GlobalForwardingRuleIpVersion: { readonly Ipv4: "IPV4"; readonly Ipv6: "IPV6"; readonly UnspecifiedVersion: "UNSPECIFIED_VERSION"; }; /** * The IP Version that will be used by this forwarding rule. Valid options are IPV4 or IPV6. */ export type GlobalForwardingRuleIpVersion = (typeof GlobalForwardingRuleIpVersion)[keyof typeof GlobalForwardingRuleIpVersion]; export declare const GlobalForwardingRuleLoadBalancingScheme: { readonly External: "EXTERNAL"; readonly ExternalManaged: "EXTERNAL_MANAGED"; readonly Internal: "INTERNAL"; readonly InternalManaged: "INTERNAL_MANAGED"; readonly InternalSelfManaged: "INTERNAL_SELF_MANAGED"; readonly Invalid: "INVALID"; }; /** * Specifies the forwarding rule type. For more information about forwarding rules, refer to Forwarding rule concepts. */ export type GlobalForwardingRuleLoadBalancingScheme = (typeof GlobalForwardingRuleLoadBalancingScheme)[keyof typeof GlobalForwardingRuleLoadBalancingScheme]; export declare const GlobalForwardingRuleNetworkTier: { /** * Public internet quality with fixed bandwidth. */ readonly FixedStandard: "FIXED_STANDARD"; /** * High quality, Google-grade network tier, support for all networking products. */ readonly Premium: "PREMIUM"; /** * Public internet quality, only limited support for other networking products. */ readonly Standard: "STANDARD"; /** * (Output only) Temporary tier for FIXED_STANDARD when fixed standard tier is expired or not configured. */ readonly StandardOverridesFixedStandard: "STANDARD_OVERRIDES_FIXED_STANDARD"; }; /** * This signifies the networking tier used for configuring this load balancer and can only take the following values: PREMIUM, STANDARD. For regional ForwardingRule, the valid values are PREMIUM and STANDARD. For GlobalForwardingRule, the valid value is PREMIUM. If this field is not specified, it is assumed to be PREMIUM. If IPAddress is specified, this value must be equal to the networkTier of the Address. */ export type GlobalForwardingRuleNetworkTier = (typeof GlobalForwardingRuleNetworkTier)[keyof typeof GlobalForwardingRuleNetworkTier]; export declare const GlobalForwardingRulePscConnectionStatus: { /** * The connection has been accepted by the producer. */ readonly Accepted: "ACCEPTED"; /** * The connection has been closed by the producer and will not serve traffic going forward. */ readonly Closed: "CLOSED"; /** * The connection has been accepted by the producer, but the producer needs to take further action before the forwarding rule can serve traffic. */ readonly NeedsAttention: "NEEDS_ATTENTION"; /** * The connection is pending acceptance by the producer. */ readonly Pending: "PENDING"; /** * The connection has been rejected by the producer. */ readonly Rejected: "REJECTED"; readonly StatusUnspecified: "STATUS_UNSPECIFIED"; }; export type GlobalForwardingRulePscConnectionStatus = (typeof GlobalForwardingRulePscConnectionStatus)[keyof typeof GlobalForwardingRulePscConnectionStatus]; export declare const GlobalNetworkEndpointGroupNetworkEndpointType: { /** * The network endpoint is represented by an IP address. */ readonly GceVmIp: "GCE_VM_IP"; /** * The network endpoint is represented by IP address and port pair. */ readonly GceVmIpPort: "GCE_VM_IP_PORT"; /** * The network endpoint is represented by fully qualified domain name and port. */ readonly InternetFqdnPort: "INTERNET_FQDN_PORT"; /** * The network endpoint is represented by an internet IP address and port. */ readonly InternetIpPort: "INTERNET_IP_PORT"; /** * The network endpoint is represented by an IP address and port. The endpoint belongs to a VM or pod running in a customer's on-premises. */ readonly NonGcpPrivateIpPort: "NON_GCP_PRIVATE_IP_PORT"; /** * The network endpoint is either public Google APIs or services exposed by other GCP Project with a Service Attachment. The connection is set up by private service connect */ readonly PrivateServiceConnect: "PRIVATE_SERVICE_CONNECT"; /** * The network endpoint is handled by specified serverless infrastructure. */ readonly Serverless: "SERVERLESS"; }; /** * Type of network endpoints in this network endpoint group. Can be one of GCE_VM_IP, GCE_VM_IP_PORT, NON_GCP_PRIVATE_IP_PORT, INTERNET_FQDN_PORT, INTERNET_IP_PORT, SERVERLESS, PRIVATE_SERVICE_CONNECT. */ export type GlobalNetworkEndpointGroupNetworkEndpointType = (typeof GlobalNetworkEndpointGroupNetworkEndpointType)[keyof typeof GlobalNetworkEndpointGroupNetworkEndpointType]; export declare const GuestOsFeatureType: { readonly FeatureTypeUnspecified: "FEATURE_TYPE_UNSPECIFIED"; readonly Gvnic: "GVNIC"; readonly MultiIpSubnet: "MULTI_IP_SUBNET"; readonly SecureBoot: "SECURE_BOOT"; readonly SevCapable: "SEV_CAPABLE"; readonly SevLiveMigratable: "SEV_LIVE_MIGRATABLE"; readonly SevLiveMigratableV2: "SEV_LIVE_MIGRATABLE_V2"; readonly SevSnpCapable: "SEV_SNP_CAPABLE"; readonly UefiCompatible: "UEFI_COMPATIBLE"; readonly VirtioScsiMultiqueue: "VIRTIO_SCSI_MULTIQUEUE"; readonly Windows: "WINDOWS"; }; /** * The ID of a supported feature. To add multiple values, use commas to separate values. Set to one or more of the following values: - VIRTIO_SCSI_MULTIQUEUE - WINDOWS - MULTI_IP_SUBNET - UEFI_COMPATIBLE - GVNIC - SEV_CAPABLE - SUSPEND_RESUME_COMPATIBLE - SEV_LIVE_MIGRATABLE - SEV_SNP_CAPABLE For more information, see Enabling guest operating system features. */ export type GuestOsFeatureType = (typeof GuestOsFeatureType)[keyof typeof GuestOsFeatureType]; export declare const HTTP2HealthCheckPortSpecification: { /** * The port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends. */ readonly UseFixedPort: "USE_FIXED_PORT"; /** * Not supported. */ readonly UseNamedPort: "USE_NAMED_PORT"; /** * For network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports. */ readonly UseServingPort: "USE_SERVING_PORT"; }; /** * Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports. */ export type HTTP2HealthCheckPortSpecification = (typeof HTTP2HealthCheckPortSpecification)[keyof typeof HTTP2HealthCheckPortSpecification]; export declare const HTTP2HealthCheckProxyHeader: { readonly None: "NONE"; readonly ProxyV1: "PROXY_V1"; }; /** * Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE. */ export type HTTP2HealthCheckProxyHeader = (typeof HTTP2HealthCheckProxyHeader)[keyof typeof HTTP2HealthCheckProxyHeader]; export declare const HTTPHealthCheckPortSpecification: { /** * The port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends. */ readonly UseFixedPort: "USE_FIXED_PORT"; /** * Not supported. */ readonly UseNamedPort: "USE_NAMED_PORT"; /** * For network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports. */ readonly UseServingPort: "USE_SERVING_PORT"; }; /** * Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Also supported in legacy HTTP health checks for target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports. */ export type HTTPHealthCheckPortSpecification = (typeof HTTPHealthCheckPortSpecification)[keyof typeof HTTPHealthCheckPortSpecification]; export declare const HTTPHealthCheckProxyHeader: { readonly None: "NONE"; readonly ProxyV1: "PROXY_V1"; }; /** * Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE. */ export type HTTPHealthCheckProxyHeader = (typeof HTTPHealthCheckProxyHeader)[keyof typeof HTTPHealthCheckProxyHeader]; export declare const HTTPSHealthCheckPortSpecification: { /** * The port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends. */ readonly UseFixedPort: "USE_FIXED_PORT"; /** * Not supported. */ readonly UseNamedPort: "USE_NAMED_PORT"; /** * For network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports. */ readonly UseServingPort: "USE_SERVING_PORT"; }; /** * Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports. */ export type HTTPSHealthCheckPortSpecification = (typeof HTTPSHealthCheckPortSpecification)[keyof typeof HTTPSHealthCheckPortSpecification]; export declare const HTTPSHealthCheckProxyHeader: { readonly None: "NONE"; readonly ProxyV1: "PROXY_V1"; }; /** * Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE. */ export type HTTPSHealthCheckProxyHeader = (typeof HTTPSHealthCheckProxyHeader)[keyof typeof HTTPSHealthCheckProxyHeader]; export declare const HealthCheckType: { readonly Grpc: "GRPC"; readonly Http: "HTTP"; readonly Http2: "HTTP2"; readonly Https: "HTTPS"; readonly Invalid: "INVALID"; readonly Ssl: "SSL"; readonly Tcp: "TCP"; }; /** * Specifies the type of the healthCheck, either TCP, SSL, HTTP, HTTPS, HTTP2 or GRPC. Exactly one of the protocol-specific health check fields must be specified, which must match type field. */ export type HealthCheckType = (typeof HealthCheckType)[keyof typeof HealthCheckType]; export declare const HttpRedirectActionRedirectResponseCode: { /** * Http Status Code 302 - Found. */ readonly Found: "FOUND"; /** * Http Status Code 301 - Moved Permanently. */ readonly MovedPermanentlyDefault: "MOVED_PERMANENTLY_DEFAULT"; /** * Http Status Code 308 - Permanent Redirect maintaining HTTP method. */ readonly PermanentRedirect: "PERMANENT_REDIRECT"; /** * Http Status Code 303 - See Other. */ readonly SeeOther: "SEE_OTHER"; /** * Http Status Code 307 - Temporary Redirect maintaining HTTP method. */ readonly TemporaryRedirect: "TEMPORARY_REDIRECT"; }; /** * 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 is retained. - PERMANENT_REDIRECT, which corresponds to 308. In this case, the request method is retained. */ export type HttpRedirectActionRedirectResponseCode = (typeof HttpRedirectActionRedirectResponseCode)[keyof typeof HttpRedirectActionRedirectResponseCode]; export declare const ImageArchitecture: { /** * Default value indicating Architecture is not set. */ readonly ArchitectureUnspecified: "ARCHITECTURE_UNSPECIFIED"; /** * Machines with architecture ARM64 */ readonly Arm64: "ARM64"; /** * Machines with architecture X86_64 */ readonly X8664: "X86_64"; }; /** * The architecture of the image. Valid values are ARM64 or X86_64. */ export type ImageArchitecture = (typeof ImageArchitecture)[keyof typeof ImageArchitecture]; export declare const ImageRawDiskContainerType: { readonly Tar: "TAR"; }; /** * 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. */ export type ImageRawDiskContainerType = (typeof ImageRawDiskContainerType)[keyof typeof ImageRawDiskContainerType]; export declare const ImageSourceType: { readonly Raw: "RAW"; }; /** * The type of the image used to create this disk. The default and only valid value is RAW. */ export type ImageSourceType = (typeof ImageSourceType)[keyof typeof ImageSourceType]; export declare const InstanceGroupManagerFailoverAction: { readonly NoFailover: "NO_FAILOVER"; readonly Unknown: "UNKNOWN"; }; /** * The action to perform in case of zone failure. Only one value is supported, NO_FAILOVER. The default is NO_FAILOVER. */ export type InstanceGroupManagerFailoverAction = (typeof InstanceGroupManagerFailoverAction)[keyof typeof InstanceGroupManagerFailoverAction]; export declare const InstanceGroupManagerInstanceLifecyclePolicyDefaultActionOnFailure: { /** * MIG deletes a failed or an unhealthy VM. Deleting the VM decreases the target size of the MIG. */ readonly Delete: "DELETE"; /** * MIG does not repair a failed or an unhealthy VM. */ readonly DoNothing: "DO_NOTHING"; /** * (Default) MIG automatically repairs a failed or an unhealthy VM by recreating it. For more information, see About repairing VMs in a MIG. */ readonly Repair: "REPAIR"; }; /** * The action that a MIG performs on a failed or an unhealthy VM. A VM is marked as unhealthy when the application running on that VM fails a health check. Valid values are - REPAIR (default): MIG automatically repairs a failed or an unhealthy VM by recreating it. For more information, see About repairing VMs in a MIG. - DO_NOTHING: MIG does not repair a failed or an unhealthy VM. */ export type InstanceGroupManagerInstanceLifecyclePolicyDefaultActionOnFailure = (typeof InstanceGroupManagerInstanceLifecyclePolicyDefaultActionOnFailure)[keyof typeof InstanceGroupManagerInstanceLifecyclePolicyDefaultActionOnFailure]; export declare const InstanceGroupManagerInstanceLifecyclePolicyForceUpdateOnRepair: { readonly No: "NO"; readonly Yes: "YES"; }; /** * A bit indicating whether to forcefully apply the group's latest configuration when repairing a VM. Valid options are: - NO (default): If configuration updates are available, they are not forcefully applied during repair. Instead, configuration updates are applied according to the group's update policy. - YES: If configuration updates are available, they are applied during repair. */ export type InstanceGroupManagerInstanceLifecyclePolicyForceUpdateOnRepair = (typeof InstanceGroupManagerInstanceLifecyclePolicyForceUpdateOnRepair)[keyof typeof InstanceGroupManagerInstanceLifecyclePolicyForceUpdateOnRepair]; export declare const InstanceGroupManagerListManagedInstancesResults: { /** * (Default) Pagination is disabled for the group's listManagedInstances API method. maxResults and pageToken query parameters are ignored and all instances are returned in a single response. */ readonly Pageless: "PAGELESS"; /** * Pagination is enabled for the group's listManagedInstances API method. maxResults and pageToken query parameters are respected. */ readonly Paginated: "PAGINATED"; }; /** * Pagination behavior of the listManagedInstances API method for this managed instance group. */ export type InstanceGroupManagerListManagedInstancesResults = (typeof InstanceGroupManagerListManagedInstancesResults)[keyof typeof InstanceGroupManagerListManagedInstancesResults]; export declare const InstanceGroupManagerStandbyPolicyMode: { /** * MIG does not automatically stop/start or suspend/resume VMs. */ readonly Manual: "MANUAL"; /** * MIG automatically resumes and starts VMs when it scales out, and replenishes the standby pool afterwards. */ readonly ScaleOutPool: "SCALE_OUT_POOL"; }; /** * Defines behaviour of using instances from standby pool to resize MIG. */ export type InstanceGroupManagerStandbyPolicyMode = (typeof InstanceGroupManagerStandbyPolicyMode)[keyof typeof InstanceGroupManagerStandbyPolicyMode]; export declare const InstanceGroupManagerUpdatePolicyInstanceRedistributionType: { /** * No action is being proactively performed in order to bring this IGM to its target instance distribution. */ readonly None: "NONE"; /** * This IGM will actively converge to its target instance distribution. */ readonly Proactive: "PROACTIVE"; }; /** * The instance redistribution policy for regional managed instance groups. Valid values are: - PROACTIVE (default): The group attempts to maintain an even distribution of VM instances across zones in the region. - NONE: For non-autoscaled groups, proactive redistribution is disabled. */ export type InstanceGroupManagerUpdatePolicyInstanceRedistributionType = (typeof InstanceGroupManagerUpdatePolicyInstanceRedistributionType)[keyof typeof InstanceGroupManagerUpdatePolicyInstanceRedistributionType]; export declare const InstanceGroupManagerUpdatePolicyMinimalAction: { /** * Do not perform any action. */ readonly None: "NONE"; /** * Do not stop the instance. */ readonly Refresh: "REFRESH"; /** * (Default.) Replace the instance according to the replacement method option. */ readonly Replace: "REPLACE"; /** * Stop the instance and start it again. */ readonly Restart: "RESTART"; }; /** * Minimal action to be taken on an instance. Use this option to minimize disruption as much as possible or to apply a more disruptive action than is necessary. - To limit disruption as much as possible, set the minimal action to REFRESH. If your update requires a more disruptive action, Compute Engine performs the necessary action to execute the update. - To apply a more disruptive action than is strictly necessary, set the minimal action to RESTART or REPLACE. For example, Compute Engine does not need to restart a VM to change its metadata. But if your application reads instance metadata only when a VM is restarted, you can set the minimal action to RESTART in order to pick up metadata changes. */ export type InstanceGroupManagerUpdatePolicyMinimalAction = (typeof InstanceGroupManagerUpdatePolicyMinimalAction)[keyof typeof InstanceGroupManagerUpdatePolicyMinimalAction]; export declare const InstanceGroupManagerUpdatePolicyMostDisruptiveAllowedAction: { /** * Do not perform any action. */ readonly None: "NONE"; /** * Do not stop the instance. */ readonly Refresh: "REFRESH"; /** * (Default.) Replace the instance according to the replacement method option. */ readonly Replace: "REPLACE"; /** * Stop the instance and start it again. */ readonly Restart: "RESTART"; }; /** * Most disruptive action that is allowed to be taken on an instance. You can specify either NONE to forbid any actions, REFRESH to avoid restarting the VM and to limit disruption as much as possible. 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. */ export type InstanceGroupManagerUpdatePolicyMostDisruptiveAllowedAction = (typeof InstanceGroupManagerUpdatePolicyMostDisruptiveAllowedAction)[keyof typeof InstanceGroupManagerUpdatePolicyMostDisruptiveAllowedAction]; export declare const InstanceGroupManagerUpdatePolicyReplacementMethod: { /** * Instances will be recreated (with the same name) */ readonly Recreate: "RECREATE"; /** * Default option: instances will be deleted and created (with a new name) */ readonly Substitute: "SUBSTITUTE"; }; /** * What action should be used to replace instances. See minimal_action.REPLACE */ export type InstanceGroupManagerUpdatePolicyReplacementMethod = (typeof InstanceGroupManagerUpdatePolicyReplacementMethod)[keyof typeof InstanceGroupManagerUpdatePolicyReplacementMethod]; export declare const InstanceGroupManagerUpdatePolicyType: { /** * MIG will apply new configurations to existing VMs only when you selectively target specific or all VMs to be updated. */ readonly Opportunistic: "OPPORTUNISTIC"; /** * MIG will automatically apply new configurations to all or a subset of existing VMs and also to new VMs that are added to the group. */ readonly Proactive: "PROACTIVE"; }; /** * The type of update process. You can specify either PROACTIVE so that the MIG automatically updates VMs to the latest configurations or OPPORTUNISTIC so that you can select the VMs that you want to update. */ export type InstanceGroupManagerUpdatePolicyType = (typeof InstanceGroupManagerUpdatePolicyType)[keyof typeof InstanceGroupManagerUpdatePolicyType]; export declare const InstanceKeyRevocationActionType: { /** * Default value. This value is unused. */ readonly KeyRevocationActionTypeUnspecified: "KEY_REVOCATION_ACTION_TYPE_UNSPECIFIED"; /** * Indicates user chose no operation. */ readonly None: "NONE"; /** * Indicates user chose to opt for VM shutdown on key revocation. */ readonly Stop: "STOP"; }; /** * KeyRevocationActionType of the instance. Supported options are "STOP" and "NONE". The default value is "NONE" if it is not specified. */ export type InstanceKeyRevocationActionType = (typeof InstanceKeyRevocationActionType)[keyof typeof InstanceKeyRevocationActionType]; export declare const InstancePostKeyRevocationActionType: { /** * Indicates user chose no operation. */ readonly Noop: "NOOP"; /** * Default value. This value is unused. */ readonly PostKeyRevocationActionTypeUnspecified: "POST_KEY_REVOCATION_ACTION_TYPE_UNSPECIFIED"; /** * Indicates user chose to opt for VM shutdown on key revocation. */ readonly Shutdown: "SHUTDOWN"; }; /** * PostKeyRevocationActionType of the instance. */ export type InstancePostKeyRevocationActionType = (typeof InstancePostKeyRevocationActionType)[keyof typeof InstancePostKeyRevocationActionType]; export declare const InstancePrivateIpv6GoogleAccess: { /** * Bidirectional private IPv6 access to/from Google services. If specified, the subnetwork who is attached to the instance's default network interface will be assigned an internal IPv6 prefix if it doesn't have before. */ readonly EnableBidirectionalAccessToGoogle: "ENABLE_BIDIRECTIONAL_ACCESS_TO_GOOGLE"; /** * Outbound private IPv6 access from VMs in this subnet to Google services. If specified, the subnetwork who is attached to the instance's default network interface will be assigned an internal IPv6 prefix if it doesn't have before. */ readonly EnableOutboundVmAccessToGoogle: "ENABLE_OUTBOUND_VM_ACCESS_TO_GOOGLE"; /** * Each network interface inherits PrivateIpv6GoogleAccess from its subnetwork. */ readonly InheritFromSubnetwork: "INHERIT_FROM_SUBNETWORK"; }; /** * The private IPv6 google access type for the VM. If not specified, use INHERIT_FROM_SUBNETWORK as default. */ export type InstancePrivateIpv6GoogleAccess = (typeof InstancePrivateIpv6GoogleAccess)[keyof typeof InstancePrivateIpv6GoogleAccess]; export declare const InstancePropertiesKeyRevocationActionType: { /** * Default value. This value is unused. */ readonly KeyRevocationActionTypeUnspecified: "KEY_REVOCATION_ACTION_TYPE_UNSPECIFIED"; /** * Indicates user chose no operation. */ readonly None: "NONE"; /** * Indicates user chose to opt for VM shutdown on key revocation. */ readonly Stop: "STOP"; }; /** * KeyRevocationActionType of the instance. Supported options are "STOP" and "NONE". The default value is "NONE" if it is not specified. */ export type InstancePropertiesKeyRevocationActionType = (typeof InstancePropertiesKeyRevocationActionType)[keyof typeof InstancePropertiesKeyRevocationActionType]; export declare const InstancePropertiesPostKeyRevocationActionType: { /** * Indicates user chose no operation. */ readonly Noop: "NOOP"; /** * Default value. This value is unused. */ readonly PostKeyRevocationActionTypeUnspecified: "POST_KEY_REVOCATION_ACTION_TYPE_UNSPECIFIED"; /** * Indicates user chose to opt for VM shutdown on key revocation. */ readonly Shutdown: "SHUTDOWN"; }; /** * PostKeyRevocationActionType of the instance. */ export type InstancePropertiesPostKeyRevocationActionType = (typeof InstancePropertiesPostKeyRevocationActionType)[keyof typeof InstancePropertiesPostKeyRevocationActionType]; export declare const InstancePropertiesPrivateIpv6GoogleAccess: { /** * Bidirectional private IPv6 access to/from Google services. If specified, the subnetwork who is attached to the instance's default network interface will be assigned an internal IPv6 prefix if it doesn't have before. */ readonly EnableBidirectionalAccessToGoogle: "ENABLE_BIDIRECTIONAL_ACCESS_TO_GOOGLE"; /** * Outbound private IPv6 access from VMs in this subnet to Google services. If specified, the subnetwork who is attached to the instance's default network interface will be assigned an internal IPv6 prefix if it doesn't have before. */ readonly EnableOutboundVmAccessToGoogle: "ENABLE_OUTBOUND_VM_ACCESS_TO_GOOGLE"; /** * Each network interface inherits PrivateIpv6GoogleAccess from its subnetwork. */ readonly InheritFromSubnetwork: "INHERIT_FROM_SUBNETWORK"; }; /** * The private IPv6 google access type for VMs. If not specified, use INHERIT_FROM_SUBNETWORK as default. Note that for MachineImage, this is not supported yet. */ export type InstancePropertiesPrivateIpv6GoogleAccess = (typeof InstancePropertiesPrivateIpv6GoogleAccess)[keyof typeof InstancePropertiesPrivateIpv6GoogleAccess]; export declare const InterconnectAttachmentBandwidth: { /** * 100 Mbit/s */ readonly Bps100m: "BPS_100M"; /** * 10 Gbit/s */ readonly Bps10g: "BPS_10G"; /** * 1 Gbit/s */ readonly Bps1g: "BPS_1G"; /** * 200 Mbit/s */ readonly Bps200m: "BPS_200M"; /** * 20 Gbit/s */ readonly Bps20g: "BPS_20G"; /** * 2 Gbit/s */ readonly Bps2g: "BPS_2G"; /** * 300 Mbit/s */ readonly Bps300m: "BPS_300M"; /** * 400 Mbit/s */ readonly Bps400m: "BPS_400M"; /** * 500 Mbit/s */ readonly Bps500m: "BPS_500M"; /** * 50 Gbit/s */ readonly Bps50g: "BPS_50G"; /** * 50 Mbit/s */ readonly Bps50m: "BPS_50M"; /** * 5 Gbit/s */ readonly Bps5g: "BPS_5G"; }; /** * Provisioned bandwidth capacity for the interconnect attachment. For attachments of type DEDICATED, the user can set the bandwidth. For attachments of type PARTNER, the Google Partner that is operating the interconnect must set the bandwidth. Output only for PARTNER type, mutable for PARTNER_PROVIDER and DEDICATED, and can take one of the following values: - BPS_50M: 50 Mbit/s - BPS_100M: 100 Mbit/s - BPS_200M: 200 Mbit/s - BPS_300M: 300 Mbit/s - BPS_400M: 400 Mbit/s - BPS_500M: 500 Mbit/s - BPS_1G: 1 Gbit/s - BPS_2G: 2 Gbit/s - BPS_5G: 5 Gbit/s - BPS_10G: 10 Gbit/s - BPS_20G: 20 Gbit/s - BPS_50G: 50 Gbit/s */ export type InterconnectAttachmentBandwidth = (typeof InterconnectAttachmentBandwidth)[keyof typeof InterconnectAttachmentBandwidth]; export declare const InterconnectAttachmentEdgeAvailabilityDomain: { readonly AvailabilityDomain1: "AVAILABILITY_DOMAIN_1"; readonly AvailabilityDomain2: "AVAILABILITY_DOMAIN_2"; readonly AvailabilityDomainAny: "AVAILABILITY_DOMAIN_ANY"; }; /** * Desired availability domain for the attachment. Only available for type PARTNER, at creation time, and can take one of the following values: - AVAILABILITY_DOMAIN_ANY - AVAILABILITY_DOMAIN_1 - AVAILABILITY_DOMAIN_2 For improved reliability, customers should configure a pair of attachments, one per availability domain. The selected availability domain will be provided to the Partner via the pairing key, so that the provisioned circuit will lie in the specified domain. If not specified, the value will default to AVAILABILITY_DOMAIN_ANY. */ export type InterconnectAttachmentEdgeAvailabilityDomain = (typeof InterconnectAttachmentEdgeAvailabilityDomain)[keyof typeof InterconnectAttachmentEdgeAvailabilityDomain]; export declare const InterconnectAttachmentEncryption: { /** * The interconnect attachment will carry only encrypted traffic that is encrypted by an IPsec device such as HA VPN gateway; VMs cannot directly send traffic to or receive traffic from such an interconnect attachment. To use HA VPN over Cloud Interconnect, the interconnect attachment must be created with this option. */ readonly Ipsec: "IPSEC"; /** * This is the default value, which means the Interconnect Attachment will carry unencrypted traffic. VMs will be able to send traffic to or receive traffic from such interconnect attachment. */ readonly None: "NONE"; }; /** * Indicates the user-supplied encryption option of this VLAN attachment (interconnectAttachment). Can only be specified at attachment creation for PARTNER or DEDICATED attachments. Possible values are: - NONE - This is the default value, which means that the VLAN attachment carries unencrypted traffic. VMs are able to send traffic to, or receive traffic from, such a VLAN attachment. - IPSEC - The VLAN attachment carries only encrypted traffic that is encrypted by an IPsec device, such as an HA VPN gateway or third-party IPsec VPN. VMs cannot directly send traffic to, or receive traffic from, such a VLAN attachment. To use *HA VPN over Cloud Interconnect*, the VLAN attachment must be created with this option. */ export type InterconnectAttachmentEncryption = (typeof InterconnectAttachmentEncryption)[keyof typeof InterconnectAttachmentEncryption]; export declare const InterconnectAttachmentStackType: { /** * The interconnect attachment can have both IPv4 and IPv6 addresses. */ readonly Ipv4Ipv6: "IPV4_IPV6"; /** * The interconnect attachment will only be assigned IPv4 addresses. */ readonly Ipv4Only: "IPV4_ONLY"; }; /** * The stack type for this interconnect attachment to identify whether the IPv6 feature is enabled or not. If not specified, IPV4_ONLY will be used. This field can be both set at interconnect attachments creation and update interconnect attachment operations. */ export type InterconnectAttachmentStackType = (typeof InterconnectAttachmentStackType)[keyof typeof InterconnectAttachmentStackType]; export declare const InterconnectAttachmentType: { /** * Attachment to a dedicated interconnect. */ readonly Dedicated: "DEDICATED"; /** * Attachment to a partner interconnect, created by the customer. */ readonly Partner: "PARTNER"; /** * Attachment to a partner interconnect, created by the partner. */ readonly PartnerProvider: "PARTNER_PROVIDER"; }; /** * The type of interconnect attachment this is, which can take one of the following values: - DEDICATED: an attachment to a Dedicated Interconnect. - PARTNER: an attachment to a Partner Interconnect, created by the customer. - PARTNER_PROVIDER: an attachment to a Partner Interconnect, created by the partner. */ export type InterconnectAttachmentType = (typeof InterconnectAttachmentType)[keyof typeof InterconnectAttachmentType]; export declare const InterconnectInterconnectType: { /** * A dedicated physical interconnection with the customer. */ readonly Dedicated: "DEDICATED"; /** * [Deprecated] A private, physical interconnection with the customer. */ readonly ItPrivate: "IT_PRIVATE"; /** * A partner-managed interconnection shared between customers via partner. */ readonly Partner: "PARTNER"; }; /** * Type of interconnect, which can take one of the following values: - PARTNER: A partner-managed interconnection shared between customers though a partner. - DEDICATED: A dedicated physical interconnection with the customer. Note that a value IT_PRIVATE has been deprecated in favor of DEDICATED. */ export type InterconnectInterconnectType = (typeof InterconnectInterconnectType)[keyof typeof InterconnectInterconnectType]; export declare const InterconnectLinkType: { /** * 100G Ethernet, LR Optics. */ readonly LinkTypeEthernet100gLr: "LINK_TYPE_ETHERNET_100G_LR"; /** * 10G Ethernet, LR Optics. [(rate_bps) = 10000000000]; */ readonly LinkTypeEthernet10gLr: "LINK_TYPE_ETHERNET_10G_LR"; }; /** * Type of link requested, which can take one of the following values: - LINK_TYPE_ETHERNET_10G_LR: A 10G Ethernet with LR optics - LINK_TYPE_ETHERNET_100G_LR: A 100G Ethernet with LR optics. Note that this field indicates the speed of each of the links in the bundle, not the speed of the entire bundle. */ export type InterconnectLinkType = (typeof InterconnectLinkType)[keyof typeof InterconnectLinkType]; export declare const InterconnectRequestedFeaturesItem: { /** * Media Access Control security (MACsec) */ readonly IfMacsec: "IF_MACSEC"; }; export type InterconnectRequestedFeaturesItem = (typeof InterconnectRequestedFeaturesItem)[keyof typeof InterconnectRequestedFeaturesItem]; export declare const LogConfigCloudAuditOptionsLogName: { /** * This is deprecated and has no effect. Do not use. */ readonly AdminActivity: "ADMIN_ACTIVITY"; /** * This is deprecated and has no effect. Do not use. */ readonly DataAccess: "DATA_ACCESS"; /** * This is deprecated and has no effect. Do not use. */ readonly UnspecifiedLogName: "UNSPECIFIED_LOG_NAME"; }; /** * This is deprecated and has no effect. Do not use. */ export type LogConfigCloudAuditOptionsLogName = (typeof LogConfigCloudAuditOptionsLogName)[keyof typeof LogConfigCloudAuditOptionsLogName]; export declare const LogConfigDataAccessOptionsLogMode: { /** * This is deprecated and has no effect. Do not use. */ readonly LogFailClosed: "LOG_FAIL_CLOSED"; /** * This is deprecated and has no effect. Do not use. */ readonly LogModeUnspecified: "LOG_MODE_UNSPECIFIED"; }; /** * This is deprecated and has no effect. Do not use. */ export type LogConfigDataAccessOptionsLogMode = (typeof LogConfigDataAccessOptionsLogMode)[keyof typeof LogConfigDataAccessOptionsLogMode]; export declare const MetadataFilterFilterMatchCriteria: { /** * Specifies that all filterLabels must match for the metadataFilter to be considered a match. */ readonly MatchAll: "MATCH_ALL"; /** * Specifies that any filterLabel must match for the metadataFilter to be considered a match. */ readonly MatchAny: "MATCH_ANY"; /** * Indicates that the match criteria was not set. A metadataFilter must never be created with this value. */ readonly NotSet: "NOT_SET"; }; /** * Specifies how individual filter label matches within the list of filterLabels and contributes toward 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. */ export type MetadataFilterFilterMatchCriteria = (typeof MetadataFilterFilterMatchCriteria)[keyof typeof MetadataFilterFilterMatchCriteria]; export declare const NetworkAttachmentConnectionPreference: { readonly AcceptAutomatic: "ACCEPT_AUTOMATIC"; readonly AcceptManual: "ACCEPT_MANUAL"; readonly Invalid: "INVALID"; }; export type NetworkAttachmentConnectionPreference = (typeof NetworkAttachmentConnectionPreference)[keyof typeof NetworkAttachmentConnectionPreference]; export declare const NetworkEndpointGroupNetworkEndpointType: { /** * The network endpoint is represented by an IP address. */ readonly GceVmIp: "GCE_VM_IP"; /** * The network endpoint is represented by IP address and port pair. */ readonly GceVmIpPort: "GCE_VM_IP_PORT"; /** * The network endpoint is represented by fully qualified domain name and port. */ readonly InternetFqdnPort: "INTERNET_FQDN_PORT"; /** * The network endpoint is represented by an internet IP address and port. */ readonly InternetIpPort: "INTERNET_IP_PORT"; /** * The network endpoint is represented by an IP address and port. The endpoint belongs to a VM or pod running in a customer's on-premises. */ readonly NonGcpPrivateIpPort: "NON_GCP_PRIVATE_IP_PORT"; /** * The network endpoint is either public Google APIs or services exposed by other GCP Project with a Service Attachment. The connection is set up by private service connect */ readonly PrivateServiceConnect: "PRIVATE_SERVICE_CONNECT"; /** * The network endpoint is handled by specified serverless infrastructure. */ readonly Serverless: "SERVERLESS"; }; /** * Type of network endpoints in this network endpoint group. Can be one of GCE_VM_IP, GCE_VM_IP_PORT, NON_GCP_PRIVATE_IP_PORT, INTERNET_FQDN_PORT, INTERNET_IP_PORT, SERVERLESS, PRIVATE_SERVICE_CONNECT. */ export type NetworkEndpointGroupNetworkEndpointType = (typeof NetworkEndpointGroupNetworkEndpointType)[keyof typeof NetworkEndpointGroupNetworkEndpointType]; export declare const NetworkInterfaceNicType: { /** * GVNIC */ readonly Gvnic: "GVNIC"; /** * No type specified. */ readonly UnspecifiedNicType: "UNSPECIFIED_NIC_TYPE"; /** * VIRTIO */ readonly VirtioNet: "VIRTIO_NET"; }; /** * The type of vNIC to be used on this interface. This may be gVNIC or VirtioNet. */ export type NetworkInterfaceNicType = (typeof NetworkInterfaceNicType)[keyof typeof NetworkInterfaceNicType]; export declare const NetworkInterfaceStackType: { /** * The network interface can have both IPv4 and IPv6 addresses. */ readonly Ipv4Ipv6: "IPV4_IPV6"; /** * The network interface will be assigned IPv4 address. */ readonly Ipv4Only: "IPV4_ONLY"; }; /** * The stack type for this network interface. To assign only IPv4 addresses, use IPV4_ONLY. To assign both IPv4 and IPv6 addresses, use IPV4_IPV6. If not specified, IPV4_ONLY is used. This field can be both set at instance creation and update network interface operations. */ export type NetworkInterfaceStackType = (typeof NetworkInterfaceStackType)[keyof typeof NetworkInterfaceStackType]; export declare const NetworkNetworkFirewallPolicyEnforcementOrder: { readonly AfterClassicFirewall: "AFTER_CLASSIC_FIREWALL"; readonly BeforeClassicFirewall: "BEFORE_CLASSIC_FIREWALL"; }; /** * The network firewall policy enforcement order. Can be either AFTER_CLASSIC_FIREWALL or BEFORE_CLASSIC_FIREWALL. Defaults to AFTER_CLASSIC_FIREWALL if the field is not specified. */ export type NetworkNetworkFirewallPolicyEnforcementOrder = (typeof NetworkNetworkFirewallPolicyEnforcementOrder)[keyof typeof NetworkNetworkFirewallPolicyEnforcementOrder]; export declare const NetworkPerformanceConfigTotalEgressBandwidthTier: { readonly Default: "DEFAULT"; readonly Tier1: "TIER_1"; }; export type NetworkPerformanceConfigTotalEgressBandwidthTier = (typeof NetworkPerformanceConfigTotalEgressBandwidthTier)[keyof typeof NetworkPerformanceConfigTotalEgressBandwidthTier]; export declare const NetworkRoutingConfigRoutingMode: { readonly Global: "GLOBAL"; readonly Regional: "REGIONAL"; }; /** * The network-wide routing mode to use. If set to REGIONAL, this network's Cloud Routers will only advertise routes with subnets of this network in the same region as the router. If set to GLOBAL, this network's Cloud Routers will advertise routes with all subnets of this network, across regions. */ export type NetworkRoutingConfigRoutingMode = (typeof NetworkRoutingConfigRoutingMode)[keyof typeof NetworkRoutingConfigRoutingMode]; export declare const NodeGroupAutoscalingPolicyMode: { readonly ModeUnspecified: "MODE_UNSPECIFIED"; /** * Autoscaling is disabled. */ readonly Off: "OFF"; /** * Autocaling is fully enabled. */ readonly On: "ON"; /** * Autoscaling will only scale out and will not remove nodes. */ readonly OnlyScaleOut: "ONLY_SCALE_OUT"; }; /** * The autoscaling mode. Set to one of: ON, OFF, or ONLY_SCALE_OUT. For more information, see Autoscaler modes. */ export type NodeGroupAutoscalingPolicyMode = (typeof NodeGroupAutoscalingPolicyMode)[keyof typeof NodeGroupAutoscalingPolicyMode]; export declare const NodeGroupMaintenanceInterval: { /** * VMs are eligible to receive infrastructure and hypervisor updates as they become available. This may result in more maintenance operations (live migrations or terminations) for the VM than the PERIODIC and RECURRENT options. */ readonly AsNeeded: "AS_NEEDED"; /** * VMs receive infrastructure and hypervisor updates on a periodic basis, minimizing the number of maintenance operations (live migrations or terminations) on an individual VM. This may mean a VM will take longer to receive an update than if it was configured for AS_NEEDED. Security updates will still be applied as soon as they are available. */ readonly Periodic: "PERIODIC"; /** * VMs receive infrastructure and hypervisor updates on a periodic basis, minimizing the number of maintenance operations (live migrations or terminations) on an individual VM. This may mean a VM will take longer to receive an update than if it was configured for AS_NEEDED. Security updates will still be applied as soon as they are available. RECURRENT is used for GEN3 and Slice of Hardware VMs. */ readonly Recurrent: "RECURRENT"; }; /** * Specifies the frequency of planned maintenance events. The accepted values are: `AS_NEEDED` and `RECURRENT`. */ export type NodeGroupMaintenanceInterval = (typeof NodeGroupMaintenanceInterval)[keyof typeof NodeGroupMaintenanceInterval]; export declare const NodeGroupMaintenancePolicy: { /** * Allow the node and corresponding instances to retain default maintenance behavior. */ readonly Default: "DEFAULT"; readonly MaintenancePolicyUnspecified: "MAINTENANCE_POLICY_UNSPECIFIED"; /** * When maintenance must be done on a node, the instances on that node will be moved to other nodes in the group. Instances with onHostMaintenance = MIGRATE will live migrate to their destinations while instances with onHostMaintenance = TERMINATE will terminate and then restart on their destination nodes if automaticRestart = true. */ readonly MigrateWithinNodeGroup: "MIGRATE_WITHIN_NODE_GROUP"; /** * Instances in this group will restart on the same node when maintenance has completed. Instances must have onHostMaintenance = TERMINATE, and they will only restart if automaticRestart = true. */ readonly RestartInPlace: "RESTART_IN_PLACE"; }; /** * Specifies how to handle instances when a node in the group undergoes maintenance. Set to one of: DEFAULT, RESTART_IN_PLACE, or MIGRATE_WITHIN_NODE_GROUP. The default value is DEFAULT. For more information, see Maintenance policies. */ export type NodeGroupMaintenancePolicy = (typeof NodeGroupMaintenancePolicy)[keyof typeof NodeGroupMaintenancePolicy]; export declare const NodeGroupStatus: { readonly Creating: "CREATING"; readonly Deleting: "DELETING"; readonly Invalid: "INVALID"; readonly Ready: "READY"; }; export type NodeGroupStatus = (typeof NodeGroupStatus)[keyof typeof NodeGroupStatus]; export declare const NodeTemplateCpuOvercommitType: { readonly CpuOvercommitTypeUnspecified: "CPU_OVERCOMMIT_TYPE_UNSPECIFIED"; readonly Enabled: "ENABLED"; readonly None: "NONE"; }; /** * CPU overcommit. */ export type NodeTemplateCpuOvercommitType = (typeof NodeTemplateCpuOvercommitType)[keyof typeof NodeTemplateCpuOvercommitType]; export declare const OrganizationSecurityPolicyType: { readonly CloudArmor: "CLOUD_ARMOR"; readonly CloudArmorEdge: "CLOUD_ARMOR_EDGE"; readonly CloudArmorNetwork: "CLOUD_ARMOR_NETWORK"; readonly Firewall: "FIREWALL"; }; /** * The type indicates the intended use of the security policy. - CLOUD_ARMOR: Cloud Armor backend security policies can be configured to filter incoming HTTP requests targeting backend services. They filter requests before they hit the origin servers. - CLOUD_ARMOR_EDGE: Cloud Armor edge security policies can be configured to filter incoming HTTP requests targeting backend services (including Cloud CDN-enabled) as well as backend buckets (Cloud Storage). They filter requests before the request is served from Google's cache. - CLOUD_ARMOR_INTERNAL_SERVICE: Cloud Armor internal service policies can be configured to filter HTTP requests targeting services managed by Traffic Director in a service mesh. They filter requests before the request is served from the application. - CLOUD_ARMOR_NETWORK: Cloud Armor network policies can be configured to filter packets targeting network load balancing resources such as backend services, target pools, target instances, and instances with external IPs. They filter requests before the request is served from the application. This field can be set only at resource creation time. */ export type OrganizationSecurityPolicyType = (typeof OrganizationSecurityPolicyType)[keyof typeof OrganizationSecurityPolicyType]; export declare const PacketMirroringEnable: { readonly False: "FALSE"; readonly True: "TRUE"; }; /** * Indicates whether or not this packet mirroring takes effect. If set to FALSE, this packet mirroring policy will not be enforced on the network. The default is TRUE. */ export type PacketMirroringEnable = (typeof PacketMirroringEnable)[keyof typeof PacketMirroringEnable]; export declare const PacketMirroringFilterDirection: { /** * Default, both directions are mirrored. */ readonly Both: "BOTH"; /** * Only egress traffic is mirrored. */ readonly Egress: "EGRESS"; /** * Only ingress traffic is mirrored. */ readonly Ingress: "INGRESS"; }; /** * Direction of traffic to mirror, either INGRESS, EGRESS, or BOTH. The default is BOTH. */ export type PacketMirroringFilterDirection = (typeof PacketMirroringFilterDirection)[keyof typeof PacketMirroringFilterDirection]; export declare const PublicAdvertisedPrefixPdpScope: { /** * The public delegated prefix is global only. The provisioning will take ~4 weeks. */ readonly Global: "GLOBAL"; /** * The public delegated prefixes is BYOIP V1 legacy prefix. This is output only value and no longer supported in BYOIP V2. */ readonly GlobalAndRegional: "GLOBAL_AND_REGIONAL"; /** * The public delegated prefix is regional only. The provisioning will take a few minutes. */ readonly Regional: "REGIONAL"; }; /** * Specifies how child public delegated prefix will be scoped. It could be one of following values: - `REGIONAL`: The public delegated prefix is regional only. The provisioning will take a few minutes. - `GLOBAL`: The public delegated prefix is global only. The provisioning will take ~4 weeks. - `GLOBAL_AND_REGIONAL` [output only]: The public delegated prefixes is BYOIP V1 legacy prefix. This is output only value and no longer supported in BYOIP V2. */ export type PublicAdvertisedPrefixPdpScope = (typeof PublicAdvertisedPrefixPdpScope)[keyof typeof PublicAdvertisedPrefixPdpScope]; export declare const PublicAdvertisedPrefixStatus: { /** * The prefix is announced to Internet. */ readonly AnnouncedToInternet: "ANNOUNCED_TO_INTERNET"; /** * RPKI validation is complete. */ readonly Initial: "INITIAL"; /** * The prefix is fully configured. */ readonly PrefixConfigurationComplete: "PREFIX_CONFIGURATION_COMPLETE"; /** * The prefix is being configured. */ readonly PrefixConfigurationInProgress: "PREFIX_CONFIGURATION_IN_PROGRESS"; /** * The prefix is being removed. */ readonly PrefixRemovalInProgress: "PREFIX_REMOVAL_IN_PROGRESS"; /** * User has configured the PTR. */ readonly PtrConfigured: "PTR_CONFIGURED"; /** * The prefix is currently withdrawn but ready to be announced. */ readonly ReadyToAnnounce: "READY_TO_ANNOUNCE"; /** * Reverse DNS lookup failed. */ readonly ReverseDnsLookupFailed: "REVERSE_DNS_LOOKUP_FAILED"; /** * Reverse DNS lookup is successful. */ readonly Validated: "VALIDATED"; }; /** * The status of the public advertised prefix. Possible values include: - `INITIAL`: RPKI validation is complete. - `PTR_CONFIGURED`: User has configured the PTR. - `VALIDATED`: Reverse DNS lookup is successful. - `REVERSE_DNS_LOOKUP_FAILED`: Reverse DNS lookup failed. - `PREFIX_CONFIGURATION_IN_PROGRESS`: The prefix is being configured. - `PREFIX_CONFIGURATION_COMPLETE`: The prefix is fully configured. - `PREFIX_REMOVAL_IN_PROGRESS`: The prefix is being removed. */ export type PublicAdvertisedPrefixStatus = (typeof PublicAdvertisedPrefixStatus)[keyof typeof PublicAdvertisedPrefixStatus]; export declare const RegionBackendServiceCompressionMode: { /** * Automatically uses the best compression based on the Accept-Encoding header sent by the client. */ readonly Automatic: "AUTOMATIC"; /** * Disables compression. Existing compressed responses cached by Cloud CDN will not be served to clients. */ readonly Disabled: "DISABLED"; }; /** * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header. */ export type RegionBackendServiceCompressionMode = (typeof RegionBackendServiceCompressionMode)[keyof typeof RegionBackendServiceCompressionMode]; export declare const RegionBackendServiceIpAddressSelectionPolicy: { /** * Only send IPv4 traffic to the backends of the Backend Service (Instance Group, Managed Instance Group, Network Endpoint Group) regardless of traffic from the client to the proxy. Only IPv4 health-checks are used to check the health of the backends. This is the default setting. */ readonly Ipv4Only: "IPV4_ONLY"; /** * Only send IPv6 traffic to the backends of the Backend Service (Instance Group, Managed Instance Group, Network Endpoint Group) regardless of traffic from the client to the proxy. Only IPv6 health-checks are used to check the health of the backends. */ readonly Ipv6Only: "IPV6_ONLY"; /** * Unspecified IP address selection policy. */ readonly IpAddressSelectionPolicyUnspecified: "IP_ADDRESS_SELECTION_POLICY_UNSPECIFIED"; /** * Prioritize the connection to the endpoints IPv6 address over its IPv4 address (provided there is a healthy IPv6 address). */ readonly PreferIpv6: "PREFER_IPV6"; }; /** * Specifies a preference for traffic sent from the proxy to the backend (or from the client to the backend for proxyless gRPC). The possible values are: - IPV4_ONLY: Only send IPv4 traffic to the backends of the backend service (Instance Group, Managed Instance Group, Network Endpoint Group), regardless of traffic from the client to the proxy. Only IPv4 health checks are used to check the health of the backends. This is the default setting. - PREFER_IPV6: Prioritize the connection to the endpoint's IPv6 address over its IPv4 address (provided there is a healthy IPv6 address). - IPV6_ONLY: Only send IPv6 traffic to the backends of the backend service (Instance Group, Managed Instance Group, Network Endpoint Group), regardless of traffic from the client to the proxy. Only IPv6 health checks are used to check the health of the backends. This field is applicable to either: - Advanced Global External HTTPS Load Balancing (load balancing scheme EXTERNAL_MANAGED), - Regional External HTTPS Load Balancing, - Internal TCP Proxy (load balancing scheme INTERNAL_MANAGED), - Regional Internal HTTPS Load Balancing (load balancing scheme INTERNAL_MANAGED), - Traffic Director with Envoy proxies and proxyless gRPC (load balancing scheme INTERNAL_SELF_MANAGED). */ export type RegionBackendServiceIpAddressSelectionPolicy = (typeof RegionBackendServiceIpAddressSelectionPolicy)[keyof typeof RegionBackendServiceIpAddressSelectionPolicy]; export declare const RegionBackendServiceLoadBalancingScheme: { /** * Signifies that this will be used for external HTTP(S), SSL Proxy, TCP Proxy, or Network Load Balancing */ readonly External: "EXTERNAL"; /** * Signifies that this will be used for External Managed HTTP(S) Load Balancing. */ readonly ExternalManaged: "EXTERNAL_MANAGED"; /** * Signifies that this will be used for Internal TCP/UDP Load Balancing. */ readonly Internal: "INTERNAL"; /** * Signifies that this will be used for Internal HTTP(S) Load Balancing. */ readonly InternalManaged: "INTERNAL_MANAGED"; /** * Signifies that this will be used by Traffic Director. */ readonly InternalSelfManaged: "INTERNAL_SELF_MANAGED"; readonly InvalidLoadBalancingScheme: "INVALID_LOAD_BALANCING_SCHEME"; }; /** * Specifies the load balancer type. A backend service created for one type of load balancer cannot be used with another. For more information, refer to Choosing a load balancer. */ export type RegionBackendServiceLoadBalancingScheme = (typeof RegionBackendServiceLoadBalancingScheme)[keyof typeof RegionBackendServiceLoadBalancingScheme]; export declare const RegionBackendServiceLocalityLbPolicy: { readonly InvalidLbPolicy: "INVALID_LB_POLICY"; /** * An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. */ readonly LeastRequest: "LEAST_REQUEST"; /** * This algorithm implements consistent hashing to backends. Maglev can be used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 */ readonly Maglev: "MAGLEV"; /** * Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. */ readonly OriginalDestination: "ORIGINAL_DESTINATION"; /** * The load balancer selects a random healthy host. */ readonly Random: "RANDOM"; /** * The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. */ readonly RingHash: "RING_HASH"; /** * This is a simple policy in which each healthy backend is selected in round robin order. This is the default. */ readonly RoundRobin: "ROUND_ROBIN"; /** * Per-instance weighted Load Balancing via health check reported weights. If set, the Backend Service must configure a non legacy HTTP-based Health Check, and health check replies are expected to contain non-standard HTTP response header field X-Load-Balancing-Endpoint-Weight to specify the per-instance weights. If set, Load Balancing is weighted based on the per-instance weights reported in the last processed health check replies, as long as every instance either reported a valid weight or had UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains equal-weight. This option is only supported in Network Load Balancing. */ readonly WeightedMaglev: "WEIGHTED_MAGLEV"; }; /** * The load balancing algorithm used within the scope of the locality. The possible values are: - ROUND_ROBIN: This is a simple policy in which each healthy backend is selected in round robin order. This is the default. - LEAST_REQUEST: An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. - RING_HASH: The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. - RANDOM: The load balancer selects a random healthy host. - ORIGINAL_DESTINATION: Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. - MAGLEV: used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED, INTERNAL_MANAGED, or EXTERNAL_MANAGED. If sessionAffinity is not NONE, and this field is not set to MAGLEV or RING_HASH, session affinity settings will not take effect. Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. */ export type RegionBackendServiceLocalityLbPolicy = (typeof RegionBackendServiceLocalityLbPolicy)[keyof typeof RegionBackendServiceLocalityLbPolicy]; export declare const RegionBackendServiceProtocol: { /** * gRPC (available for Traffic Director). */ readonly Grpc: "GRPC"; readonly Http: "HTTP"; /** * HTTP/2 with SSL. */ readonly Http2: "HTTP2"; readonly Https: "HTTPS"; /** * TCP proxying with SSL. */ readonly Ssl: "SSL"; /** * TCP proxying or TCP pass-through. */ readonly Tcp: "TCP"; /** * UDP. */ readonly Udp: "UDP"; /** * If a Backend Service has UNSPECIFIED as its protocol, it can be used with any L3/L4 Forwarding Rules. */ readonly Unspecified: "UNSPECIFIED"; }; /** * The protocol this BackendService uses to communicate with backends. Possible values are HTTP, HTTPS, HTTP2, TCP, SSL, UDP or GRPC. depending on the chosen load balancer or Traffic Director configuration. Refer to the documentation for the load balancers or for Traffic Director for more information. Must be set to GRPC when the backend service is referenced by a URL map that is bound to target gRPC proxy. */ export type RegionBackendServiceProtocol = (typeof RegionBackendServiceProtocol)[keyof typeof RegionBackendServiceProtocol]; export declare const RegionBackendServiceSessionAffinity: { /** * 2-tuple hash on packet's source and destination IP addresses. Connections from the same source IP address to the same destination IP address will be served by the same backend VM while that VM remains healthy. */ readonly ClientIp: "CLIENT_IP"; /** * 1-tuple hash only on packet's source IP address. Connections from the same source IP address will be served by the same backend VM while that VM remains healthy. This option can only be used for Internal TCP/UDP Load Balancing. */ readonly ClientIpNoDestination: "CLIENT_IP_NO_DESTINATION"; /** * 5-tuple hash on packet's source and destination IP addresses, IP protocol, and source and destination ports. Connections for the same IP protocol from the same source IP address and port to the same destination IP address and port will be served by the same backend VM while that VM remains healthy. This option cannot be used for HTTP(S) load balancing. */ readonly ClientIpPortProto: "CLIENT_IP_PORT_PROTO"; /** * 3-tuple hash on packet's source and destination IP addresses, and IP protocol. Connections for the same IP protocol from the same source IP address to the same destination IP address will be served by the same backend VM while that VM remains healthy. This option cannot be used for HTTP(S) load balancing. */ readonly ClientIpProto: "CLIENT_IP_PROTO"; /** * Hash based on a cookie generated by the L7 loadbalancer. Only valid for HTTP(S) load balancing. */ readonly GeneratedCookie: "GENERATED_COOKIE"; /** * The hash is based on a user specified header field. */ readonly HeaderField: "HEADER_FIELD"; /** * The hash is based on a user provided cookie. */ readonly HttpCookie: "HTTP_COOKIE"; /** * No session affinity. Connections from the same client IP may go to any instance in the pool. */ readonly None: "NONE"; }; /** * Type of session affinity to use. The default is NONE. Only NONE and HEADER_FIELD are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. For more details, see: [Session Affinity](https://cloud.google.com/load-balancing/docs/backend-service#session_affinity). */ export type RegionBackendServiceSessionAffinity = (typeof RegionBackendServiceSessionAffinity)[keyof typeof RegionBackendServiceSessionAffinity]; export declare const RegionCommitmentCategory: { readonly CategoryUnspecified: "CATEGORY_UNSPECIFIED"; readonly License: "LICENSE"; readonly Machine: "MACHINE"; }; /** * The category of the commitment. Category MACHINE specifies commitments composed of machine resources such as VCPU or MEMORY, listed in resources. Category LICENSE specifies commitments composed of software licenses, listed in licenseResources. Note that only MACHINE commitments should have a Type specified. */ export type RegionCommitmentCategory = (typeof RegionCommitmentCategory)[keyof typeof RegionCommitmentCategory]; export declare const RegionCommitmentPlan: { readonly Invalid: "INVALID"; readonly ThirtySixMonth: "THIRTY_SIX_MONTH"; readonly TwelveMonth: "TWELVE_MONTH"; }; /** * The plan for this commitment, which determines duration and discount rate. The currently supported plans are TWELVE_MONTH (1 year), and THIRTY_SIX_MONTH (3 years). */ export type RegionCommitmentPlan = (typeof RegionCommitmentPlan)[keyof typeof RegionCommitmentPlan]; export declare const RegionCommitmentType: { readonly AcceleratorOptimized: "ACCELERATOR_OPTIMIZED"; readonly AcceleratorOptimizedA3: "ACCELERATOR_OPTIMIZED_A3"; readonly ComputeOptimized: "COMPUTE_OPTIMIZED"; readonly ComputeOptimizedC2d: "COMPUTE_OPTIMIZED_C2D"; readonly ComputeOptimizedC3: "COMPUTE_OPTIMIZED_C3"; readonly ComputeOptimizedC3d: "COMPUTE_OPTIMIZED_C3D"; readonly ComputeOptimizedH3: "COMPUTE_OPTIMIZED_H3"; readonly GeneralPurpose: "GENERAL_PURPOSE"; readonly GeneralPurposeE2: "GENERAL_PURPOSE_E2"; readonly GeneralPurposeN2: "GENERAL_PURPOSE_N2"; readonly GeneralPurposeN2d: "GENERAL_PURPOSE_N2D"; readonly GeneralPurposeT2d: "GENERAL_PURPOSE_T2D"; readonly GraphicsOptimized: "GRAPHICS_OPTIMIZED"; readonly MemoryOptimized: "MEMORY_OPTIMIZED"; readonly MemoryOptimizedM3: "MEMORY_OPTIMIZED_M3"; readonly TypeUnspecified: "TYPE_UNSPECIFIED"; }; /** * The type of commitment, which affects the discount rate and the eligible resources. Type MEMORY_OPTIMIZED specifies a commitment that will only apply to memory optimized machines. Type ACCELERATOR_OPTIMIZED specifies a commitment that will only apply to accelerator optimized machines. */ export type RegionCommitmentType = (typeof RegionCommitmentType)[keyof typeof RegionCommitmentType]; export declare const RegionDiskArchitecture: { /** * Default value indicating Architecture is not set. */ readonly ArchitectureUnspecified: "ARCHITECTURE_UNSPECIFIED"; /** * Machines with architecture ARM64 */ readonly Arm64: "ARM64"; /** * Machines with architecture X86_64 */ readonly X8664: "X86_64"; }; /** * The architecture of the disk. Valid values are ARM64 or X86_64. */ export type RegionDiskArchitecture = (typeof RegionDiskArchitecture)[keyof typeof RegionDiskArchitecture]; export declare const RegionDiskInterface: { readonly Nvme: "NVME"; readonly Scsi: "SCSI"; readonly Unspecified: "UNSPECIFIED"; }; /** * [Deprecated] Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME. The default is SCSI. */ export type RegionDiskInterface = (typeof RegionDiskInterface)[keyof typeof RegionDiskInterface]; export declare const RegionDiskStorageType: { readonly Hdd: "HDD"; readonly Ssd: "SSD"; }; /** * [Deprecated] Storage type of the persistent disk. */ export type RegionDiskStorageType = (typeof RegionDiskStorageType)[keyof typeof RegionDiskStorageType]; export declare const RegionHealthCheckServiceHealthStatusAggregationPolicy: { /** * If any backend's health check reports UNHEALTHY, then UNHEALTHY is the HealthState of the entire health check service. If all backend's are healthy, the HealthState of the health check service is HEALTHY. */ readonly And: "AND"; /** * An EndpointHealth message is returned for each backend in the health check service. */ readonly NoAggregation: "NO_AGGREGATION"; }; /** * Optional. Policy for how the results from multiple health checks for the same endpoint are aggregated. Defaults to NO_AGGREGATION if unspecified. - NO_AGGREGATION. An EndpointHealth message is returned for each pair in the health check service. - AND. If any health check of an endpoint reports UNHEALTHY, then UNHEALTHY is the HealthState of the endpoint. If all health checks report HEALTHY, the HealthState of the endpoint is HEALTHY. . This is only allowed with regional HealthCheckService. */ export type RegionHealthCheckServiceHealthStatusAggregationPolicy = (typeof RegionHealthCheckServiceHealthStatusAggregationPolicy)[keyof typeof RegionHealthCheckServiceHealthStatusAggregationPolicy]; export declare const RegionHealthCheckServiceHealthStatusAggregationStrategy: { /** * This is deprecated. Use health_status_aggregation_policy instead. If any backend's health check reports UNHEALTHY, then UNHEALTHY is the HealthState of the entire health check service. If all backend's are healthy, the HealthState of the health check service is HEALTHY. */ readonly And: "AND"; /** * This is deprecated. Use health_status_aggregation_policy instead. An EndpointHealth message is returned for each backend in the health check service. */ readonly NoAggregation: "NO_AGGREGATION"; }; /** * This field is deprecated. Use health_status_aggregation_policy instead. Policy for how the results from multiple health checks for the same endpoint are aggregated. - NO_AGGREGATION. An EndpointHealth message is returned for each backend in the health check service. - AND. If any backend's health check reports UNHEALTHY, then UNHEALTHY is the HealthState of the entire health check service. If all backend's are healthy, the HealthState of the health check service is HEALTHY. . */ export type RegionHealthCheckServiceHealthStatusAggregationStrategy = (typeof RegionHealthCheckServiceHealthStatusAggregationStrategy)[keyof typeof RegionHealthCheckServiceHealthStatusAggregationStrategy]; export declare const RegionHealthCheckType: { readonly Grpc: "GRPC"; readonly Http: "HTTP"; readonly Http2: "HTTP2"; readonly Https: "HTTPS"; readonly Invalid: "INVALID"; readonly Ssl: "SSL"; readonly Tcp: "TCP"; }; /** * Specifies the type of the healthCheck, either TCP, SSL, HTTP, HTTPS, HTTP2 or GRPC. Exactly one of the protocol-specific health check fields must be specified, which must match type field. */ export type RegionHealthCheckType = (typeof RegionHealthCheckType)[keyof typeof RegionHealthCheckType]; export declare const RegionInstanceGroupManagerFailoverAction: { readonly NoFailover: "NO_FAILOVER"; readonly Unknown: "UNKNOWN"; }; /** * The action to perform in case of zone failure. Only one value is supported, NO_FAILOVER. The default is NO_FAILOVER. */ export type RegionInstanceGroupManagerFailoverAction = (typeof RegionInstanceGroupManagerFailoverAction)[keyof typeof RegionInstanceGroupManagerFailoverAction]; export declare const RegionInstanceGroupManagerListManagedInstancesResults: { /** * (Default) Pagination is disabled for the group's listManagedInstances API method. maxResults and pageToken query parameters are ignored and all instances are returned in a single response. */ readonly Pageless: "PAGELESS"; /** * Pagination is enabled for the group's listManagedInstances API method. maxResults and pageToken query parameters are respected. */ readonly Paginated: "PAGINATED"; }; /** * Pagination behavior of the listManagedInstances API method for this managed instance group. */ export type RegionInstanceGroupManagerListManagedInstancesResults = (typeof RegionInstanceGroupManagerListManagedInstancesResults)[keyof typeof RegionInstanceGroupManagerListManagedInstancesResults]; export declare const RegionNetworkEndpointGroupNetworkEndpointType: { /** * The network endpoint is represented by an IP address. */ readonly GceVmIp: "GCE_VM_IP"; /** * The network endpoint is represented by IP address and port pair. */ readonly GceVmIpPort: "GCE_VM_IP_PORT"; /** * The network endpoint is represented by fully qualified domain name and port. */ readonly InternetFqdnPort: "INTERNET_FQDN_PORT"; /** * The network endpoint is represented by an internet IP address and port. */ readonly InternetIpPort: "INTERNET_IP_PORT"; /** * The network endpoint is represented by an IP address and port. The endpoint belongs to a VM or pod running in a customer's on-premises. */ readonly NonGcpPrivateIpPort: "NON_GCP_PRIVATE_IP_PORT"; /** * The network endpoint is either public Google APIs or services exposed by other GCP Project with a Service Attachment. The connection is set up by private service connect */ readonly PrivateServiceConnect: "PRIVATE_SERVICE_CONNECT"; /** * The network endpoint is handled by specified serverless infrastructure. */ readonly Serverless: "SERVERLESS"; }; /** * Type of network endpoints in this network endpoint group. Can be one of GCE_VM_IP, GCE_VM_IP_PORT, NON_GCP_PRIVATE_IP_PORT, INTERNET_FQDN_PORT, INTERNET_IP_PORT, SERVERLESS, PRIVATE_SERVICE_CONNECT. */ export type RegionNetworkEndpointGroupNetworkEndpointType = (typeof RegionNetworkEndpointGroupNetworkEndpointType)[keyof typeof RegionNetworkEndpointGroupNetworkEndpointType]; export declare const RegionSecurityPolicyType: { readonly CloudArmor: "CLOUD_ARMOR"; readonly CloudArmorEdge: "CLOUD_ARMOR_EDGE"; readonly CloudArmorNetwork: "CLOUD_ARMOR_NETWORK"; readonly Firewall: "FIREWALL"; }; /** * The type indicates the intended use of the security policy. - CLOUD_ARMOR: Cloud Armor backend security policies can be configured to filter incoming HTTP requests targeting backend services. They filter requests before they hit the origin servers. - CLOUD_ARMOR_EDGE: Cloud Armor edge security policies can be configured to filter incoming HTTP requests targeting backend services (including Cloud CDN-enabled) as well as backend buckets (Cloud Storage). They filter requests before the request is served from Google's cache. - CLOUD_ARMOR_INTERNAL_SERVICE: Cloud Armor internal service policies can be configured to filter HTTP requests targeting services managed by Traffic Director in a service mesh. They filter requests before the request is served from the application. - CLOUD_ARMOR_NETWORK: Cloud Armor network policies can be configured to filter packets targeting network load balancing resources such as backend services, target pools, target instances, and instances with external IPs. They filter requests before the request is served from the application. This field can be set only at resource creation time. */ export type RegionSecurityPolicyType = (typeof RegionSecurityPolicyType)[keyof typeof RegionSecurityPolicyType]; export declare const RegionSslCertificateType: { /** * Google-managed SSLCertificate. */ readonly Managed: "MANAGED"; /** * Certificate uploaded by user. */ readonly SelfManaged: "SELF_MANAGED"; readonly TypeUnspecified: "TYPE_UNSPECIFIED"; }; /** * (Optional) Specifies the type of SSL certificate, either "SELF_MANAGED" or "MANAGED". If not specified, the certificate is self-managed and the fields certificate and private_key are used. */ export type RegionSslCertificateType = (typeof RegionSslCertificateType)[keyof typeof RegionSslCertificateType]; export declare const RegionSslPolicyMinTlsVersion: { /** * TLS 1.0 */ readonly Tls10: "TLS_1_0"; /** * TLS 1.1 */ readonly Tls11: "TLS_1_1"; /** * TLS 1.2 */ readonly Tls12: "TLS_1_2"; }; /** * The minimum version of SSL protocol that can be used by the clients to establish a connection with the load balancer. This can be one of TLS_1_0, TLS_1_1, TLS_1_2. */ export type RegionSslPolicyMinTlsVersion = (typeof RegionSslPolicyMinTlsVersion)[keyof typeof RegionSslPolicyMinTlsVersion]; export declare const RegionSslPolicyProfile: { /** * Compatible profile. Allows the broadset set of clients, even those which support only out-of-date SSL features to negotiate with the load balancer. */ readonly Compatible: "COMPATIBLE"; /** * Custom profile. Allow only the set of allowed SSL features specified in the customFeatures field. */ readonly Custom: "CUSTOM"; /** * Modern profile. Supports a wide set of SSL features, allowing modern clients to negotiate SSL with the load balancer. */ readonly Modern: "MODERN"; /** * Restricted profile. Supports a reduced set of SSL features, intended to meet stricter compliance requirements. */ readonly Restricted: "RESTRICTED"; }; /** * Profile specifies the set of SSL features that can be used by the load balancer when negotiating SSL with clients. This can be one of COMPATIBLE, MODERN, RESTRICTED, or CUSTOM. If using CUSTOM, the set of SSL features to enable must be specified in the customFeatures field. */ export type RegionSslPolicyProfile = (typeof RegionSslPolicyProfile)[keyof typeof RegionSslPolicyProfile]; export declare const RegionTargetHttpsProxyQuicOverride: { /** * The load balancer will not attempt to negotiate QUIC with clients. */ readonly Disable: "DISABLE"; /** * The load balancer will attempt to negotiate QUIC with clients. */ readonly Enable: "ENABLE"; /** * No overrides to the default QUIC policy. This option is implicit if no QUIC override has been specified in the request. */ readonly None: "NONE"; }; /** * Specifies the QUIC override policy for this TargetHttpsProxy resource. This setting determines whether the load balancer attempts to negotiate QUIC with clients. You can specify NONE, ENABLE, or DISABLE. - When quic-override is set to NONE, Google manages whether QUIC is used. - When quic-override is set to ENABLE, the load balancer uses QUIC when possible. - When quic-override is set to DISABLE, the load balancer doesn't use QUIC. - If the quic-override flag is not specified, NONE is implied. */ export type RegionTargetHttpsProxyQuicOverride = (typeof RegionTargetHttpsProxyQuicOverride)[keyof typeof RegionTargetHttpsProxyQuicOverride]; export declare const RegionTargetTcpProxyProxyHeader: { readonly None: "NONE"; readonly ProxyV1: "PROXY_V1"; }; /** * Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE. */ export type RegionTargetTcpProxyProxyHeader = (typeof RegionTargetTcpProxyProxyHeader)[keyof typeof RegionTargetTcpProxyProxyHeader]; export declare const ReservationAffinityConsumeReservationType: { /** * Consume any allocation available. */ readonly AnyReservation: "ANY_RESERVATION"; /** * Do not consume from any allocated capacity. */ readonly NoReservation: "NO_RESERVATION"; /** * Must consume from a specific reservation. Must specify key value fields for specifying the reservations. */ readonly SpecificReservation: "SPECIFIC_RESERVATION"; /** * Prefer to consume from a specific reservation, but still consume any reservation available if the specified reservation is not available or exhausted. Must specify key value fields for specifying the reservations. */ readonly SpecificThenAnyReservation: "SPECIFIC_THEN_ANY_RESERVATION"; /** * Prefer to consume from a specific reservation, but still consume from the on-demand pool if the specified reservation is exhausted. Must specify key value fields for specifying the reservations. */ readonly SpecificThenNoReservation: "SPECIFIC_THEN_NO_RESERVATION"; readonly Unspecified: "UNSPECIFIED"; }; /** * Specifies the type of reservation from which this instance can consume resources: ANY_RESERVATION (default), SPECIFIC_RESERVATION, or NO_RESERVATION. See Consuming reserved instances for examples. */ export type ReservationAffinityConsumeReservationType = (typeof ReservationAffinityConsumeReservationType)[keyof typeof ReservationAffinityConsumeReservationType]; export declare const ResourceCommitmentType: { readonly Accelerator: "ACCELERATOR"; readonly LocalSsd: "LOCAL_SSD"; readonly Memory: "MEMORY"; readonly Unspecified: "UNSPECIFIED"; readonly Vcpu: "VCPU"; }; /** * Type of resource for which this commitment applies. Possible values are VCPU, MEMORY, LOCAL_SSD, and ACCELERATOR. */ export type ResourceCommitmentType = (typeof ResourceCommitmentType)[keyof typeof ResourceCommitmentType]; export declare const ResourcePolicyGroupPlacementPolicyCollocation: { readonly Collocated: "COLLOCATED"; readonly UnspecifiedCollocation: "UNSPECIFIED_COLLOCATION"; }; /** * Specifies network collocation */ export type ResourcePolicyGroupPlacementPolicyCollocation = (typeof ResourcePolicyGroupPlacementPolicyCollocation)[keyof typeof ResourcePolicyGroupPlacementPolicyCollocation]; export declare const ResourcePolicySnapshotSchedulePolicyRetentionPolicyOnSourceDiskDelete: { readonly ApplyRetentionPolicy: "APPLY_RETENTION_POLICY"; readonly KeepAutoSnapshots: "KEEP_AUTO_SNAPSHOTS"; readonly UnspecifiedOnSourceDiskDelete: "UNSPECIFIED_ON_SOURCE_DISK_DELETE"; }; /** * Specifies the behavior to apply to scheduled snapshots when the source disk is deleted. */ export type ResourcePolicySnapshotSchedulePolicyRetentionPolicyOnSourceDiskDelete = (typeof ResourcePolicySnapshotSchedulePolicyRetentionPolicyOnSourceDiskDelete)[keyof typeof ResourcePolicySnapshotSchedulePolicyRetentionPolicyOnSourceDiskDelete]; export declare const ResourcePolicyWeeklyCycleDayOfWeekDay: { readonly Friday: "FRIDAY"; readonly Invalid: "INVALID"; readonly Monday: "MONDAY"; readonly Saturday: "SATURDAY"; readonly Sunday: "SUNDAY"; readonly Thursday: "THURSDAY"; readonly Tuesday: "TUESDAY"; readonly Wednesday: "WEDNESDAY"; }; /** * Defines a schedule that runs on specific days of the week. Specify one or more days. The following options are available: MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY. */ export type ResourcePolicyWeeklyCycleDayOfWeekDay = (typeof ResourcePolicyWeeklyCycleDayOfWeekDay)[keyof typeof ResourcePolicyWeeklyCycleDayOfWeekDay]; export declare const RouterBgpAdvertiseMode: { readonly Custom: "CUSTOM"; readonly Default: "DEFAULT"; }; /** * User-specified flag to indicate which mode to use for advertisement. The options are DEFAULT or CUSTOM. */ export type RouterBgpAdvertiseMode = (typeof RouterBgpAdvertiseMode)[keyof typeof RouterBgpAdvertiseMode]; export declare const RouterBgpAdvertisedGroupsItem: { /** * Advertise all available subnets (including peer VPC subnets). */ readonly AllSubnets: "ALL_SUBNETS"; }; export type RouterBgpAdvertisedGroupsItem = (typeof RouterBgpAdvertisedGroupsItem)[keyof typeof RouterBgpAdvertisedGroupsItem]; export declare const RouterBgpPeerAdvertiseMode: { readonly Custom: "CUSTOM"; readonly Default: "DEFAULT"; }; /** * User-specified flag to indicate which mode to use for advertisement. */ export type RouterBgpPeerAdvertiseMode = (typeof RouterBgpPeerAdvertiseMode)[keyof typeof RouterBgpPeerAdvertiseMode]; export declare const RouterBgpPeerAdvertisedGroupsItem: { /** * Advertise all available subnets (including peer VPC subnets). */ readonly AllSubnets: "ALL_SUBNETS"; }; export type RouterBgpPeerAdvertisedGroupsItem = (typeof RouterBgpPeerAdvertisedGroupsItem)[keyof typeof RouterBgpPeerAdvertisedGroupsItem]; export declare const RouterBgpPeerBfdSessionInitializationMode: { readonly Active: "ACTIVE"; readonly Disabled: "DISABLED"; readonly Passive: "PASSIVE"; }; /** * 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. The default is DISABLED. */ export type RouterBgpPeerBfdSessionInitializationMode = (typeof RouterBgpPeerBfdSessionInitializationMode)[keyof typeof RouterBgpPeerBfdSessionInitializationMode]; export declare const RouterBgpPeerEnable: { readonly False: "FALSE"; readonly True: "TRUE"; }; /** * The status of the BGP peer connection. If set to FALSE, any active session with the peer is terminated and all associated routing information is removed. If set to TRUE, the peer connection can be established with routing information. The default is TRUE. */ export type RouterBgpPeerEnable = (typeof RouterBgpPeerEnable)[keyof typeof RouterBgpPeerEnable]; export declare const RouterInterfaceIpVersion: { readonly Ipv4: "IPV4"; readonly Ipv6: "IPV6"; }; /** * IP version of this interface. */ export type RouterInterfaceIpVersion = (typeof RouterInterfaceIpVersion)[keyof typeof RouterInterfaceIpVersion]; export declare const RouterNatAutoNetworkTier: { /** * Public internet quality with fixed bandwidth. */ readonly FixedStandard: "FIXED_STANDARD"; /** * High quality, Google-grade network tier, support for all networking products. */ readonly Premium: "PREMIUM"; /** * Public internet quality, only limited support for other networking products. */ readonly Standard: "STANDARD"; /** * (Output only) Temporary tier for FIXED_STANDARD when fixed standard tier is expired or not configured. */ readonly StandardOverridesFixedStandard: "STANDARD_OVERRIDES_FIXED_STANDARD"; }; /** * The network tier to use when automatically reserving NAT IP addresses. Must be one of: PREMIUM, STANDARD. If not specified, then the current project-level default tier is used. */ export type RouterNatAutoNetworkTier = (typeof RouterNatAutoNetworkTier)[keyof typeof RouterNatAutoNetworkTier]; export declare const RouterNatEndpointTypesItem: { /** * This is used for regional Application Load Balancers (internal and external) and regional proxy Network Load Balancers (internal and external) endpoints. */ readonly EndpointTypeManagedProxyLb: "ENDPOINT_TYPE_MANAGED_PROXY_LB"; /** * This is used for Secure Web Gateway endpoints. */ readonly EndpointTypeSwg: "ENDPOINT_TYPE_SWG"; /** * This is the default. */ readonly EndpointTypeVm: "ENDPOINT_TYPE_VM"; }; export type RouterNatEndpointTypesItem = (typeof RouterNatEndpointTypesItem)[keyof typeof RouterNatEndpointTypesItem]; export declare const RouterNatLogConfigFilter: { /** * Export logs for all (successful and unsuccessful) connections. */ readonly All: "ALL"; /** * Export logs for connection failures only. */ readonly ErrorsOnly: "ERRORS_ONLY"; /** * Export logs for successful connections only. */ readonly TranslationsOnly: "TRANSLATIONS_ONLY"; }; /** * Specify the desired filtering of logs on this NAT. If unspecified, logs are exported for all connections handled by this NAT. This option can take one of the following values: - ERRORS_ONLY: Export logs only for connection failures. - TRANSLATIONS_ONLY: Export logs only for successful connections. - ALL: Export logs for all connections, successful and unsuccessful. */ export type RouterNatLogConfigFilter = (typeof RouterNatLogConfigFilter)[keyof typeof RouterNatLogConfigFilter]; export declare const RouterNatNatIpAllocateOption: { /** * Nat IPs are allocated by GCP; customers can not specify any Nat IPs. */ readonly AutoOnly: "AUTO_ONLY"; /** * Only use Nat IPs provided by customers. When specified Nat IPs are not enough then the Nat service fails for new VMs. */ readonly ManualOnly: "MANUAL_ONLY"; }; /** * Specify the NatIpAllocateOption, which can take one of the following values: - MANUAL_ONLY: Uses only Nat IP addresses provided by customers. When there are not enough specified Nat IPs, the Nat service fails for new VMs. - AUTO_ONLY: Nat IPs are allocated by Google Cloud Platform; customers can't specify any Nat IPs. When choosing AUTO_ONLY, then nat_ip should be empty. */ export type RouterNatNatIpAllocateOption = (typeof RouterNatNatIpAllocateOption)[keyof typeof RouterNatNatIpAllocateOption]; export declare const RouterNatSourceSubnetworkIpRangesToNat: { /** * All the IP ranges in every Subnetwork are allowed to Nat. */ readonly AllSubnetworksAllIpRanges: "ALL_SUBNETWORKS_ALL_IP_RANGES"; /** * All the primary IP ranges in every Subnetwork are allowed to Nat. */ readonly AllSubnetworksAllPrimaryIpRanges: "ALL_SUBNETWORKS_ALL_PRIMARY_IP_RANGES"; /** * A list of Subnetworks are allowed to Nat (specified in the field subnetwork below) */ readonly ListOfSubnetworks: "LIST_OF_SUBNETWORKS"; }; /** * Specify the Nat option, which can take one of the following values: - ALL_SUBNETWORKS_ALL_IP_RANGES: All of the IP ranges in every Subnetwork are allowed to Nat. - ALL_SUBNETWORKS_ALL_PRIMARY_IP_RANGES: All of the primary IP ranges in every Subnetwork are allowed to Nat. - LIST_OF_SUBNETWORKS: A list of Subnetworks are allowed to Nat (specified in the field subnetwork below) The default is SUBNETWORK_IP_RANGE_TO_NAT_OPTION_UNSPECIFIED. Note that if this field contains ALL_SUBNETWORKS_ALL_IP_RANGES then there should not be any other Router.Nat section in any Router for this network in this region. */ export type RouterNatSourceSubnetworkIpRangesToNat = (typeof RouterNatSourceSubnetworkIpRangesToNat)[keyof typeof RouterNatSourceSubnetworkIpRangesToNat]; export declare const RouterNatSubnetworkToNatSourceIpRangesToNatItem: { /** * The primary and all the secondary ranges are allowed to Nat. */ readonly AllIpRanges: "ALL_IP_RANGES"; /** * A list of secondary ranges are allowed to Nat. */ readonly ListOfSecondaryIpRanges: "LIST_OF_SECONDARY_IP_RANGES"; /** * The primary range is allowed to Nat. */ readonly PrimaryIpRange: "PRIMARY_IP_RANGE"; }; export type RouterNatSubnetworkToNatSourceIpRangesToNatItem = (typeof RouterNatSubnetworkToNatSourceIpRangesToNatItem)[keyof typeof RouterNatSubnetworkToNatSourceIpRangesToNatItem]; export declare const RouterNatType: { /** * NAT used for private IP translation. */ readonly Private: "PRIVATE"; /** * NAT used for public IP translation. This is the default. */ readonly Public: "PUBLIC"; }; /** * Indicates whether this NAT is used for public or private IP translation. If unspecified, it defaults to PUBLIC. */ export type RouterNatType = (typeof RouterNatType)[keyof typeof RouterNatType]; export declare const RuleAction: { /** * This is deprecated and has no effect. Do not use. */ readonly Allow: "ALLOW"; /** * This is deprecated and has no effect. Do not use. */ readonly AllowWithLog: "ALLOW_WITH_LOG"; /** * This is deprecated and has no effect. Do not use. */ readonly Deny: "DENY"; /** * This is deprecated and has no effect. Do not use. */ readonly DenyWithLog: "DENY_WITH_LOG"; /** * This is deprecated and has no effect. Do not use. */ readonly Log: "LOG"; /** * This is deprecated and has no effect. Do not use. */ readonly NoAction: "NO_ACTION"; }; /** * This is deprecated and has no effect. Do not use. */ export type RuleAction = (typeof RuleAction)[keyof typeof RuleAction]; export declare const SSLHealthCheckPortSpecification: { /** * The port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends. */ readonly UseFixedPort: "USE_FIXED_PORT"; /** * Not supported. */ readonly UseNamedPort: "USE_NAMED_PORT"; /** * For network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports. */ readonly UseServingPort: "USE_SERVING_PORT"; }; /** * Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports. */ export type SSLHealthCheckPortSpecification = (typeof SSLHealthCheckPortSpecification)[keyof typeof SSLHealthCheckPortSpecification]; export declare const SSLHealthCheckProxyHeader: { readonly None: "NONE"; readonly ProxyV1: "PROXY_V1"; }; /** * Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE. */ export type SSLHealthCheckProxyHeader = (typeof SSLHealthCheckProxyHeader)[keyof typeof SSLHealthCheckProxyHeader]; export declare const SchedulingInstanceTerminationAction: { /** * Delete the VM. */ readonly Delete: "DELETE"; /** * Default value. This value is unused. */ readonly InstanceTerminationActionUnspecified: "INSTANCE_TERMINATION_ACTION_UNSPECIFIED"; /** * Stop the VM without storing in-memory content. default action. */ readonly Stop: "STOP"; }; /** * Specifies the termination action for the instance. */ export type SchedulingInstanceTerminationAction = (typeof SchedulingInstanceTerminationAction)[keyof typeof SchedulingInstanceTerminationAction]; export declare const SchedulingMaintenanceInterval: { /** * VMs are eligible to receive infrastructure and hypervisor updates as they become available. This may result in more maintenance operations (live migrations or terminations) for the VM than the PERIODIC and RECURRENT options. */ readonly AsNeeded: "AS_NEEDED"; /** * VMs receive infrastructure and hypervisor updates on a periodic basis, minimizing the number of maintenance operations (live migrations or terminations) on an individual VM. This may mean a VM will take longer to receive an update than if it was configured for AS_NEEDED. Security updates will still be applied as soon as they are available. */ readonly Periodic: "PERIODIC"; /** * VMs receive infrastructure and hypervisor updates on a periodic basis, minimizing the number of maintenance operations (live migrations or terminations) on an individual VM. This may mean a VM will take longer to receive an update than if it was configured for AS_NEEDED. Security updates will still be applied as soon as they are available. RECURRENT is used for GEN3 and Slice of Hardware VMs. */ readonly Recurrent: "RECURRENT"; }; /** * Specifies the frequency of planned maintenance events. The accepted values are: `PERIODIC`. */ export type SchedulingMaintenanceInterval = (typeof SchedulingMaintenanceInterval)[keyof typeof SchedulingMaintenanceInterval]; export declare const SchedulingNodeAffinityOperator: { /** * Requires Compute Engine to seek for matched nodes. */ readonly In: "IN"; /** * Requires Compute Engine to avoid certain nodes. */ readonly NotIn: "NOT_IN"; readonly OperatorUnspecified: "OPERATOR_UNSPECIFIED"; }; /** * Defines the operation of node selection. Valid operators are IN for affinity and NOT_IN for anti-affinity. */ export type SchedulingNodeAffinityOperator = (typeof SchedulingNodeAffinityOperator)[keyof typeof SchedulingNodeAffinityOperator]; export declare const SchedulingOnHostMaintenance: { /** * *[Default]* Allows Compute Engine to automatically migrate instances out of the way of maintenance events. */ readonly Migrate: "MIGRATE"; /** * Tells Compute Engine to terminate and (optionally) restart the instance away from the maintenance activity. If you would like your instance to be restarted, set the automaticRestart flag to true. Your instance may be restarted more than once, and it may be restarted outside the window of maintenance events. */ readonly Terminate: "TERMINATE"; }; /** * Defines the maintenance behavior for this instance. For standard instances, the default behavior is MIGRATE. For preemptible instances, the default and only possible behavior is TERMINATE. For more information, see Set VM host maintenance policy. */ export type SchedulingOnHostMaintenance = (typeof SchedulingOnHostMaintenance)[keyof typeof SchedulingOnHostMaintenance]; export declare const SchedulingProvisioningModel: { /** * Heavily discounted, no guaranteed runtime. */ readonly Spot: "SPOT"; /** * Standard provisioning with user controlled runtime, no discounts. */ readonly Standard: "STANDARD"; }; /** * Specifies the provisioning model of the instance. */ export type SchedulingProvisioningModel = (typeof SchedulingProvisioningModel)[keyof typeof SchedulingProvisioningModel]; export declare const SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigRuleVisibility: { readonly Premium: "PREMIUM"; readonly Standard: "STANDARD"; }; /** * Rule visibility can be one of the following: STANDARD - opaque rules. (default) PREMIUM - transparent rules. This field is only supported in Global Security Policies of type CLOUD_ARMOR. */ export type SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigRuleVisibility = (typeof SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigRuleVisibility)[keyof typeof SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigRuleVisibility]; export declare const SecurityPolicyAdvancedOptionsConfigJsonParsing: { readonly Disabled: "DISABLED"; readonly Standard: "STANDARD"; readonly StandardWithGraphql: "STANDARD_WITH_GRAPHQL"; }; export type SecurityPolicyAdvancedOptionsConfigJsonParsing = (typeof SecurityPolicyAdvancedOptionsConfigJsonParsing)[keyof typeof SecurityPolicyAdvancedOptionsConfigJsonParsing]; export declare const SecurityPolicyAdvancedOptionsConfigLogLevel: { readonly Normal: "NORMAL"; readonly Verbose: "VERBOSE"; }; export type SecurityPolicyAdvancedOptionsConfigLogLevel = (typeof SecurityPolicyAdvancedOptionsConfigLogLevel)[keyof typeof SecurityPolicyAdvancedOptionsConfigLogLevel]; export declare const SecurityPolicyDdosProtectionConfigDdosProtection: { readonly Advanced: "ADVANCED"; readonly AdvancedPreview: "ADVANCED_PREVIEW"; readonly Standard: "STANDARD"; }; export type SecurityPolicyDdosProtectionConfigDdosProtection = (typeof SecurityPolicyDdosProtectionConfigDdosProtection)[keyof typeof SecurityPolicyDdosProtectionConfigDdosProtection]; export declare const SecurityPolicyRuleDirection: { readonly Egress: "EGRESS"; readonly Ingress: "INGRESS"; }; /** * The direction in which this rule applies. This field may only be specified when versioned_expr is set to FIREWALL. */ export type SecurityPolicyRuleDirection = (typeof SecurityPolicyRuleDirection)[keyof typeof SecurityPolicyRuleDirection]; export declare const SecurityPolicyRuleMatcherVersionedExpr: { readonly Firewall: "FIREWALL"; /** * Matches the source IP address of a request to the IP ranges supplied in config. */ readonly SrcIpsV1: "SRC_IPS_V1"; }; /** * Preconfigured versioned expression. If this field is specified, config must also be specified. Available preconfigured expressions along with their requirements are: SRC_IPS_V1 - must specify the corresponding src_ip_range field in config. */ export type SecurityPolicyRuleMatcherVersionedExpr = (typeof SecurityPolicyRuleMatcherVersionedExpr)[keyof typeof SecurityPolicyRuleMatcherVersionedExpr]; export declare const SecurityPolicyRulePreconfiguredWafConfigExclusionFieldParamsOp: { /** * The operator matches if the field value contains the specified value. */ readonly Contains: "CONTAINS"; /** * The operator matches if the field value ends with the specified value. */ readonly EndsWith: "ENDS_WITH"; /** * The operator matches if the field value equals the specified value. */ readonly Equals: "EQUALS"; /** * The operator matches if the field value is any value. */ readonly EqualsAny: "EQUALS_ANY"; /** * The operator matches if the field value starts with the specified value. */ readonly StartsWith: "STARTS_WITH"; }; /** * The match operator for the field. */ export type SecurityPolicyRulePreconfiguredWafConfigExclusionFieldParamsOp = (typeof SecurityPolicyRulePreconfiguredWafConfigExclusionFieldParamsOp)[keyof typeof SecurityPolicyRulePreconfiguredWafConfigExclusionFieldParamsOp]; export declare const SecurityPolicyRuleRateLimitOptionsEnforceOnKey: { readonly All: "ALL"; readonly AllIps: "ALL_IPS"; readonly HttpCookie: "HTTP_COOKIE"; readonly HttpHeader: "HTTP_HEADER"; readonly HttpPath: "HTTP_PATH"; readonly Ip: "IP"; readonly RegionCode: "REGION_CODE"; readonly Sni: "SNI"; readonly XffIp: "XFF_IP"; }; /** * Determines the key to enforce the rate_limit_threshold on. Possible values are: - ALL: A single rate limit threshold is applied to all the requests matching this rule. This is the default value if "enforceOnKey" is not configured. - IP: The source IP address of the request is the key. Each IP has this limit enforced separately. - HTTP_HEADER: The value of the HTTP header whose name is configured under "enforceOnKeyName". The key value is truncated to the first 128 bytes of the header value. If no such header is present in the request, the key type defaults to ALL. - XFF_IP: The first IP address (i.e. the originating client IP address) specified in the list of IPs under X-Forwarded-For HTTP header. If no such header is present or the value is not a valid IP, the key defaults to the source IP address of the request i.e. key type IP. - HTTP_COOKIE: The value of the HTTP cookie whose name is configured under "enforceOnKeyName". The key value is truncated to the first 128 bytes of the cookie value. If no such cookie is present in the request, the key type defaults to ALL. - HTTP_PATH: The URL path of the HTTP request. The key value is truncated to the first 128 bytes. - SNI: Server name indication in the TLS session of the HTTPS request. The key value is truncated to the first 128 bytes. The key type defaults to ALL on a HTTP session. - REGION_CODE: The country/region from which the request originates. */ export type SecurityPolicyRuleRateLimitOptionsEnforceOnKey = (typeof SecurityPolicyRuleRateLimitOptionsEnforceOnKey)[keyof typeof SecurityPolicyRuleRateLimitOptionsEnforceOnKey]; export declare const SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfigEnforceOnKeyType: { readonly All: "ALL"; readonly AllIps: "ALL_IPS"; readonly HttpCookie: "HTTP_COOKIE"; readonly HttpHeader: "HTTP_HEADER"; readonly HttpPath: "HTTP_PATH"; readonly Ip: "IP"; readonly RegionCode: "REGION_CODE"; readonly Sni: "SNI"; readonly XffIp: "XFF_IP"; }; /** * Determines the key to enforce the rate_limit_threshold on. Possible values are: - ALL: A single rate limit threshold is applied to all the requests matching this rule. This is the default value if "enforceOnKeyConfigs" is not configured. - IP: The source IP address of the request is the key. Each IP has this limit enforced separately. - HTTP_HEADER: The value of the HTTP header whose name is configured under "enforceOnKeyName". The key value is truncated to the first 128 bytes of the header value. If no such header is present in the request, the key type defaults to ALL. - XFF_IP: The first IP address (i.e. the originating client IP address) specified in the list of IPs under X-Forwarded-For HTTP header. If no such header is present or the value is not a valid IP, the key defaults to the source IP address of the request i.e. key type IP. - HTTP_COOKIE: The value of the HTTP cookie whose name is configured under "enforceOnKeyName". The key value is truncated to the first 128 bytes of the cookie value. If no such cookie is present in the request, the key type defaults to ALL. - HTTP_PATH: The URL path of the HTTP request. The key value is truncated to the first 128 bytes. - SNI: Server name indication in the TLS session of the HTTPS request. The key value is truncated to the first 128 bytes. The key type defaults to ALL on a HTTP session. - REGION_CODE: The country/region from which the request originates. */ export type SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfigEnforceOnKeyType = (typeof SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfigEnforceOnKeyType)[keyof typeof SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfigEnforceOnKeyType]; export declare const SecurityPolicyRuleRedirectOptionsType: { readonly External302: "EXTERNAL_302"; readonly GoogleRecaptcha: "GOOGLE_RECAPTCHA"; }; /** * Type of the redirect action. */ export type SecurityPolicyRuleRedirectOptionsType = (typeof SecurityPolicyRuleRedirectOptionsType)[keyof typeof SecurityPolicyRuleRedirectOptionsType]; export declare const SecurityPolicyType: { readonly CloudArmor: "CLOUD_ARMOR"; readonly CloudArmorEdge: "CLOUD_ARMOR_EDGE"; readonly CloudArmorNetwork: "CLOUD_ARMOR_NETWORK"; readonly Firewall: "FIREWALL"; }; /** * The type indicates the intended use of the security policy. - CLOUD_ARMOR: Cloud Armor backend security policies can be configured to filter incoming HTTP requests targeting backend services. They filter requests before they hit the origin servers. - CLOUD_ARMOR_EDGE: Cloud Armor edge security policies can be configured to filter incoming HTTP requests targeting backend services (including Cloud CDN-enabled) as well as backend buckets (Cloud Storage). They filter requests before the request is served from Google's cache. - CLOUD_ARMOR_INTERNAL_SERVICE: Cloud Armor internal service policies can be configured to filter HTTP requests targeting services managed by Traffic Director in a service mesh. They filter requests before the request is served from the application. - CLOUD_ARMOR_NETWORK: Cloud Armor network policies can be configured to filter packets targeting network load balancing resources such as backend services, target pools, target instances, and instances with external IPs. They filter requests before the request is served from the application. This field can be set only at resource creation time. */ export type SecurityPolicyType = (typeof SecurityPolicyType)[keyof typeof SecurityPolicyType]; export declare const SecurityPolicyUserDefinedFieldBase: { readonly Ipv4: "IPV4"; readonly Ipv6: "IPV6"; readonly Tcp: "TCP"; readonly Udp: "UDP"; }; /** * The base relative to which 'offset' is measured. Possible values are: - IPV4: Points to the beginning of the IPv4 header. - IPV6: Points to the beginning of the IPv6 header. - TCP: Points to the beginning of the TCP header, skipping over any IPv4 options or IPv6 extension headers. Not present for non-first fragments. - UDP: Points to the beginning of the UDP header, skipping over any IPv4 options or IPv6 extension headers. Not present for non-first fragments. required */ export type SecurityPolicyUserDefinedFieldBase = (typeof SecurityPolicyUserDefinedFieldBase)[keyof typeof SecurityPolicyUserDefinedFieldBase]; export declare const ServerBindingType: { /** * Node may associate with any physical server over its lifetime. */ readonly RestartNodeOnAnyServer: "RESTART_NODE_ON_ANY_SERVER"; /** * Node may associate with minimal physical servers over its lifetime. */ readonly RestartNodeOnMinimalServers: "RESTART_NODE_ON_MINIMAL_SERVERS"; readonly ServerBindingTypeUnspecified: "SERVER_BINDING_TYPE_UNSPECIFIED"; }; export type ServerBindingType = (typeof ServerBindingType)[keyof typeof ServerBindingType]; export declare const ServiceAttachmentConnectionPreference: { readonly AcceptAutomatic: "ACCEPT_AUTOMATIC"; readonly AcceptManual: "ACCEPT_MANUAL"; readonly ConnectionPreferenceUnspecified: "CONNECTION_PREFERENCE_UNSPECIFIED"; }; /** * The connection preference of service attachment. The value can be set to ACCEPT_AUTOMATIC. An ACCEPT_AUTOMATIC service attachment is one that always accepts the connection from consumer forwarding rules. */ export type ServiceAttachmentConnectionPreference = (typeof ServiceAttachmentConnectionPreference)[keyof typeof ServiceAttachmentConnectionPreference]; export declare const ServiceAttachmentTunnelingConfigEncapsulationProfile: { /** * Use GENEVE encapsulation protocol and include the SECURITY_V1 set of GENEVE headers. */ readonly GeneveSecurityV1: "GENEVE_SECURITY_V1"; readonly UnspecifiedEncapsulationProfile: "UNSPECIFIED_ENCAPSULATION_PROFILE"; }; /** * Specify the encapsulation protocol and what metadata to include in incoming encapsulated packet headers. */ export type ServiceAttachmentTunnelingConfigEncapsulationProfile = (typeof ServiceAttachmentTunnelingConfigEncapsulationProfile)[keyof typeof ServiceAttachmentTunnelingConfigEncapsulationProfile]; export declare const ServiceAttachmentTunnelingConfigRoutingMode: { /** * Traffic sent to this service attachment will be reinjected into the consumer network. */ readonly PacketInjection: "PACKET_INJECTION"; /** * Response traffic, after de-encapsulation, will be returned to the client. */ readonly StandardRouting: "STANDARD_ROUTING"; readonly UnspecifiedRoutingMode: "UNSPECIFIED_ROUTING_MODE"; }; /** * How this Service Attachment will treat traffic sent to the tunnel_ip, destined for the consumer network. */ export type ServiceAttachmentTunnelingConfigRoutingMode = (typeof ServiceAttachmentTunnelingConfigRoutingMode)[keyof typeof ServiceAttachmentTunnelingConfigRoutingMode]; export declare const ShareSettingsShareType: { /** * Default value. */ readonly Local: "LOCAL"; /** * Shared-reservation is open to entire Organization */ readonly Organization: "ORGANIZATION"; /** * Default value. This value is unused. */ readonly ShareTypeUnspecified: "SHARE_TYPE_UNSPECIFIED"; /** * Shared-reservation is open to specific projects */ readonly SpecificProjects: "SPECIFIC_PROJECTS"; }; /** * Type of sharing for this shared-reservation */ export type ShareSettingsShareType = (typeof ShareSettingsShareType)[keyof typeof ShareSettingsShareType]; export declare const SnapshotSnapshotType: { readonly Archive: "ARCHIVE"; readonly Standard: "STANDARD"; }; /** * Indicates the type of the snapshot. */ export type SnapshotSnapshotType = (typeof SnapshotSnapshotType)[keyof typeof SnapshotSnapshotType]; export declare const SslCertificateType: { /** * Google-managed SSLCertificate. */ readonly Managed: "MANAGED"; /** * Certificate uploaded by user. */ readonly SelfManaged: "SELF_MANAGED"; readonly TypeUnspecified: "TYPE_UNSPECIFIED"; }; /** * (Optional) Specifies the type of SSL certificate, either "SELF_MANAGED" or "MANAGED". If not specified, the certificate is self-managed and the fields certificate and private_key are used. */ export type SslCertificateType = (typeof SslCertificateType)[keyof typeof SslCertificateType]; export declare const SslPolicyMinTlsVersion: { /** * TLS 1.0 */ readonly Tls10: "TLS_1_0"; /** * TLS 1.1 */ readonly Tls11: "TLS_1_1"; /** * TLS 1.2 */ readonly Tls12: "TLS_1_2"; }; /** * The minimum version of SSL protocol that can be used by the clients to establish a connection with the load balancer. This can be one of TLS_1_0, TLS_1_1, TLS_1_2. */ export type SslPolicyMinTlsVersion = (typeof SslPolicyMinTlsVersion)[keyof typeof SslPolicyMinTlsVersion]; export declare const SslPolicyProfile: { /** * Compatible profile. Allows the broadset set of clients, even those which support only out-of-date SSL features to negotiate with the load balancer. */ readonly Compatible: "COMPATIBLE"; /** * Custom profile. Allow only the set of allowed SSL features specified in the customFeatures field. */ readonly Custom: "CUSTOM"; /** * Modern profile. Supports a wide set of SSL features, allowing modern clients to negotiate SSL with the load balancer. */ readonly Modern: "MODERN"; /** * Restricted profile. Supports a reduced set of SSL features, intended to meet stricter compliance requirements. */ readonly Restricted: "RESTRICTED"; }; /** * Profile specifies the set of SSL features that can be used by the load balancer when negotiating SSL with clients. This can be one of COMPATIBLE, MODERN, RESTRICTED, or CUSTOM. If using CUSTOM, the set of SSL features to enable must be specified in the customFeatures field. */ export type SslPolicyProfile = (typeof SslPolicyProfile)[keyof typeof SslPolicyProfile]; export declare const SubnetworkIpv6AccessType: { /** * VMs on this subnet will be assigned IPv6 addresses that are accessible via the Internet, as well as the VPC network. */ readonly External: "EXTERNAL"; /** * VMs on this subnet will be assigned IPv6 addresses that are only accessible over the VPC network. */ readonly Internal: "INTERNAL"; }; /** * The access type of IPv6 address this subnet holds. It's immutable and can only be specified during creation or the first time the subnet is updated into IPV4_IPV6 dual stack. */ export type SubnetworkIpv6AccessType = (typeof SubnetworkIpv6AccessType)[keyof typeof SubnetworkIpv6AccessType]; export declare const SubnetworkLogConfigAggregationInterval: { readonly Interval10Min: "INTERVAL_10_MIN"; readonly Interval15Min: "INTERVAL_15_MIN"; readonly Interval1Min: "INTERVAL_1_MIN"; readonly Interval30Sec: "INTERVAL_30_SEC"; readonly Interval5Min: "INTERVAL_5_MIN"; readonly Interval5Sec: "INTERVAL_5_SEC"; }; /** * 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. */ export type SubnetworkLogConfigAggregationInterval = (typeof SubnetworkLogConfigAggregationInterval)[keyof typeof SubnetworkLogConfigAggregationInterval]; export declare const SubnetworkLogConfigMetadata: { readonly CustomMetadata: "CUSTOM_METADATA"; readonly ExcludeAllMetadata: "EXCLUDE_ALL_METADATA"; readonly IncludeAllMetadata: "INCLUDE_ALL_METADATA"; }; /** * Can only be specified if VPC flow logs for this subnetwork is enabled. Configures whether all, none or a subset of metadata fields should be added to the reported VPC flow logs. Default is EXCLUDE_ALL_METADATA. */ export type SubnetworkLogConfigMetadata = (typeof SubnetworkLogConfigMetadata)[keyof typeof SubnetworkLogConfigMetadata]; export declare const SubnetworkPrivateIpv6GoogleAccess: { /** * Disable private IPv6 access to/from Google services. */ readonly DisableGoogleAccess: "DISABLE_GOOGLE_ACCESS"; /** * Bidirectional private IPv6 access to/from Google services. */ readonly EnableBidirectionalAccessToGoogle: "ENABLE_BIDIRECTIONAL_ACCESS_TO_GOOGLE"; /** * Outbound private IPv6 access from VMs in this subnet to Google services. */ readonly EnableOutboundVmAccessToGoogle: "ENABLE_OUTBOUND_VM_ACCESS_TO_GOOGLE"; }; /** * This field is for internal use. This field can be both set at resource creation time and updated using patch. */ export type SubnetworkPrivateIpv6GoogleAccess = (typeof SubnetworkPrivateIpv6GoogleAccess)[keyof typeof SubnetworkPrivateIpv6GoogleAccess]; export declare const SubnetworkPurpose: { /** * Subnet reserved for Global Envoy-based Load Balancing. */ readonly GlobalManagedProxy: "GLOBAL_MANAGED_PROXY"; /** * Subnet reserved for Internal HTTP(S) Load Balancing. */ readonly InternalHttpsLoadBalancer: "INTERNAL_HTTPS_LOAD_BALANCER"; /** * Regular user created or automatically created subnet. */ readonly Private: "PRIVATE"; /** * Subnetwork used as source range for Private NAT Gateways. */ readonly PrivateNat: "PRIVATE_NAT"; /** * Regular user created or automatically created subnet. */ readonly PrivateRfc1918: "PRIVATE_RFC_1918"; /** * Subnetworks created for Private Service Connect in the producer network. */ readonly PrivateServiceConnect: "PRIVATE_SERVICE_CONNECT"; /** * Subnetwork used for Regional Envoy-based Load Balancing. */ readonly RegionalManagedProxy: "REGIONAL_MANAGED_PROXY"; }; /** * The purpose of the resource. This field can be either PRIVATE, REGIONAL_MANAGED_PROXY, PRIVATE_SERVICE_CONNECT, or INTERNAL_HTTPS_LOAD_BALANCER. PRIVATE is the default purpose for user-created subnets or subnets that are automatically created in auto mode networks. A subnet with purpose set to REGIONAL_MANAGED_PROXY is a user-created subnetwork that is reserved for regional Envoy-based load balancers. A subnet with purpose set to PRIVATE_SERVICE_CONNECT is used to publish services using Private Service Connect. A subnet with purpose set to INTERNAL_HTTPS_LOAD_BALANCER is a proxy-only subnet that can be used only by regional internal HTTP(S) load balancers. Note that REGIONAL_MANAGED_PROXY is the preferred setting for all regional Envoy load balancers. If unspecified, the subnet purpose defaults to PRIVATE. The enableFlowLogs field isn't supported if the subnet purpose field is set to REGIONAL_MANAGED_PROXY. */ export type SubnetworkPurpose = (typeof SubnetworkPurpose)[keyof typeof SubnetworkPurpose]; export declare const SubnetworkRole: { /** * The ACTIVE subnet that is currently used. */ readonly Active: "ACTIVE"; /** * The BACKUP subnet that could be promoted to ACTIVE. */ readonly Backup: "BACKUP"; }; /** * The role of subnetwork. Currently, this field is only used when purpose = REGIONAL_MANAGED_PROXY. The value can be set to ACTIVE or BACKUP. An ACTIVE subnetwork is one that is currently being used for Envoy-based load balancers in a region. A BACKUP subnetwork is one that is ready to be promoted to ACTIVE or is currently draining. This field can be updated with a patch request. */ export type SubnetworkRole = (typeof SubnetworkRole)[keyof typeof SubnetworkRole]; export declare const SubnetworkStackType: { /** * New VMs in this subnet can have both IPv4 and IPv6 addresses. */ readonly Ipv4Ipv6: "IPV4_IPV6"; /** * New VMs in this subnet will only be assigned IPv4 addresses. */ readonly Ipv4Only: "IPV4_ONLY"; }; /** * The stack type for the subnet. If set to IPV4_ONLY, new VMs in the subnet are assigned IPv4 addresses only. If set to IPV4_IPV6, new VMs in the subnet can be assigned both IPv4 and IPv6 addresses. If not specified, IPV4_ONLY is used. This field can be both set at resource creation time and updated using patch. */ export type SubnetworkStackType = (typeof SubnetworkStackType)[keyof typeof SubnetworkStackType]; export declare const SubsettingPolicy: { /** * Subsetting based on consistent hashing. For Traffic Director, the number of backends per backend group (the subset size) is based on the `subset_size` parameter. For Internal HTTP(S) load balancing, the number of backends per backend group (the subset size) is dynamically adjusted in two cases: - As the number of proxy instances participating in Internal HTTP(S) load balancing increases, the subset size decreases. - When the total number of backends in a network exceeds the capacity of a single proxy instance, subset sizes are reduced automatically for each service that has backend subsetting enabled. */ readonly ConsistentHashSubsetting: "CONSISTENT_HASH_SUBSETTING"; /** * No Subsetting. Clients may open connections and send traffic to all backends of this backend service. This can lead to performance issues if there is substantial imbalance in the count of clients and backends. */ readonly None: "NONE"; }; export type SubsettingPolicy = (typeof SubsettingPolicy)[keyof typeof SubsettingPolicy]; export declare const TCPHealthCheckPortSpecification: { /** * The port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends. */ readonly UseFixedPort: "USE_FIXED_PORT"; /** * Not supported. */ readonly UseNamedPort: "USE_NAMED_PORT"; /** * For network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports. */ readonly UseServingPort: "USE_SERVING_PORT"; }; /** * Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports. */ export type TCPHealthCheckPortSpecification = (typeof TCPHealthCheckPortSpecification)[keyof typeof TCPHealthCheckPortSpecification]; export declare const TCPHealthCheckProxyHeader: { readonly None: "NONE"; readonly ProxyV1: "PROXY_V1"; }; /** * Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE. */ export type TCPHealthCheckProxyHeader = (typeof TCPHealthCheckProxyHeader)[keyof typeof TCPHealthCheckProxyHeader]; export declare const TargetHttpsProxyQuicOverride: { /** * The load balancer will not attempt to negotiate QUIC with clients. */ readonly Disable: "DISABLE"; /** * The load balancer will attempt to negotiate QUIC with clients. */ readonly Enable: "ENABLE"; /** * No overrides to the default QUIC policy. This option is implicit if no QUIC override has been specified in the request. */ readonly None: "NONE"; }; /** * Specifies the QUIC override policy for this TargetHttpsProxy resource. This setting determines whether the load balancer attempts to negotiate QUIC with clients. You can specify NONE, ENABLE, or DISABLE. - When quic-override is set to NONE, Google manages whether QUIC is used. - When quic-override is set to ENABLE, the load balancer uses QUIC when possible. - When quic-override is set to DISABLE, the load balancer doesn't use QUIC. - If the quic-override flag is not specified, NONE is implied. */ export type TargetHttpsProxyQuicOverride = (typeof TargetHttpsProxyQuicOverride)[keyof typeof TargetHttpsProxyQuicOverride]; export declare const TargetInstanceNatPolicy: { /** * No NAT performed. */ readonly NoNat: "NO_NAT"; }; /** * Must have a value of NO_NAT. Protocol forwarding delivers packets while preserving the destination IP address of the forwarding rule referencing the target instance. */ export type TargetInstanceNatPolicy = (typeof TargetInstanceNatPolicy)[keyof typeof TargetInstanceNatPolicy]; export declare const TargetPoolSessionAffinity: { /** * 2-tuple hash on packet's source and destination IP addresses. Connections from the same source IP address to the same destination IP address will be served by the same backend VM while that VM remains healthy. */ readonly ClientIp: "CLIENT_IP"; /** * 1-tuple hash only on packet's source IP address. Connections from the same source IP address will be served by the same backend VM while that VM remains healthy. This option can only be used for Internal TCP/UDP Load Balancing. */ readonly ClientIpNoDestination: "CLIENT_IP_NO_DESTINATION"; /** * 5-tuple hash on packet's source and destination IP addresses, IP protocol, and source and destination ports. Connections for the same IP protocol from the same source IP address and port to the same destination IP address and port will be served by the same backend VM while that VM remains healthy. This option cannot be used for HTTP(S) load balancing. */ readonly ClientIpPortProto: "CLIENT_IP_PORT_PROTO"; /** * 3-tuple hash on packet's source and destination IP addresses, and IP protocol. Connections for the same IP protocol from the same source IP address to the same destination IP address will be served by the same backend VM while that VM remains healthy. This option cannot be used for HTTP(S) load balancing. */ readonly ClientIpProto: "CLIENT_IP_PROTO"; /** * Hash based on a cookie generated by the L7 loadbalancer. Only valid for HTTP(S) load balancing. */ readonly GeneratedCookie: "GENERATED_COOKIE"; /** * The hash is based on a user specified header field. */ readonly HeaderField: "HEADER_FIELD"; /** * The hash is based on a user provided cookie. */ readonly HttpCookie: "HTTP_COOKIE"; /** * No session affinity. Connections from the same client IP may go to any instance in the pool. */ readonly None: "NONE"; }; /** * Session affinity option, must be one of the following values: NONE: Connections from the same client IP may go to any instance in the pool. CLIENT_IP: Connections from the same client IP will go to the same instance in the pool while that instance remains healthy. CLIENT_IP_PROTO: Connections from the same client IP with the same IP protocol will go to the same instance in the pool while that instance remains healthy. */ export type TargetPoolSessionAffinity = (typeof TargetPoolSessionAffinity)[keyof typeof TargetPoolSessionAffinity]; export declare const TargetSslProxyProxyHeader: { readonly None: "NONE"; readonly ProxyV1: "PROXY_V1"; }; /** * Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE. */ export type TargetSslProxyProxyHeader = (typeof TargetSslProxyProxyHeader)[keyof typeof TargetSslProxyProxyHeader]; export declare const TargetTcpProxyProxyHeader: { readonly None: "NONE"; readonly ProxyV1: "PROXY_V1"; }; /** * Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE. */ export type TargetTcpProxyProxyHeader = (typeof TargetTcpProxyProxyHeader)[keyof typeof TargetTcpProxyProxyHeader]; export declare const VpnGatewayGatewayIpVersion: { /** * Every HA-VPN gateway interface is configured with an IPv4 address. */ readonly Ipv4: "IPV4"; /** * Every HA-VPN gateway interface is configured with an IPv6 address. */ readonly Ipv6: "IPV6"; }; /** * The IP family of the gateway IPs for the HA-VPN gateway interfaces. If not specified, IPV4 will be used. */ export type VpnGatewayGatewayIpVersion = (typeof VpnGatewayGatewayIpVersion)[keyof typeof VpnGatewayGatewayIpVersion]; export declare const VpnGatewayStackType: { /** * Enable VPN gateway with both IPv4 and IPv6 protocols. */ readonly Ipv4Ipv6: "IPV4_IPV6"; /** * Enable VPN gateway with only IPv4 protocol. */ readonly Ipv4Only: "IPV4_ONLY"; }; /** * The stack type for this VPN gateway to identify the IP protocols that are enabled. Possible values are: IPV4_ONLY, IPV4_IPV6. If not specified, IPV4_ONLY will be used. */ export type VpnGatewayStackType = (typeof VpnGatewayStackType)[keyof typeof VpnGatewayStackType];