gcp-lite-rs 0.1.1

# Compute Engine API — Full Reference Manifest
# Auto-generated by reference.py — DO NOT HAND-EDIT
# This file contains EVERY schema and operation from the discovery doc.
# Use it as a reference when extending codegen/manifests/compute.toml
#
# Schemas: 907 total, 24 in manifest
# Operations: 901 total, 31 in manifest
#
# Legend:
#   [IN MANIFEST] = already in the curated manifest
#   format: byte  = needs format = "bytes" override
#   RESERVED_WORD = needs rust_name + serde_rename override

# ======================================================================
# SCHEMAS (907 total)
# ======================================================================

# --- AWSV4Signature (4 fields) ---
# Contains the configurations necessary to generate a signature for access to private storage buckets 
# [[types]]
# schema = "AWSV4Signature"
# include_fields = ["accessKey", "accessKeyId", "accessKeyVersion", "originRegion"]
#
#   accessKey: string
#   accessKeyId: string
#   accessKeyVersion: string
#   originRegion: string

# --- AcceleratorConfig (2 fields) ---
# A specification of the type and number of accelerator cards attached to the instance.
# [[types]]
# schema = "AcceleratorConfig"
# include_fields = ["acceleratorCount", "acceleratorType"]
#
#   acceleratorCount: integer, format: int32
#   acceleratorType: string

# --- AcceleratorTopologiesInfo (1 fields) ---
# Info for accelerator topologies within a densely packed reservation.
# [[types]]
# schema = "AcceleratorTopologiesInfo"
# include_fields = ["acceleratorTopologyInfos"]
#
#   acceleratorTopologyInfos: array<AcceleratorTopologiesInfoAcceleratorTopologyInfo>

# --- AcceleratorTopologiesInfoAcceleratorTopologyInfo (2 fields) ---
# Info for a slice of a given topology.
# [[types]]
# schema = "AcceleratorTopologiesInfoAcceleratorTopologyInfo"
# include_fields = ["acceleratorTopology", "infoPerTopologyStates"]
#
#   acceleratorTopology: string
#   infoPerTopologyStates: array<AcceleratorTopologiesInfoAcceleratorTopologyInfoInfoPerTopologyState>

# --- AcceleratorTopologiesInfoAcceleratorTopologyInfoInfoPerTopologyState (2 fields) ---
# Info for each topology state.
# [[types]]
# schema = "AcceleratorTopologiesInfoAcceleratorTopologyInfoInfoPerTopologyState"
# include_fields = ["count", "state"]
#
#   count: integer, format: int32
#   state: string, enum: [AVAILABLE, DEGRADED, RUNNING, TOPOLOGY_STATE_UNSPECIFIED, UNHEALTHY]
#
# [types.field_overrides]
# # state = { enum_type = "AcceleratorTopologiesInfoAcceleratorTopologyInfoInfoPerTopologyStateState" }

# --- AcceleratorType (9 fields) ---
# Represents an Accelerator Type resource. Google Cloud Platform provides graphics processing units (a
# [[types]]
# schema = "AcceleratorType"
# include_fields = ["creationTimestamp", "deprecated", "description", "id", "kind", "maximumCardsPerInstance", "name", "selfLink", "zone"]
#
#   creationTimestamp: string
#   deprecated: $ref: DeprecationStatus
#   description: string
#   id: string, format: uint64
#   kind: string, readOnly
#   maximumCardsPerInstance: integer, format: int32
#   name: string
#   selfLink: string, readOnly
#   zone: string
#
# [types.field_overrides]
# name = { required = true }

# --- AcceleratorTypeAggregatedList (7 fields) ---
# [[types]]
# schema = "AcceleratorTypeAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, AcceleratorTypesScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- AcceleratorTypeList (6 fields) ---
# Contains a list of accelerator types.
# [[types]]
# schema = "AcceleratorTypeList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<AcceleratorType>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- AcceleratorTypesScopedList (2 fields) ---
# [[types]]
# schema = "AcceleratorTypesScopedList"
# include_fields = ["acceleratorTypes", "warning"]
#
#   acceleratorTypes: array<AcceleratorType>
#   warning: object

# --- AccessConfig (10 fields) [IN MANIFEST] ---
# An access configuration attached to an instance's network interface. Only one access config per inst
# WARNING: reserved words: type
# [[types]]
# schema = "AccessConfig"
# include_fields = ["externalIpv6", "externalIpv6PrefixLength", "kind", "name", "natIP", "networkTier", "publicPtrDomainName", "securityPolicy", "setPublicPtr", "type"]
#
#   externalIpv6: string
#   externalIpv6PrefixLength: integer, format: int32
#   kind: string, readOnly
#   name: string
#   natIP: string
#   networkTier: string, enum: [FIXED_STANDARD, PREMIUM, STANDARD, STANDARD_OVERRIDES_FIXED_STANDARD]
#   publicPtrDomainName: string
#   securityPolicy: string
#   setPublicPtr: boolean
#   type: string, enum: [DIRECT_IPV6, ONE_TO_ONE_NAT], RESERVED_WORD
#
# [types.field_overrides]
# name = { required = true }
# type = { rust_name = "type_value", serde_rename = "type" }
# # type = { enum_type = "AccessConfigType" }
# # networkTier = { enum_type = "AccessConfigNetworkTier" }

# --- Address (21 fields) [IN MANIFEST] ---
# Represents an IP Address resource. Google Compute Engine has two IP Address resources: * [Global (ex
# WARNING: format:"byte" fields: labelFingerprint
# [[types]]
# schema = "Address"
# include_fields = ["address", "addressType", "creationTimestamp", "description", "id", "ipCollection", "ipVersion", "ipv6EndpointType", "kind", "labelFingerprint", "labels", "name", "network", "networkTier", "prefixLength", "purpose", "region", "selfLink", "status", "subnetwork", "users"]
#
#   address: string
#   addressType: string, enum: [EXTERNAL, INTERNAL, UNSPECIFIED_TYPE]
#   creationTimestamp: string, readOnly
#   description: string
#   id: string, format: uint64, readOnly
#   ipCollection: string
#   ipVersion: string, enum: [IPV4, IPV6, UNSPECIFIED_VERSION]
#   ipv6EndpointType: string, enum: [NETLB, VM]
#   kind: string, readOnly
#   labelFingerprint: string, format: byte
#   labels: map<string, string>
#   name: string
#   network: string
#   networkTier: string, enum: [FIXED_STANDARD, PREMIUM, STANDARD, STANDARD_OVERRIDES_FIXED_STANDARD]
#   prefixLength: integer, format: int32
#   purpose: string, enum: [DNS_RESOLVER, GCE_ENDPOINT, IPSEC_INTERCONNECT, NAT_AUTO, ... +4]
#   region: string, readOnly
#   selfLink: string
#   status: string, enum: [IN_USE, RESERVED, RESERVING], readOnly
#   subnetwork: string
#   users: array<string>
#
# [types.field_overrides]
# name = { required = true }
# labelFingerprint = { format = "bytes" }
# # status = { enum_type = "AddressStatus" }
# # purpose = { enum_type = "AddressPurpose" }
# # ipVersion = { enum_type = "AddressIpVersion" }
# # addressType = { enum_type = "AddressAddressType" }
# # ipv6EndpointType = { enum_type = "AddressIpv6EndpointType" }
# # networkTier = { enum_type = "AddressNetworkTier" }

# --- AddressAggregatedList (7 fields) ---
# [[types]]
# schema = "AddressAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, AddressesScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- AddressList (6 fields) ---
# Contains a list of addresses.
# [[types]]
# schema = "AddressList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<Address>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- AddressesScopedList (2 fields) ---
# [[types]]
# schema = "AddressesScopedList"
# include_fields = ["addresses", "warning"]
#
#   addresses: array<Address>
#   warning: object

# --- AdvancedMachineFeatures (6 fields) ---
# Specifies options for controlling advanced machine features. Options that would traditionally be con
# [[types]]
# schema = "AdvancedMachineFeatures"
# include_fields = ["enableNestedVirtualization", "enableUefiNetworking", "performanceMonitoringUnit", "threadsPerCore", "turboMode", "visibleCoreCount"]
#
#   enableNestedVirtualization: boolean
#   enableUefiNetworking: boolean
#   performanceMonitoringUnit: string, enum: [ARCHITECTURAL, ENHANCED, PERFORMANCE_MONITORING_UNIT_UNSPECIFIED, STANDARD]
#   threadsPerCore: integer, format: int32
#   turboMode: string
#   visibleCoreCount: integer, format: int32
#
# [types.field_overrides]
# # performanceMonitoringUnit = { enum_type = "AdvancedMachineFeaturesPerformanceMonitoringUnit" }

# --- AliasIpRange (2 fields) ---
# An alias IP range attached to an instance's network interface.
# [[types]]
# schema = "AliasIpRange"
# include_fields = ["ipCidrRange", "subnetworkRangeName"]
#
#   ipCidrRange: string
#   subnetworkRangeName: string

# --- AllocationAggregateReservation (4 fields) ---
# This reservation type is specified by total resource amounts (e.g. total count of CPUs) and can acco
# [[types]]
# schema = "AllocationAggregateReservation"
# include_fields = ["inUseResources", "reservedResources", "vmFamily", "workloadType"]
#
#   inUseResources: array<AllocationAggregateReservationReservedResourceInfo>, readOnly
#   reservedResources: array<AllocationAggregateReservationReservedResourceInfo>
#   vmFamily: string, enum: [VM_FAMILY_CLOUD_TPU_DEVICE_CT3, VM_FAMILY_CLOUD_TPU_LITE_DEVICE_CT5L, VM_FAMILY_CLOUD_TPU_LITE_POD_SLICE_CT5LP, VM_FAMILY_CLOUD_TPU_LITE_POD_SLICE_CT6E, ... +4]
#   workloadType: string, enum: [BATCH, SERVING, UNSPECIFIED]
#
# [types.field_overrides]
# # vmFamily = { enum_type = "AllocationAggregateReservationVmFamily" }
# # workloadType = { enum_type = "AllocationAggregateReservationWorkloadType" }

# --- AllocationAggregateReservationReservedResourceInfo (1 fields) ---
# [[types]]
# schema = "AllocationAggregateReservationReservedResourceInfo"
# include_fields = ["accelerator"]
#
#   accelerator: $ref: AllocationAggregateReservationReservedResourceInfoAccelerator

# --- AllocationAggregateReservationReservedResourceInfoAccelerator (2 fields) ---
# [[types]]
# schema = "AllocationAggregateReservationReservedResourceInfoAccelerator"
# include_fields = ["acceleratorCount", "acceleratorType"]
#
#   acceleratorCount: integer, format: int32
#   acceleratorType: string

# --- AllocationReservationSharingPolicy (1 fields) ---
# [[types]]
# schema = "AllocationReservationSharingPolicy"
# include_fields = ["serviceShareType"]
#
#   serviceShareType: string, enum: [ALLOW_ALL, DISALLOW_ALL, SERVICE_SHARE_TYPE_UNSPECIFIED]
#
# [types.field_overrides]
# # serviceShareType = { enum_type = "AllocationReservationSharingPolicyServiceShareType" }

# --- AllocationResourceStatus (4 fields) ---
# [Output Only] Contains output only fields.
# [[types]]
# schema = "AllocationResourceStatus"
# include_fields = ["healthInfo", "reservationBlockCount", "reservationMaintenance", "specificSkuAllocation"]
#
#   healthInfo: $ref: AllocationResourceStatusHealthInfo
#   reservationBlockCount: integer, format: int32
#   reservationMaintenance: $ref: GroupMaintenanceInfo
#   specificSkuAllocation: $ref: AllocationResourceStatusSpecificSKUAllocation

# --- AllocationResourceStatusHealthInfo (3 fields) ---
# Health information for the reservation.
# [[types]]
# schema = "AllocationResourceStatusHealthInfo"
# include_fields = ["degradedBlockCount", "healthStatus", "healthyBlockCount"]
#
#   degradedBlockCount: integer, format: int32
#   healthStatus: string, enum: [DEGRADED, HEALTHY, HEALTH_STATUS_UNSPECIFIED]
#   healthyBlockCount: integer, format: int32
#
# [types.field_overrides]
# # healthStatus = { enum_type = "AllocationResourceStatusHealthInfoHealthStatus" }

# --- AllocationResourceStatusSpecificSKUAllocation (2 fields) ---
# Contains Properties set for the reservation.
# [[types]]
# schema = "AllocationResourceStatusSpecificSKUAllocation"
# include_fields = ["sourceInstanceTemplateId", "utilizations"]
#
#   sourceInstanceTemplateId: string
#   utilizations: map<string, string>

# --- AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk (2 fields) ---
# [[types]]
# schema = "AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk"
# include_fields = ["diskSizeGb", "interface"]
#
#   diskSizeGb: string, format: int64
#   interface: string, enum: [NVME, SCSI]
#
# [types.field_overrides]
# # interface = { enum_type = "AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDiskInterface" }

# --- AllocationSpecificSKUAllocationReservedInstanceProperties (5 fields) ---
# Properties of the SKU instances being reserved. Next ID: 9
# [[types]]
# schema = "AllocationSpecificSKUAllocationReservedInstanceProperties"
# include_fields = ["guestAccelerators", "localSsds", "locationHint", "machineType", "minCpuPlatform"]
#
#   guestAccelerators: array<AcceleratorConfig>
#   localSsds: array<AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk>
#   locationHint: string
#   machineType: string
#   minCpuPlatform: string

# --- AllocationSpecificSKUReservation (5 fields) ---
# This reservation type allows to pre allocate specific instance configuration.
# [[types]]
# schema = "AllocationSpecificSKUReservation"
# include_fields = ["assuredCount", "count", "inUseCount", "instanceProperties", "sourceInstanceTemplate"]
#
#   assuredCount: string, format: int64, readOnly
#   count: string, format: int64
#   inUseCount: string, format: int64, readOnly
#   instanceProperties: $ref: AllocationSpecificSKUAllocationReservedInstanceProperties
#   sourceInstanceTemplate: string

# --- AttachedDisk (18 fields) [IN MANIFEST] ---
# An instance-attached disk resource.
# WARNING: reserved words: type
# [[types]]
# schema = "AttachedDisk"
# include_fields = ["architecture", "autoDelete", "boot", "deviceName", "diskEncryptionKey", "diskSizeGb", "forceAttach", "guestOsFeatures", "index", "initializeParams", "interface", "kind", "licenses", "mode", "savedState", "shieldedInstanceInitialState", "source", "type"]
#
#   architecture: string, enum: [ARCHITECTURE_UNSPECIFIED, ARM64, X86_64], readOnly
#   autoDelete: boolean
#   boot: boolean
#   deviceName: string
#   diskEncryptionKey: $ref: CustomerEncryptionKey
#   diskSizeGb: string, format: int64
#   forceAttach: boolean
#   guestOsFeatures: array<GuestOsFeature>
#   index: integer, format: int32, readOnly
#   initializeParams: $ref: AttachedDiskInitializeParams
#   interface: string, enum: [NVME, SCSI]
#   kind: string, readOnly
#   licenses: array<string>, readOnly
#   mode: string, enum: [READ_ONLY, READ_WRITE]
#   savedState: string, enum: [DISK_SAVED_STATE_UNSPECIFIED, PRESERVED], readOnly
#   shieldedInstanceInitialState: $ref: InitialStateConfig, readOnly
#   source: string
#   type: string, enum: [PERSISTENT, SCRATCH], RESERVED_WORD
#
# [types.field_overrides]
# type = { rust_name = "type_value", serde_rename = "type" }
# # architecture = { enum_type = "AttachedDiskArchitecture" }
# # type = { enum_type = "AttachedDiskType" }
# # interface = { enum_type = "AttachedDiskInterface" }
# # savedState = { enum_type = "AttachedDiskSavedState" }
# # mode = { enum_type = "AttachedDiskMode" }

# --- AttachedDiskInitializeParams (19 fields) ---
# [Input Only] Specifies the parameters for a new disk that will be created alongside the new instance
# [[types]]
# schema = "AttachedDiskInitializeParams"
# include_fields = ["architecture", "description", "diskName", "diskSizeGb", "diskType", "enableConfidentialCompute", "labels", "licenses", "onUpdateAction", "provisionedIops", "provisionedThroughput", "replicaZones", "resourceManagerTags", "resourcePolicies", "sourceImage", "sourceImageEncryptionKey", "sourceSnapshot", "sourceSnapshotEncryptionKey", "storagePool"]
#
#   architecture: string, enum: [ARCHITECTURE_UNSPECIFIED, ARM64, X86_64]
#   description: string
#   diskName: string
#   diskSizeGb: string, format: int64
#   diskType: string
#   enableConfidentialCompute: boolean
#   labels: map<string, string>
#   licenses: array<string>
#   onUpdateAction: string, enum: [RECREATE_DISK, RECREATE_DISK_IF_SOURCE_CHANGED, USE_EXISTING_DISK]
#   provisionedIops: string, format: int64
#   provisionedThroughput: string, format: int64
#   replicaZones: array<string>
#   resourceManagerTags: map<string, string>
#   resourcePolicies: array<string>
#   sourceImage: string
#   sourceImageEncryptionKey: $ref: CustomerEncryptionKey
#   sourceSnapshot: string
#   sourceSnapshotEncryptionKey: $ref: CustomerEncryptionKey
#   storagePool: string
#
# [types.field_overrides]
# # onUpdateAction = { enum_type = "AttachedDiskInitializeParamsOnUpdateAction" }
# # architecture = { enum_type = "AttachedDiskInitializeParamsArchitecture" }

# --- AuditConfig (2 fields) ---
# Specifies the audit configuration for a service. The configuration determines which permission types
# [[types]]
# schema = "AuditConfig"
# include_fields = ["auditLogConfigs", "service"]
#
#   auditLogConfigs: array<AuditLogConfig>
#   service: string

# --- AuditLogConfig (2 fields) ---
# Provides the configuration for logging a type of permissions. Example: { "audit_log_configs": [ { "l
# [[types]]
# schema = "AuditLogConfig"
# include_fields = ["exemptedMembers", "logType"]
#
#   exemptedMembers: array<string>
#   logType: string, enum: [ADMIN_READ, DATA_READ, DATA_WRITE, LOG_TYPE_UNSPECIFIED]
#
# [types.field_overrides]
# # logType = { enum_type = "AuditLogConfigLogType" }

# --- Autoscaler (14 fields) ---
# Represents an Autoscaler resource. Google Compute Engine has two Autoscaler resources: * [Zonal](/co
# [[types]]
# schema = "Autoscaler"
# include_fields = ["autoscalingPolicy", "creationTimestamp", "description", "id", "kind", "name", "recommendedSize", "region", "scalingScheduleStatus", "selfLink", "status", "statusDetails", "target", "zone"]
#
#   autoscalingPolicy: $ref: AutoscalingPolicy
#   creationTimestamp: string, readOnly
#   description: string
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   name: string
#   recommendedSize: integer, format: int32, readOnly
#   region: string, readOnly
#   scalingScheduleStatus: map<string, ScalingScheduleStatus>, readOnly
#   selfLink: string
#   status: string, enum: [ACTIVE, DELETING, ERROR, PENDING]
#   statusDetails: array<AutoscalerStatusDetails>
#   target: string
#   zone: string, readOnly
#
# [types.field_overrides]
# name = { required = true }
# # status = { enum_type = "AutoscalerStatus" }

# --- AutoscalerAggregatedList (7 fields) ---
# [[types]]
# schema = "AutoscalerAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, AutoscalersScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- AutoscalerList (6 fields) ---
# Contains a list of Autoscaler resources.
# [[types]]
# schema = "AutoscalerList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<Autoscaler>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- AutoscalerStatusDetails (2 fields) ---
# WARNING: reserved words: type
# [[types]]
# schema = "AutoscalerStatusDetails"
# include_fields = ["message", "type"]
#
#   message: string
#   type: string, enum: [ALL_INSTANCES_UNHEALTHY, BACKEND_SERVICE_DOES_NOT_EXIST, CAPPED_AT_MAX_NUM_REPLICAS, CUSTOM_METRIC_DATA_POINTS_TOO_SPARSE, ... +16], RESERVED_WORD
#
# [types.field_overrides]
# type = { rust_name = "type_value", serde_rename = "type" }
# # type = { enum_type = "AutoscalerStatusDetailsType" }

# --- AutoscalersScopedList (2 fields) ---
# [[types]]
# schema = "AutoscalersScopedList"
# include_fields = ["autoscalers", "warning"]
#
#   autoscalers: array<Autoscaler>
#   warning: object

# --- AutoscalingPolicy (9 fields) ---
# Cloud Autoscaler policy.
# [[types]]
# schema = "AutoscalingPolicy"
# include_fields = ["coolDownPeriodSec", "cpuUtilization", "customMetricUtilizations", "loadBalancingUtilization", "maxNumReplicas", "minNumReplicas", "mode", "scaleInControl", "scalingSchedules"]
#
#   coolDownPeriodSec: integer, format: int32
#   cpuUtilization: $ref: AutoscalingPolicyCpuUtilization
#   customMetricUtilizations: array<AutoscalingPolicyCustomMetricUtilization>
#   loadBalancingUtilization: $ref: AutoscalingPolicyLoadBalancingUtilization
#   maxNumReplicas: integer, format: int32
#   minNumReplicas: integer, format: int32
#   mode: string, enum: [OFF, ON, ONLY_SCALE_OUT, ONLY_UP]
#   scaleInControl: $ref: AutoscalingPolicyScaleInControl
#   scalingSchedules: map<string, AutoscalingPolicyScalingSchedule>
#
# [types.field_overrides]
# # mode = { enum_type = "AutoscalingPolicyMode" }

# --- AutoscalingPolicyCpuUtilization (2 fields) ---
# CPU utilization policy.
# [[types]]
# schema = "AutoscalingPolicyCpuUtilization"
# include_fields = ["predictiveMethod", "utilizationTarget"]
#
#   predictiveMethod: string, enum: [NONE, OPTIMIZE_AVAILABILITY]
#   utilizationTarget: number, format: double
#
# [types.field_overrides]
# # predictiveMethod = { enum_type = "AutoscalingPolicyCpuUtilizationPredictiveMethod" }

# --- AutoscalingPolicyCustomMetricUtilization (5 fields) ---
# Custom utilization metric policy.
# [[types]]
# schema = "AutoscalingPolicyCustomMetricUtilization"
# include_fields = ["filter", "metric", "singleInstanceAssignment", "utilizationTarget", "utilizationTargetType"]
#
#   filter: string
#   metric: string
#   singleInstanceAssignment: number, format: double
#   utilizationTarget: number, format: double
#   utilizationTargetType: string, enum: [DELTA_PER_MINUTE, DELTA_PER_SECOND, GAUGE]
#
# [types.field_overrides]
# # utilizationTargetType = { enum_type = "AutoscalingPolicyCustomMetricUtilizationUtilizationTargetType" }

# --- AutoscalingPolicyLoadBalancingUtilization (1 fields) ---
# Configuration parameters of autoscaling based on load balancing.
# [[types]]
# schema = "AutoscalingPolicyLoadBalancingUtilization"
# include_fields = ["utilizationTarget"]
#
#   utilizationTarget: number, format: double

# --- AutoscalingPolicyScaleInControl (2 fields) ---
# Configuration that allows for slower scale in so that even if Autoscaler recommends an abrupt scale 
# [[types]]
# schema = "AutoscalingPolicyScaleInControl"
# include_fields = ["maxScaledInReplicas", "timeWindowSec"]
#
#   maxScaledInReplicas: $ref: FixedOrPercent
#   timeWindowSec: integer, format: int32

# --- AutoscalingPolicyScalingSchedule (6 fields) ---
# Scaling based on user-defined schedule. The message describes a single scaling schedule. A scaling s
# [[types]]
# schema = "AutoscalingPolicyScalingSchedule"
# include_fields = ["description", "disabled", "durationSec", "minRequiredReplicas", "schedule", "timeZone"]
#
#   description: string
#   disabled: boolean
#   durationSec: integer, format: int32
#   minRequiredReplicas: integer, format: int32
#   schedule: string
#   timeZone: string

# --- Backend (14 fields) [IN MANIFEST] ---
# Message containing information of one individual backend.
# [[types]]
# schema = "Backend"
# include_fields = ["balancingMode", "capacityScaler", "customMetrics", "description", "failover", "group", "maxConnections", "maxConnectionsPerEndpoint", "maxConnectionsPerInstance", "maxRate", "maxRatePerEndpoint", "maxRatePerInstance", "maxUtilization", "preference"]
#
#   balancingMode: string, enum: [CONNECTION, CUSTOM_METRICS, RATE, UTILIZATION]
#   capacityScaler: number, format: float
#   customMetrics: array<BackendCustomMetric>
#   description: string
#   failover: boolean
#   group: string
#   maxConnections: integer, format: int32
#   maxConnectionsPerEndpoint: integer, format: int32
#   maxConnectionsPerInstance: integer, format: int32
#   maxRate: integer, format: int32
#   maxRatePerEndpoint: number, format: float
#   maxRatePerInstance: number, format: float
#   maxUtilization: number, format: float
#   preference: string, enum: [DEFAULT, PREFERENCE_UNSPECIFIED, PREFERRED]
#
# [types.field_overrides]
# # preference = { enum_type = "BackendPreference" }
# # balancingMode = { enum_type = "BackendBalancingMode" }

# --- BackendBucket (15 fields) ---
# Represents a Cloud Storage Bucket resource. This Cloud Storage bucket resource is referenced by a UR
# [[types]]
# schema = "BackendBucket"
# include_fields = ["bucketName", "cdnPolicy", "compressionMode", "creationTimestamp", "customResponseHeaders", "description", "edgeSecurityPolicy", "enableCdn", "id", "kind", "loadBalancingScheme", "name", "params", "selfLink", "usedBy"]
#
#   bucketName: string
#   cdnPolicy: $ref: BackendBucketCdnPolicy
#   compressionMode: string, enum: [AUTOMATIC, DISABLED]
#   creationTimestamp: string
#   customResponseHeaders: array<string>
#   description: string
#   edgeSecurityPolicy: string
#   enableCdn: boolean
#   id: string, format: uint64
#   kind: string, readOnly
#   loadBalancingScheme: string, enum: [INTERNAL_MANAGED]
#   name: string
#   params: $ref: BackendBucketParams
#   selfLink: string
#   usedBy: array<BackendBucketUsedBy>, readOnly
#
# [types.field_overrides]
# name = { required = true }
# # loadBalancingScheme = { enum_type = "BackendBucketLoadBalancingScheme" }
# # compressionMode = { enum_type = "BackendBucketCompressionMode" }

# --- BackendBucketCdnPolicy (12 fields) ---
# Message containing Cloud CDN configuration for a backend bucket.
# [[types]]
# schema = "BackendBucketCdnPolicy"
# include_fields = ["bypassCacheOnRequestHeaders", "cacheKeyPolicy", "cacheMode", "clientTtl", "defaultTtl", "maxTtl", "negativeCaching", "negativeCachingPolicy", "requestCoalescing", "serveWhileStale", "signedUrlCacheMaxAgeSec", "signedUrlKeyNames"]
#
#   bypassCacheOnRequestHeaders: array<BackendBucketCdnPolicyBypassCacheOnRequestHeader>
#   cacheKeyPolicy: $ref: BackendBucketCdnPolicyCacheKeyPolicy
#   cacheMode: string, enum: [CACHE_ALL_STATIC, FORCE_CACHE_ALL, INVALID_CACHE_MODE, USE_ORIGIN_HEADERS]
#   clientTtl: integer, format: int32
#   defaultTtl: integer, format: int32
#   maxTtl: integer, format: int32
#   negativeCaching: boolean
#   negativeCachingPolicy: array<BackendBucketCdnPolicyNegativeCachingPolicy>
#   requestCoalescing: boolean
#   serveWhileStale: integer, format: int32
#   signedUrlCacheMaxAgeSec: string, format: int64
#   signedUrlKeyNames: array<string>
#
# [types.field_overrides]
# # cacheMode = { enum_type = "BackendBucketCdnPolicyCacheMode" }

# --- BackendBucketCdnPolicyBypassCacheOnRequestHeader (1 fields) ---
# Bypass the cache when the specified request headers are present, e.g. Pragma or Authorization header
# [[types]]
# schema = "BackendBucketCdnPolicyBypassCacheOnRequestHeader"
# include_fields = ["headerName"]
#
#   headerName: string

# --- BackendBucketCdnPolicyCacheKeyPolicy (2 fields) ---
# Message containing what to include in the cache key for a request for Cloud CDN.
# [[types]]
# schema = "BackendBucketCdnPolicyCacheKeyPolicy"
# include_fields = ["includeHttpHeaders", "queryStringWhitelist"]
#
#   includeHttpHeaders: array<string>
#   queryStringWhitelist: array<string>

# --- BackendBucketCdnPolicyNegativeCachingPolicy (2 fields) ---
# Specify CDN TTLs for response error codes.
# [[types]]
# schema = "BackendBucketCdnPolicyNegativeCachingPolicy"
# include_fields = ["code", "ttl"]
#
#   code: integer, format: int32
#   ttl: integer, format: int32

# --- BackendBucketList (6 fields) ---
# Contains a list of BackendBucket resources.
# [[types]]
# schema = "BackendBucketList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<BackendBucket>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- BackendBucketParams (1 fields) ---
# Additional Backend Bucket parameters.
# [[types]]
# schema = "BackendBucketParams"
# include_fields = ["resourceManagerTags"]
#
#   resourceManagerTags: map<string, string>

# --- BackendBucketUsedBy (1 fields) ---
# [[types]]
# schema = "BackendBucketUsedBy"
# include_fields = ["reference"]
#
#   reference: string, readOnly

# --- BackendCustomMetric (3 fields) ---
# Custom Metrics are used for CUSTOM_METRICS balancing_mode.
# [[types]]
# schema = "BackendCustomMetric"
# include_fields = ["dryRun", "maxUtilization", "name"]
#
#   dryRun: boolean
#   maxUtilization: number, format: float
#   name: string
#
# [types.field_overrides]
# name = { required = true }

# --- BackendService (51 fields) [IN MANIFEST] ---
# Represents a Backend Service resource. A backend service defines how Google Cloud load balancers dis
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "BackendService"
# include_fields = ["affinityCookieTtlSec", "backends", "cdnPolicy", "circuitBreakers", "compressionMode", "connectionDraining", "connectionTrackingPolicy", "consistentHash", "creationTimestamp", "customMetrics", "customRequestHeaders", "customResponseHeaders", "description", "edgeSecurityPolicy", "enableCDN", "externalManagedMigrationState", "externalManagedMigrationTestingPercentage", "failoverPolicy", "fingerprint", "haPolicy", "healthChecks", "iap", "id", "ipAddressSelectionPolicy", "kind", "loadBalancingScheme", "localityLbPolicies", "localityLbPolicy", "logConfig", "maxStreamDuration", "metadatas", "name", "network", "networkPassThroughLbTrafficPolicy", "outlierDetection", "params", "port", "portName", "protocol", "region", "securityPolicy", "securitySettings", "selfLink", "serviceBindings", "serviceLbPolicy", "sessionAffinity", "strongSessionAffinityCookie", "subsetting", "timeoutSec", "tlsSettings", "usedBy"]
#
#   affinityCookieTtlSec: integer, format: int32
#   backends: array<Backend>
#   cdnPolicy: $ref: BackendServiceCdnPolicy
#   circuitBreakers: $ref: CircuitBreakers
#   compressionMode: string, enum: [AUTOMATIC, DISABLED]
#   connectionDraining: $ref: ConnectionDraining
#   connectionTrackingPolicy: $ref: BackendServiceConnectionTrackingPolicy
#   consistentHash: $ref: ConsistentHashLoadBalancerSettings
#   creationTimestamp: string, readOnly
#   customMetrics: array<BackendServiceCustomMetric>
#   customRequestHeaders: array<string>
#   customResponseHeaders: array<string>
#   description: string
#   edgeSecurityPolicy: string
#   enableCDN: boolean
#   externalManagedMigrationState: string, enum: [PREPARE, TEST_ALL_TRAFFIC, TEST_BY_PERCENTAGE]
#   externalManagedMigrationTestingPercentage: number, format: float
#   failoverPolicy: $ref: BackendServiceFailoverPolicy
#   fingerprint: string, format: byte
#   haPolicy: $ref: BackendServiceHAPolicy
#   healthChecks: array<string>
#   iap: $ref: BackendServiceIAP
#   id: string, format: uint64
#   ipAddressSelectionPolicy: string, enum: [IPV4_ONLY, IPV6_ONLY, IP_ADDRESS_SELECTION_POLICY_UNSPECIFIED, PREFER_IPV6]
#   kind: string, readOnly
#   loadBalancingScheme: string, enum: [EXTERNAL, EXTERNAL_MANAGED, INTERNAL, INTERNAL_MANAGED, ... +2]
#   localityLbPolicies: array<BackendServiceLocalityLoadBalancingPolicyConfig>
#   localityLbPolicy: string, enum: [INVALID_LB_POLICY, LEAST_REQUEST, MAGLEV, ORIGINAL_DESTINATION, ... +6]
#   logConfig: $ref: BackendServiceLogConfig
#   maxStreamDuration: $ref: Duration
#   metadatas: map<string, string>
#   name: string
#   network: string
#   networkPassThroughLbTrafficPolicy: $ref: BackendServiceNetworkPassThroughLbTrafficPolicy
#   outlierDetection: $ref: OutlierDetection
#   params: $ref: BackendServiceParams
#   port: integer, format: int32
#   portName: string
#   protocol: string, enum: [GRPC, H2C, HTTP, HTTP2, ... +5]
#   region: string, readOnly
#   securityPolicy: string
#   securitySettings: $ref: SecuritySettings
#   selfLink: string
#   serviceBindings: array<string>
#   serviceLbPolicy: string
#   sessionAffinity: string, enum: [CLIENT_IP, CLIENT_IP_NO_DESTINATION, CLIENT_IP_PORT_PROTO, CLIENT_IP_PROTO, ... +5]
#   strongSessionAffinityCookie: $ref: BackendServiceHttpCookie
#   subsetting: $ref: Subsetting
#   timeoutSec: integer, format: int32
#   tlsSettings: $ref: BackendServiceTlsSettings
#   usedBy: array<BackendServiceUsedBy>, readOnly
#
# [types.field_overrides]
# name = { required = true }
# fingerprint = { format = "bytes" }
# # externalManagedMigrationState = { enum_type = "BackendServiceExternalManagedMigrationState" }
# # loadBalancingScheme = { enum_type = "BackendServiceLoadBalancingScheme" }
# # localityLbPolicy = { enum_type = "BackendServiceLocalityLbPolicy" }
# # ipAddressSelectionPolicy = { enum_type = "BackendServiceIpAddressSelectionPolicy" }
# # compressionMode = { enum_type = "BackendServiceCompressionMode" }
# # protocol = { enum_type = "BackendServiceProtocol" }
# # sessionAffinity = { enum_type = "BackendServiceSessionAffinity" }

# --- BackendServiceAggregatedList (7 fields) ---
# Contains a list of BackendServicesScopedList.
# [[types]]
# schema = "BackendServiceAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, BackendServicesScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- BackendServiceCdnPolicy (12 fields) ---
# Message containing Cloud CDN configuration for a backend service.
# [[types]]
# schema = "BackendServiceCdnPolicy"
# include_fields = ["bypassCacheOnRequestHeaders", "cacheKeyPolicy", "cacheMode", "clientTtl", "defaultTtl", "maxTtl", "negativeCaching", "negativeCachingPolicy", "requestCoalescing", "serveWhileStale", "signedUrlCacheMaxAgeSec", "signedUrlKeyNames"]
#
#   bypassCacheOnRequestHeaders: array<BackendServiceCdnPolicyBypassCacheOnRequestHeader>
#   cacheKeyPolicy: $ref: CacheKeyPolicy
#   cacheMode: string, enum: [CACHE_ALL_STATIC, FORCE_CACHE_ALL, INVALID_CACHE_MODE, USE_ORIGIN_HEADERS]
#   clientTtl: integer, format: int32
#   defaultTtl: integer, format: int32
#   maxTtl: integer, format: int32
#   negativeCaching: boolean
#   negativeCachingPolicy: array<BackendServiceCdnPolicyNegativeCachingPolicy>
#   requestCoalescing: boolean
#   serveWhileStale: integer, format: int32
#   signedUrlCacheMaxAgeSec: string, format: int64
#   signedUrlKeyNames: array<string>
#
# [types.field_overrides]
# # cacheMode = { enum_type = "BackendServiceCdnPolicyCacheMode" }

# --- BackendServiceCdnPolicyBypassCacheOnRequestHeader (1 fields) ---
# Bypass the cache when the specified request headers are present, e.g. Pragma or Authorization header
# [[types]]
# schema = "BackendServiceCdnPolicyBypassCacheOnRequestHeader"
# include_fields = ["headerName"]
#
#   headerName: string

# --- BackendServiceCdnPolicyNegativeCachingPolicy (2 fields) ---
# Specify CDN TTLs for response error codes.
# [[types]]
# schema = "BackendServiceCdnPolicyNegativeCachingPolicy"
# include_fields = ["code", "ttl"]
#
#   code: integer, format: int32
#   ttl: integer, format: int32

# --- BackendServiceConnectionTrackingPolicy (4 fields) ---
# Connection Tracking configuration for this BackendService.
# [[types]]
# schema = "BackendServiceConnectionTrackingPolicy"
# include_fields = ["connectionPersistenceOnUnhealthyBackends", "enableStrongAffinity", "idleTimeoutSec", "trackingMode"]
#
#   connectionPersistenceOnUnhealthyBackends: string, enum: [ALWAYS_PERSIST, DEFAULT_FOR_PROTOCOL, NEVER_PERSIST]
#   enableStrongAffinity: boolean
#   idleTimeoutSec: integer, format: int32
#   trackingMode: string, enum: [INVALID_TRACKING_MODE, PER_CONNECTION, PER_SESSION]
#
# [types.field_overrides]
# # connectionPersistenceOnUnhealthyBackends = { enum_type = "BackendServiceConnectionTrackingPolicyConnectionPersistenceOnUnhealthyBackends" }
# # trackingMode = { enum_type = "BackendServiceConnectionTrackingPolicyTrackingMode" }

# --- BackendServiceCustomMetric (2 fields) ---
# Custom Metrics are used for WEIGHTED_ROUND_ROBIN locality_lb_policy.
# [[types]]
# schema = "BackendServiceCustomMetric"
# include_fields = ["dryRun", "name"]
#
#   dryRun: boolean
#   name: string
#
# [types.field_overrides]
# name = { required = true }

# --- BackendServiceFailoverPolicy (3 fields) ---
# For load balancers that have configurable failover: [Internal passthrough Network Load Balancers](ht
# [[types]]
# schema = "BackendServiceFailoverPolicy"
# include_fields = ["disableConnectionDrainOnFailover", "dropTrafficIfUnhealthy", "failoverRatio"]
#
#   disableConnectionDrainOnFailover: boolean
#   dropTrafficIfUnhealthy: boolean
#   failoverRatio: number, format: float

# --- BackendServiceGroupHealth (3 fields) ---
# [[types]]
# schema = "BackendServiceGroupHealth"
# include_fields = ["annotations", "healthStatus", "kind"]
#
#   annotations: map<string, string>
#   healthStatus: array<HealthStatus>
#   kind: string, readOnly

# --- BackendServiceHAPolicy (2 fields) ---
# [[types]]
# schema = "BackendServiceHAPolicy"
# include_fields = ["fastIPMove", "leader"]
#
#   fastIPMove: string, enum: [DISABLED, GARP_RA]
#   leader: $ref: BackendServiceHAPolicyLeader
#
# [types.field_overrides]
# # fastIPMove = { enum_type = "BackendServiceHAPolicyFastIPMove" }

# --- BackendServiceHAPolicyLeader (2 fields) ---
# [[types]]
# schema = "BackendServiceHAPolicyLeader"
# include_fields = ["backendGroup", "networkEndpoint"]
#
#   backendGroup: string
#   networkEndpoint: $ref: BackendServiceHAPolicyLeaderNetworkEndpoint

# --- BackendServiceHAPolicyLeaderNetworkEndpoint (1 fields) ---
# [[types]]
# schema = "BackendServiceHAPolicyLeaderNetworkEndpoint"
# include_fields = ["instance"]
#
#   instance: string

# --- BackendServiceHttpCookie (3 fields) ---
# The HTTP cookie used for stateful session affinity.
# [[types]]
# schema = "BackendServiceHttpCookie"
# include_fields = ["name", "path", "ttl"]
#
#   name: string
#   path: string
#   ttl: $ref: Duration
#
# [types.field_overrides]
# name = { required = true }

# --- BackendServiceIAP (4 fields) ---
# Identity-Aware Proxy
# [[types]]
# schema = "BackendServiceIAP"
# include_fields = ["enabled", "oauth2ClientId", "oauth2ClientSecret", "oauth2ClientSecretSha256"]
#
#   enabled: boolean
#   oauth2ClientId: string
#   oauth2ClientSecret: string
#   oauth2ClientSecretSha256: string, readOnly

# --- BackendServiceList (6 fields) ---
# Contains a list of BackendService resources.
# [[types]]
# schema = "BackendServiceList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<BackendService>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- BackendServiceListUsable (6 fields) ---
# Contains a list of usable BackendService resources.
# [[types]]
# schema = "BackendServiceListUsable"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<BackendService>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- BackendServiceLocalityLoadBalancingPolicyConfig (2 fields) ---
# Container for either a built-in LB policy supported by gRPC or Envoy or a custom one implemented by 
# [[types]]
# schema = "BackendServiceLocalityLoadBalancingPolicyConfig"
# include_fields = ["customPolicy", "policy"]
#
#   customPolicy: $ref: BackendServiceLocalityLoadBalancingPolicyConfigCustomPolicy
#   policy: $ref: BackendServiceLocalityLoadBalancingPolicyConfigPolicy

# --- BackendServiceLocalityLoadBalancingPolicyConfigCustomPolicy (2 fields) ---
# The configuration for a custom policy implemented by the user and deployed with the client.
# [[types]]
# schema = "BackendServiceLocalityLoadBalancingPolicyConfigCustomPolicy"
# include_fields = ["data", "name"]
#
#   data: string
#   name: string
#
# [types.field_overrides]
# name = { required = true }

# --- BackendServiceLocalityLoadBalancingPolicyConfigPolicy (1 fields) ---
# The configuration for a built-in load balancing policy.
# [[types]]
# schema = "BackendServiceLocalityLoadBalancingPolicyConfigPolicy"
# include_fields = ["name"]
#
#   name: string, enum: [INVALID_LB_POLICY, LEAST_REQUEST, MAGLEV, ORIGINAL_DESTINATION, ... +6]
#
# [types.field_overrides]
# name = { required = true }
# # name = { enum_type = "BackendServiceLocalityLoadBalancingPolicyConfigPolicyName" }

# --- BackendServiceLogConfig (4 fields) [IN MANIFEST] ---
# The available logging options for the load balancer traffic served by this backend service.
# [[types]]
# schema = "BackendServiceLogConfig"
# include_fields = ["enable", "optionalFields", "optionalMode", "sampleRate"]
#
#   enable: boolean
#   optionalFields: array<string>
#   optionalMode: string, enum: [CUSTOM, EXCLUDE_ALL_OPTIONAL, INCLUDE_ALL_OPTIONAL]
#   sampleRate: number, format: float
#
# [types.field_overrides]
# # optionalMode = { enum_type = "BackendServiceLogConfigOptionalMode" }

# --- BackendServiceNetworkPassThroughLbTrafficPolicy (1 fields) ---
# [[types]]
# schema = "BackendServiceNetworkPassThroughLbTrafficPolicy"
# include_fields = ["zonalAffinity"]
#
#   zonalAffinity: $ref: BackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinity

# --- BackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinity (2 fields) ---
# [[types]]
# schema = "BackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinity"
# include_fields = ["spillover", "spilloverRatio"]
#
#   spillover: string, enum: [ZONAL_AFFINITY_DISABLED, ZONAL_AFFINITY_SPILL_CROSS_ZONE, ZONAL_AFFINITY_STAY_WITHIN_ZONE]
#   spilloverRatio: number, format: float
#
# [types.field_overrides]
# # spillover = { enum_type = "BackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinitySpillover" }

# --- BackendServiceParams (1 fields) ---
# Additional Backend Service parameters.
# [[types]]
# schema = "BackendServiceParams"
# include_fields = ["resourceManagerTags"]
#
#   resourceManagerTags: map<string, string>

# --- BackendServiceReference (1 fields) ---
# [[types]]
# schema = "BackendServiceReference"
# include_fields = ["backendService"]
#
#   backendService: string

# --- BackendServiceTlsSettings (3 fields) ---
# [[types]]
# schema = "BackendServiceTlsSettings"
# include_fields = ["authenticationConfig", "sni", "subjectAltNames"]
#
#   authenticationConfig: string
#   sni: string
#   subjectAltNames: array<BackendServiceTlsSettingsSubjectAltName>

# --- BackendServiceTlsSettingsSubjectAltName (2 fields) ---
# A Subject Alternative Name that the load balancer matches against the SAN field in the TLS certifica
# [[types]]
# schema = "BackendServiceTlsSettingsSubjectAltName"
# include_fields = ["dnsName", "uniformResourceIdentifier"]
#
#   dnsName: string
#   uniformResourceIdentifier: string

# --- BackendServiceUsedBy (1 fields) ---
# [[types]]
# schema = "BackendServiceUsedBy"
# include_fields = ["reference"]
#
#   reference: string, readOnly

# --- BackendServicesScopedList (2 fields) ---
# [[types]]
# schema = "BackendServicesScopedList"
# include_fields = ["backendServices", "warning"]
#
#   backendServices: array<BackendService>
#   warning: object

# --- BfdPacket (16 fields) ---
# WARNING: reserved words: final
# [[types]]
# schema = "BfdPacket"
# include_fields = ["authenticationPresent", "controlPlaneIndependent", "demand", "diagnostic", "final", "length", "minEchoRxIntervalMs", "minRxIntervalMs", "minTxIntervalMs", "multiplier", "multipoint", "myDiscriminator", "poll", "state", "version", "yourDiscriminator"]
#
#   authenticationPresent: boolean
#   controlPlaneIndependent: boolean
#   demand: boolean
#   diagnostic: string, enum: [ADMINISTRATIVELY_DOWN, CONCATENATED_PATH_DOWN, CONTROL_DETECTION_TIME_EXPIRED, DIAGNOSTIC_UNSPECIFIED, ... +6]
#   final: boolean, RESERVED_WORD
#   length: integer, format: uint32
#   minEchoRxIntervalMs: integer, format: uint32
#   minRxIntervalMs: integer, format: uint32
#   minTxIntervalMs: integer, format: uint32
#   multiplier: integer, format: uint32
#   multipoint: boolean
#   myDiscriminator: integer, format: uint32
#   poll: boolean
#   state: string, enum: [ADMIN_DOWN, DOWN, INIT, STATE_UNSPECIFIED, UP]
#   version: integer, format: uint32
#   yourDiscriminator: integer, format: uint32
#
# [types.field_overrides]
# final = { rust_name = "final_value", serde_rename = "final" }
# # state = { enum_type = "BfdPacketState" }
# # diagnostic = { enum_type = "BfdPacketDiagnostic" }

# --- BfdStatus (10 fields) ---
# Next free: 15
# [[types]]
# schema = "BfdStatus"
# include_fields = ["bfdSessionInitializationMode", "configUpdateTimestampMicros", "controlPacketCounts", "controlPacketIntervals", "localDiagnostic", "localState", "negotiatedLocalControlTxIntervalMs", "rxPacket", "txPacket", "uptimeMs"]
#
#   bfdSessionInitializationMode: string, enum: [ACTIVE, DISABLED, PASSIVE]
#   configUpdateTimestampMicros: string, format: int64
#   controlPacketCounts: $ref: BfdStatusPacketCounts
#   controlPacketIntervals: array<PacketIntervals>
#   localDiagnostic: string, enum: [ADMINISTRATIVELY_DOWN, CONCATENATED_PATH_DOWN, CONTROL_DETECTION_TIME_EXPIRED, DIAGNOSTIC_UNSPECIFIED, ... +6]
#   localState: string, enum: [ADMIN_DOWN, DOWN, INIT, STATE_UNSPECIFIED, UP]
#   negotiatedLocalControlTxIntervalMs: integer, format: uint32
#   rxPacket: $ref: BfdPacket
#   txPacket: $ref: BfdPacket
#   uptimeMs: string, format: int64
#
# [types.field_overrides]
# # localState = { enum_type = "BfdStatusLocalState" }
# # bfdSessionInitializationMode = { enum_type = "BfdStatusBfdSessionInitializationMode" }
# # localDiagnostic = { enum_type = "BfdStatusLocalDiagnostic" }

# --- BfdStatusPacketCounts (4 fields) ---
# [[types]]
# schema = "BfdStatusPacketCounts"
# include_fields = ["numRx", "numRxRejected", "numRxSuccessful", "numTx"]
#
#   numRx: integer, format: uint32
#   numRxRejected: integer, format: uint32
#   numRxSuccessful: integer, format: uint32
#   numTx: integer, format: uint32

# --- BgpRoute (5 fields) ---
# [[types]]
# schema = "BgpRoute"
# include_fields = ["asPaths", "communities", "destination", "med", "origin"]
#
#   asPaths: array<BgpRouteAsPath>, readOnly
#   communities: array<string>, readOnly
#   destination: $ref: BgpRouteNetworkLayerReachabilityInformation, readOnly
#   med: integer, format: uint32, readOnly
#   origin: string, enum: [BGP_ORIGIN_EGP, BGP_ORIGIN_IGP, BGP_ORIGIN_INCOMPLETE], readOnly
#
# [types.field_overrides]
# # origin = { enum_type = "BgpRouteOrigin" }

# --- BgpRouteAsPath (3 fields) ---
# WARNING: reserved words: type
# [[types]]
# schema = "BgpRouteAsPath"
# include_fields = ["asns", "asns32", "type"]
#
#   asns: array<integer>, readOnly
#   asns32: array<integer>, readOnly
#   type: string, enum: [AS_PATH_TYPE_SEQUENCE, AS_PATH_TYPE_SET], readOnly, RESERVED_WORD
#
# [types.field_overrides]
# type = { rust_name = "type_value", serde_rename = "type" }
# # type = { enum_type = "BgpRouteAsPathType" }

# --- BgpRouteNetworkLayerReachabilityInformation (2 fields) ---
# Network Layer Reachability Information (NLRI) for a route.
# [[types]]
# schema = "BgpRouteNetworkLayerReachabilityInformation"
# include_fields = ["pathId", "prefix"]
#
#   pathId: integer, format: uint32
#   prefix: string

# --- Binding (3 fields) ---
# Associates `members`, or principals, with a `role`.
# [[types]]
# schema = "Binding"
# include_fields = ["condition", "members", "role"]
#
#   condition: $ref: Expr
#   members: array<string>
#   role: string

# --- BulkInsertDiskResource (1 fields) ---
# A transient resource used in compute.disks.bulkInsert and compute.regionDisks.bulkInsert. It is only
# [[types]]
# schema = "BulkInsertDiskResource"
# include_fields = ["sourceConsistencyGroupPolicy"]
#
#   sourceConsistencyGroupPolicy: string

# --- BulkInsertInstanceResource (8 fields) ---
# A transient resource used in compute.instances.bulkInsert and compute.regionInstances.bulkInsert . T
# [[types]]
# schema = "BulkInsertInstanceResource"
# include_fields = ["count", "instanceFlexibilityPolicy", "instanceProperties", "locationPolicy", "minCount", "namePattern", "perInstanceProperties", "sourceInstanceTemplate"]
#
#   count: string, format: int64
#   instanceFlexibilityPolicy: $ref: InstanceFlexibilityPolicy
#   instanceProperties: $ref: InstanceProperties
#   locationPolicy: $ref: LocationPolicy
#   minCount: string, format: int64
#   namePattern: string
#   perInstanceProperties: map<string, BulkInsertInstanceResourcePerInstanceProperties>
#   sourceInstanceTemplate: string

# --- BulkInsertInstanceResourcePerInstanceProperties (2 fields) ---
# Per-instance properties to be set on individual instances. To be extended in the future.
# [[types]]
# schema = "BulkInsertInstanceResourcePerInstanceProperties"
# include_fields = ["hostname", "name"]
#
#   hostname: string
#   name: string, readOnly
#
# [types.field_overrides]
# name = { required = true }

# --- BulkInsertOperationStatus (5 fields) ---
# [[types]]
# schema = "BulkInsertOperationStatus"
# include_fields = ["createdVmCount", "deletedVmCount", "failedToCreateVmCount", "status", "targetVmCount"]
#
#   createdVmCount: integer, format: int32
#   deletedVmCount: integer, format: int32
#   failedToCreateVmCount: integer, format: int32
#   status: string, enum: [CREATING, DONE, ROLLING_BACK, STATUS_UNSPECIFIED]
#   targetVmCount: integer, format: int32
#
# [types.field_overrides]
# # status = { enum_type = "BulkInsertOperationStatusStatus" }

# --- BulkSetLabelsRequest (2 fields) ---
# WARNING: format:"byte" fields: labelFingerprint
# [[types]]
# schema = "BulkSetLabelsRequest"
# include_fields = ["labelFingerprint", "labels"]
#
#   labelFingerprint: string, format: byte
#   labels: map<string, string>
#
# [types.field_overrides]
# labelFingerprint = { format = "bytes" }

# --- BulkZoneSetLabelsRequest (1 fields) ---
# [[types]]
# schema = "BulkZoneSetLabelsRequest"
# include_fields = ["requests"]
#
#   requests: array<BulkSetLabelsRequest>

# --- BundledLocalSsds (2 fields) ---
# [[types]]
# schema = "BundledLocalSsds"
# include_fields = ["defaultInterface", "partitionCount"]
#
#   defaultInterface: string
#   partitionCount: integer, format: int32

# --- CacheInvalidationRule (3 fields) ---
# [[types]]
# schema = "CacheInvalidationRule"
# include_fields = ["cacheTags", "host", "path"]
#
#   cacheTags: array<string>
#   host: string
#   path: string

# --- CacheKeyPolicy (7 fields) ---
# Message containing what to include in the cache key for a request for Cloud CDN.
# [[types]]
# schema = "CacheKeyPolicy"
# include_fields = ["includeHost", "includeHttpHeaders", "includeNamedCookies", "includeProtocol", "includeQueryString", "queryStringBlacklist", "queryStringWhitelist"]
#
#   includeHost: boolean
#   includeHttpHeaders: array<string>
#   includeNamedCookies: array<string>
#   includeProtocol: boolean
#   includeQueryString: boolean
#   queryStringBlacklist: array<string>
#   queryStringWhitelist: array<string>

# --- CalendarModeAdviceRequest (1 fields) ---
# A request to recommend the best way to consume the specified resources in the future.
# [[types]]
# schema = "CalendarModeAdviceRequest"
# include_fields = ["futureResourcesSpecs"]
#
#   futureResourcesSpecs: map<string, FutureResourcesSpec>

# --- CalendarModeAdviceResponse (1 fields) ---
# A response containing the recommended way of creating the specified resources in the future. It cont
# [[types]]
# schema = "CalendarModeAdviceResponse"
# include_fields = ["recommendations"]
#
#   recommendations: array<CalendarModeRecommendation>

# --- CalendarModeRecommendation (1 fields) ---
# A single recommendation to create requested resources. Contains detailed recommendations for every f
# [[types]]
# schema = "CalendarModeRecommendation"
# include_fields = ["recommendationsPerSpec"]
#
#   recommendationsPerSpec: map<string, FutureResourcesRecommendation>

# --- CircuitBreakers (5 fields) ---
# Settings controlling the volume of requests, connections and retries to this backend service.
# [[types]]
# schema = "CircuitBreakers"
# include_fields = ["maxConnections", "maxPendingRequests", "maxRequests", "maxRequestsPerConnection", "maxRetries"]
#
#   maxConnections: integer, format: int32
#   maxPendingRequests: integer, format: int32
#   maxRequests: integer, format: int32
#   maxRequestsPerConnection: integer, format: int32
#   maxRetries: integer, format: int32

# --- Commitment (23 fields) ---
# Represents a regional resource-based commitment resource. Creating this commitment resource means th
# WARNING: reserved words: type
# [[types]]
# schema = "Commitment"
# include_fields = ["autoRenew", "category", "creationTimestamp", "customEndTimestamp", "description", "endTimestamp", "existingReservations", "id", "kind", "licenseResource", "mergeSourceCommitments", "name", "plan", "region", "reservations", "resourceStatus", "resources", "selfLink", "splitSourceCommitment", "startTimestamp", "status", "statusMessage", "type"]
#
#   autoRenew: boolean
#   category: string, enum: [CATEGORY_UNSPECIFIED, LICENSE, MACHINE]
#   creationTimestamp: string, readOnly
#   customEndTimestamp: string
#   description: string
#   endTimestamp: string, readOnly
#   existingReservations: array<string>
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   licenseResource: $ref: LicenseResourceCommitment
#   mergeSourceCommitments: array<string>
#   name: string
#   plan: string, enum: [INVALID, THIRTY_SIX_MONTH, TWELVE_MONTH]
#   region: string, readOnly
#   reservations: array<Reservation>
#   resourceStatus: $ref: CommitmentResourceStatus, readOnly
#   resources: array<ResourceCommitment>
#   selfLink: string, readOnly
#   splitSourceCommitment: string
#   startTimestamp: string, readOnly
#   status: string, enum: [ACTIVE, CANCELLED, CREATING, EXPIRED, NOT_YET_ACTIVE], readOnly
#   statusMessage: string, readOnly
#   type: string, enum: [ACCELERATOR_OPTIMIZED, ACCELERATOR_OPTIMIZED_A3, ACCELERATOR_OPTIMIZED_A3_MEGA, ACCELERATOR_OPTIMIZED_A3_ULTRA, ... +35], RESERVED_WORD
#
# [types.field_overrides]
# name = { required = true }
# type = { rust_name = "type_value", serde_rename = "type" }
# # category = { enum_type = "CommitmentCategory" }
# # plan = { enum_type = "CommitmentPlan" }
# # type = { enum_type = "CommitmentType" }
# # status = { enum_type = "CommitmentStatus" }

# --- CommitmentAggregatedList (7 fields) ---
# [[types]]
# schema = "CommitmentAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, CommitmentsScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- CommitmentList (6 fields) ---
# Contains a list of Commitment resources.
# [[types]]
# schema = "CommitmentList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<Commitment>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- CommitmentResourceStatus (1 fields) ---
# [Output Only] Contains output only fields.
# [[types]]
# schema = "CommitmentResourceStatus"
# include_fields = ["customTermEligibilityEndTimestamp"]
#
#   customTermEligibilityEndTimestamp: string, readOnly

# --- CommitmentsScopedList (2 fields) ---
# [[types]]
# schema = "CommitmentsScopedList"
# include_fields = ["commitments", "warning"]
#
#   commitments: array<Commitment>
#   warning: object

# --- ConfidentialInstanceConfig (2 fields) ---
# A set of Confidential Instance options.
# [[types]]
# schema = "ConfidentialInstanceConfig"
# include_fields = ["confidentialInstanceType", "enableConfidentialCompute"]
#
#   confidentialInstanceType: string, enum: [CONFIDENTIAL_INSTANCE_TYPE_UNSPECIFIED, SEV, SEV_SNP, TDX]
#   enableConfidentialCompute: boolean
#
# [types.field_overrides]
# # confidentialInstanceType = { enum_type = "ConfidentialInstanceConfigConfidentialInstanceType" }

# --- ConnectionDraining (1 fields) [IN MANIFEST] ---
# Message containing connection draining configuration.
# [[types]]
# schema = "ConnectionDraining"
# include_fields = ["drainingTimeoutSec"]
#
#   drainingTimeoutSec: integer, format: int32

# --- ConsistentHashLoadBalancerSettings (3 fields) ---
# This message defines settings for a consistent hash style load balancer.
# [[types]]
# schema = "ConsistentHashLoadBalancerSettings"
# include_fields = ["httpCookie", "httpHeaderName", "minimumRingSize"]
#
#   httpCookie: $ref: ConsistentHashLoadBalancerSettingsHttpCookie
#   httpHeaderName: string
#   minimumRingSize: string, format: int64

# --- ConsistentHashLoadBalancerSettingsHttpCookie (3 fields) ---
# The information about the HTTP Cookie on which the hash function is based for load balancing policie
# [[types]]
# schema = "ConsistentHashLoadBalancerSettingsHttpCookie"
# include_fields = ["name", "path", "ttl"]
#
#   name: string
#   path: string
#   ttl: $ref: Duration
#
# [types.field_overrides]
# name = { required = true }

# --- CorsPolicy (8 fields) ---
# The specification for allowing client-side cross-origin requests. For more information about the W3C
# [[types]]
# schema = "CorsPolicy"
# include_fields = ["allowCredentials", "allowHeaders", "allowMethods", "allowOriginRegexes", "allowOrigins", "disabled", "exposeHeaders", "maxAge"]
#
#   allowCredentials: boolean
#   allowHeaders: array<string>
#   allowMethods: array<string>
#   allowOriginRegexes: array<string>
#   allowOrigins: array<string>
#   disabled: boolean
#   exposeHeaders: array<string>
#   maxAge: integer, format: int32

# --- CrossSiteNetwork (6 fields) ---
# A resource that represents a cross-site network. You can use cross-site networks to connect your on-
# [[types]]
# schema = "CrossSiteNetwork"
# include_fields = ["creationTimestamp", "description", "id", "kind", "name", "selfLink"]
#
#   creationTimestamp: string, readOnly
#   description: string
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   name: string
#   selfLink: string, readOnly
#
# [types.field_overrides]
# name = { required = true }

# --- CrossSiteNetworkList (8 fields) ---
# Response to the list request that contains a list of cross-site networks.
# [[types]]
# schema = "CrossSiteNetworkList"
# include_fields = ["etag", "id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   etag: string
#   id: string
#   items: array<CrossSiteNetwork>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string
#   unreachables: array<string>, readOnly
#   warning: object

# --- CustomErrorResponsePolicy (2 fields) ---
# Specifies the custom error response policy that must be applied when the backend service or backend 
# [[types]]
# schema = "CustomErrorResponsePolicy"
# include_fields = ["errorResponseRules", "errorService"]
#
#   errorResponseRules: array<CustomErrorResponsePolicyCustomErrorResponseRule>
#   errorService: string

# --- CustomErrorResponsePolicyCustomErrorResponseRule (3 fields) ---
# Specifies the mapping between the response code that will be returned along with the custom error co
# [[types]]
# schema = "CustomErrorResponsePolicyCustomErrorResponseRule"
# include_fields = ["matchResponseCodes", "overrideResponseCode", "path"]
#
#   matchResponseCodes: array<string>
#   overrideResponseCode: integer, format: int32
#   path: string

# --- CustomerEncryptionKey (5 fields) [IN MANIFEST] ---
# [[types]]
# schema = "CustomerEncryptionKey"
# include_fields = ["kmsKeyName", "kmsKeyServiceAccount", "rawKey", "rsaEncryptedKey", "sha256"]
#
#   kmsKeyName: string
#   kmsKeyServiceAccount: string
#   rawKey: string
#   rsaEncryptedKey: string
#   sha256: string

# --- CustomerEncryptionKeyProtectedDisk (2 fields) ---
# [[types]]
# schema = "CustomerEncryptionKeyProtectedDisk"
# include_fields = ["diskEncryptionKey", "source"]
#
#   diskEncryptionKey: $ref: CustomerEncryptionKey
#   source: string

# --- Date (3 fields) ---
# Represents a whole or partial calendar date, such as a birthday. The time of day and time zone are e
# [[types]]
# schema = "Date"
# include_fields = ["day", "month", "year"]
#
#   day: integer, format: int32
#   month: integer, format: int32
#   year: integer, format: int32

# --- DeprecationStatus (5 fields) ---
# Deprecation status for a public resource.
# [[types]]
# schema = "DeprecationStatus"
# include_fields = ["deleted", "deprecated", "obsolete", "replacement", "state"]
#
#   deleted: string
#   deprecated: string
#   obsolete: string
#   replacement: string
#   state: string, enum: [ACTIVE, DELETED, DEPRECATED, OBSOLETE]
#
# [types.field_overrides]
# # state = { enum_type = "DeprecationStatusState" }

# --- Disk (50 fields) [IN MANIFEST] ---
# Represents a Persistent Disk resource. Google Compute Engine has two Disk resources: * [Zonal](/comp
# WARNING: format:"byte" fields: labelFingerprint
# WARNING: reserved words: type
# [[types]]
# schema = "Disk"
# include_fields = ["accessMode", "architecture", "asyncPrimaryDisk", "asyncSecondaryDisks", "creationTimestamp", "description", "diskEncryptionKey", "enableConfidentialCompute", "guestOsFeatures", "id", "kind", "labelFingerprint", "labels", "lastAttachTimestamp", "lastDetachTimestamp", "licenseCodes", "licenses", "locationHint", "name", "options", "params", "physicalBlockSizeBytes", "provisionedIops", "provisionedThroughput", "region", "replicaZones", "resourcePolicies", "resourceStatus", "satisfiesPzi", "satisfiesPzs", "selfLink", "sizeGb", "sourceConsistencyGroupPolicy", "sourceConsistencyGroupPolicyId", "sourceDisk", "sourceDiskId", "sourceImage", "sourceImageEncryptionKey", "sourceImageId", "sourceInstantSnapshot", "sourceInstantSnapshotId", "sourceSnapshot", "sourceSnapshotEncryptionKey", "sourceSnapshotId", "sourceStorageObject", "status", "storagePool", "type", "users", "zone"]
#
#   accessMode: string, enum: [READ_ONLY_MANY, READ_WRITE_MANY, READ_WRITE_SINGLE]
#   architecture: string, enum: [ARCHITECTURE_UNSPECIFIED, ARM64, X86_64]
#   asyncPrimaryDisk: $ref: DiskAsyncReplication
#   asyncSecondaryDisks: map<string, DiskAsyncReplicationList>, readOnly
#   creationTimestamp: string, readOnly
#   description: string
#   diskEncryptionKey: $ref: CustomerEncryptionKey
#   enableConfidentialCompute: boolean
#   guestOsFeatures: array<GuestOsFeature>
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   labelFingerprint: string, format: byte
#   labels: map<string, string>
#   lastAttachTimestamp: string, readOnly
#   lastDetachTimestamp: string, readOnly
#   licenseCodes: array<string>
#   licenses: array<string>
#   locationHint: string
#   name: string
#   options: string
#   params: $ref: DiskParams
#   physicalBlockSizeBytes: string, format: int64
#   provisionedIops: string, format: int64
#   provisionedThroughput: string, format: int64
#   region: string, readOnly
#   replicaZones: array<string>
#   resourcePolicies: array<string>
#   resourceStatus: $ref: DiskResourceStatus, readOnly
#   satisfiesPzi: boolean, readOnly
#   satisfiesPzs: boolean, readOnly
#   selfLink: string, readOnly
#   sizeGb: string, format: int64
#   sourceConsistencyGroupPolicy: string, readOnly
#   sourceConsistencyGroupPolicyId: string, readOnly
#   sourceDisk: string
#   sourceDiskId: string, readOnly
#   sourceImage: string
#   sourceImageEncryptionKey: $ref: CustomerEncryptionKey
#   sourceImageId: string, readOnly
#   sourceInstantSnapshot: string
#   sourceInstantSnapshotId: string, readOnly
#   sourceSnapshot: string
#   sourceSnapshotEncryptionKey: $ref: CustomerEncryptionKey
#   sourceSnapshotId: string, readOnly
#   sourceStorageObject: string
#   status: string, enum: [CREATING, DELETING, FAILED, READY, ... +2], readOnly
#   storagePool: string
#   type: string, RESERVED_WORD
#   users: array<string>, readOnly
#   zone: string, readOnly
#
# [types.field_overrides]
# name = { required = true }
# type = { rust_name = "type_value", serde_rename = "type" }
# labelFingerprint = { format = "bytes" }
# # status = { enum_type = "DiskStatus" }
# # accessMode = { enum_type = "DiskAccessMode" }
# # architecture = { enum_type = "DiskArchitecture" }

# --- DiskAggregatedList (7 fields) ---
# [[types]]
# schema = "DiskAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, DisksScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- DiskAsyncReplication (4 fields) ---
# [[types]]
# schema = "DiskAsyncReplication"
# include_fields = ["consistencyGroupPolicy", "consistencyGroupPolicyId", "disk", "diskId"]
#
#   consistencyGroupPolicy: string, readOnly
#   consistencyGroupPolicyId: string, readOnly
#   disk: string
#   diskId: string, readOnly

# --- DiskAsyncReplicationList (1 fields) ---
# [[types]]
# schema = "DiskAsyncReplicationList"
# include_fields = ["asyncReplicationDisk"]
#
#   asyncReplicationDisk: $ref: DiskAsyncReplication

# --- DiskInstantiationConfig (4 fields) ---
# A specification of the desired way to instantiate a disk in the instance template when its created f
# [[types]]
# schema = "DiskInstantiationConfig"
# include_fields = ["autoDelete", "customImage", "deviceName", "instantiateFrom"]
#
#   autoDelete: boolean
#   customImage: string
#   deviceName: string
#   instantiateFrom: string, enum: [ATTACH_READ_ONLY, BLANK, CUSTOM_IMAGE, DEFAULT, ... +3]
#
# [types.field_overrides]
# # instantiateFrom = { enum_type = "DiskInstantiationConfigInstantiateFrom" }

# --- DiskList (6 fields) ---
# A list of Disk resources.
# [[types]]
# schema = "DiskList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<Disk>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- DiskMoveRequest (2 fields) ---
# [[types]]
# schema = "DiskMoveRequest"
# include_fields = ["destinationZone", "targetDisk"]
#
#   destinationZone: string
#   targetDisk: string

# --- DiskParams (1 fields) ---
# Additional disk params.
# [[types]]
# schema = "DiskParams"
# include_fields = ["resourceManagerTags"]
#
#   resourceManagerTags: map<string, string>

# --- DiskResourceStatus (2 fields) ---
# [[types]]
# schema = "DiskResourceStatus"
# include_fields = ["asyncPrimaryDisk", "asyncSecondaryDisks"]
#
#   asyncPrimaryDisk: $ref: DiskResourceStatusAsyncReplicationStatus
#   asyncSecondaryDisks: map<string, DiskResourceStatusAsyncReplicationStatus>

# --- DiskResourceStatusAsyncReplicationStatus (1 fields) ---
# [[types]]
# schema = "DiskResourceStatusAsyncReplicationStatus"
# include_fields = ["state"]
#
#   state: string, enum: [ACTIVE, CREATED, STARTING, STATE_UNSPECIFIED, ... +2]
#
# [types.field_overrides]
# # state = { enum_type = "DiskResourceStatusAsyncReplicationStatusState" }

# --- DiskType (11 fields) ---
# Represents a Disk Type resource. Google Compute Engine has two Disk Type resources: * [Regional](/co
# [[types]]
# schema = "DiskType"
# include_fields = ["creationTimestamp", "defaultDiskSizeGb", "deprecated", "description", "id", "kind", "name", "region", "selfLink", "validDiskSize", "zone"]
#
#   creationTimestamp: string
#   defaultDiskSizeGb: string, format: int64
#   deprecated: $ref: DeprecationStatus
#   description: string
#   id: string, format: uint64
#   kind: string, readOnly
#   name: string
#   region: string
#   selfLink: string
#   validDiskSize: string
#   zone: string
#
# [types.field_overrides]
# name = { required = true }

# --- DiskTypeAggregatedList (7 fields) ---
# [[types]]
# schema = "DiskTypeAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, DiskTypesScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- DiskTypeList (6 fields) ---
# Contains a list of disk types.
# [[types]]
# schema = "DiskTypeList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<DiskType>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- DiskTypesScopedList (2 fields) ---
# [[types]]
# schema = "DiskTypesScopedList"
# include_fields = ["diskTypes", "warning"]
#
#   diskTypes: array<DiskType>
#   warning: object

# --- DisksAddResourcePoliciesRequest (1 fields) ---
# [[types]]
# schema = "DisksAddResourcePoliciesRequest"
# include_fields = ["resourcePolicies"]
#
#   resourcePolicies: array<string>

# --- DisksRemoveResourcePoliciesRequest (1 fields) ---
# [[types]]
# schema = "DisksRemoveResourcePoliciesRequest"
# include_fields = ["resourcePolicies"]
#
#   resourcePolicies: array<string>

# --- DisksResizeRequest (1 fields) [IN MANIFEST] ---
# [[types]]
# schema = "DisksResizeRequest"
# include_fields = ["sizeGb"]
#
#   sizeGb: string, format: int64

# --- DisksScopedList (2 fields) ---
# [[types]]
# schema = "DisksScopedList"
# include_fields = ["disks", "warning"]
#
#   disks: array<Disk>
#   warning: object

# --- DisksStartAsyncReplicationRequest (1 fields) ---
# [[types]]
# schema = "DisksStartAsyncReplicationRequest"
# include_fields = ["asyncSecondaryDisk"]
#
#   asyncSecondaryDisk: string

# --- DisksStopGroupAsyncReplicationResource (1 fields) ---
# A transient resource used in compute.disks.stopGroupAsyncReplication and compute.regionDisks.stopGro
# [[types]]
# schema = "DisksStopGroupAsyncReplicationResource"
# include_fields = ["resourcePolicy"]
#
#   resourcePolicy: string

# --- DisplayDevice (1 fields) ---
# A set of Display Device options
# [[types]]
# schema = "DisplayDevice"
# include_fields = ["enableDisplay"]
#
#   enableDisplay: boolean

# --- DistributionPolicy (2 fields) ---
# [[types]]
# schema = "DistributionPolicy"
# include_fields = ["targetShape", "zones"]
#
#   targetShape: string, enum: [ANY, ANY_SINGLE_ZONE, BALANCED, EVEN]
#   zones: array<DistributionPolicyZoneConfiguration>
#
# [types.field_overrides]
# # targetShape = { enum_type = "DistributionPolicyTargetShape" }

# --- DistributionPolicyZoneConfiguration (1 fields) ---
# [[types]]
# schema = "DistributionPolicyZoneConfiguration"
# include_fields = ["zone"]
#
#   zone: string

# --- Duration (2 fields) ---
# A Duration represents a fixed-length span of time represented as a count of seconds and fractions of
# [[types]]
# schema = "Duration"
# include_fields = ["nanos", "seconds"]
#
#   nanos: integer, format: int32
#   seconds: string, format: int64

# --- ErrorInfo (3 fields) ---
# Describes the cause of the error with structured details. Example of an error when contacting the "p
# [[types]]
# schema = "ErrorInfo"
# include_fields = ["domain", "metadatas", "reason"]
#
#   domain: string
#   metadatas: map<string, string>
#   reason: string

# --- ExchangedPeeringRoute (5 fields) ---
# WARNING: reserved words: type
# [[types]]
# schema = "ExchangedPeeringRoute"
# include_fields = ["destRange", "imported", "nextHopRegion", "priority", "type"]
#
#   destRange: string
#   imported: boolean
#   nextHopRegion: string
#   priority: integer, format: uint32
#   type: string, enum: [DYNAMIC_PEERING_ROUTE, STATIC_PEERING_ROUTE, SUBNET_PEERING_ROUTE], RESERVED_WORD
#
# [types.field_overrides]
# type = { rust_name = "type_value", serde_rename = "type" }
# # type = { enum_type = "ExchangedPeeringRouteType" }

# --- ExchangedPeeringRoutesList (6 fields) ---
# [[types]]
# schema = "ExchangedPeeringRoutesList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<ExchangedPeeringRoute>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- Expr (4 fields) ---
# Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expr
# [[types]]
# schema = "Expr"
# include_fields = ["description", "expression", "location", "title"]
#
#   description: string
#   expression: string
#   location: string
#   title: string

# --- ExternalVpnGateway (10 fields) ---
# Represents an external VPN gateway. External VPN gateway is the on-premises VPN gateway(s) or anothe
# WARNING: format:"byte" fields: labelFingerprint
# [[types]]
# schema = "ExternalVpnGateway"
# include_fields = ["creationTimestamp", "description", "id", "interfaces", "kind", "labelFingerprint", "labels", "name", "redundancyType", "selfLink"]
#
#   creationTimestamp: string, readOnly
#   description: string
#   id: string, format: uint64, readOnly
#   interfaces: array<ExternalVpnGatewayInterface>
#   kind: string, readOnly
#   labelFingerprint: string, format: byte
#   labels: map<string, string>
#   name: string
#   redundancyType: string, enum: [FOUR_IPS_REDUNDANCY, SINGLE_IP_INTERNALLY_REDUNDANT, TWO_IPS_REDUNDANCY]
#   selfLink: string, readOnly
#
# [types.field_overrides]
# name = { required = true }
# labelFingerprint = { format = "bytes" }
# # redundancyType = { enum_type = "ExternalVpnGatewayRedundancyType" }

# --- ExternalVpnGatewayInterface (3 fields) ---
# The interface for the external VPN gateway.
# [[types]]
# schema = "ExternalVpnGatewayInterface"
# include_fields = ["id", "ipAddress", "ipv6Address"]
#
#   id: integer, format: uint32
#   ipAddress: string
#   ipv6Address: string

# --- ExternalVpnGatewayList (7 fields) ---
# Response to the list request, and contains a list of externalVpnGateways.
# [[types]]
# schema = "ExternalVpnGatewayList"
# include_fields = ["etag", "id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   etag: string
#   id: string
#   items: array<ExternalVpnGateway>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- FileContentBuffer (2 fields) ---
# WARNING: format:"byte" fields: content
# [[types]]
# schema = "FileContentBuffer"
# include_fields = ["content", "fileType"]
#
#   content: string, format: byte
#   fileType: string, enum: [BIN, UNDEFINED, X509]
#
# [types.field_overrides]
# content = { format = "bytes" }
# # fileType = { enum_type = "FileContentBufferFileType" }

# --- Firewall (20 fields) ---
# Represents a Firewall Rule resource. Firewall rules allow or deny ingress traffic to, and egress tra
# [[types]]
# schema = "Firewall"
# include_fields = ["allowed", "creationTimestamp", "denied", "description", "destinationRanges", "direction", "disabled", "id", "kind", "logConfig", "name", "network", "params", "priority", "selfLink", "sourceRanges", "sourceServiceAccounts", "sourceTags", "targetServiceAccounts", "targetTags"]
#
#   allowed: array<object>
#   creationTimestamp: string, readOnly
#   denied: array<object>
#   description: string
#   destinationRanges: array<string>
#   direction: string, enum: [EGRESS, INGRESS]
#   disabled: boolean
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   logConfig: $ref: FirewallLogConfig
#   name: string
#   network: string
#   params: $ref: FirewallParams
#   priority: integer, format: int32
#   selfLink: string
#   sourceRanges: array<string>
#   sourceServiceAccounts: array<string>
#   sourceTags: array<string>
#   targetServiceAccounts: array<string>
#   targetTags: array<string>
#
# [types.field_overrides]
# name = { required = true }
# # direction = { enum_type = "FirewallDirection" }

# --- FirewallList (6 fields) ---
# Contains a list of firewalls.
# [[types]]
# schema = "FirewallList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<Firewall>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- FirewallLogConfig (2 fields) ---
# The available logging options for a firewall rule.
# [[types]]
# schema = "FirewallLogConfig"
# include_fields = ["enable", "metadata"]
#
#   enable: boolean
#   metadata: string, enum: [EXCLUDE_ALL_METADATA, INCLUDE_ALL_METADATA]
#
# [types.field_overrides]
# # metadata = { enum_type = "FirewallLogConfigMetadata" }

# --- FirewallParams (1 fields) ---
# Additional firewall parameters.
# [[types]]
# schema = "FirewallParams"
# include_fields = ["resourceManagerTags"]
#
#   resourceManagerTags: map<string, string>

# --- FirewallPoliciesListAssociationsResponse (2 fields) ---
# [[types]]
# schema = "FirewallPoliciesListAssociationsResponse"
# include_fields = ["associations", "kind"]
#
#   associations: array<FirewallPolicyAssociation>
#   kind: string, readOnly

# --- FirewallPoliciesScopedList (2 fields) ---
# [[types]]
# schema = "FirewallPoliciesScopedList"
# include_fields = ["firewallPolicies", "warning"]
#
#   firewallPolicies: array<FirewallPolicy>
#   warning: object

# --- FirewallPolicy (17 fields) ---
# Represents a Firewall Policy resource.
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "FirewallPolicy"
# include_fields = ["associations", "creationTimestamp", "description", "displayName", "fingerprint", "id", "kind", "name", "packetMirroringRules", "parent", "policyType", "region", "ruleTupleCount", "rules", "selfLink", "selfLinkWithId", "shortName"]
#
#   associations: array<FirewallPolicyAssociation>
#   creationTimestamp: string, readOnly
#   description: string
#   displayName: string
#   fingerprint: string, format: byte
#   id: string, format: uint64
#   kind: string, readOnly
#   name: string
#   packetMirroringRules: array<FirewallPolicyRule>
#   parent: string, readOnly
#   policyType: string, enum: [RDMA_ROCE_POLICY, VPC_POLICY]
#   region: string, readOnly
#   ruleTupleCount: integer, format: int32, readOnly
#   rules: array<FirewallPolicyRule>
#   selfLink: string
#   selfLinkWithId: string, readOnly
#   shortName: string
#
# [types.field_overrides]
# name = { required = true }
# fingerprint = { format = "bytes" }
# # policyType = { enum_type = "FirewallPolicyPolicyType" }

# --- FirewallPolicyAssociation (5 fields) ---
# [[types]]
# schema = "FirewallPolicyAssociation"
# include_fields = ["attachmentTarget", "displayName", "firewallPolicyId", "name", "shortName"]
#
#   attachmentTarget: string
#   displayName: string
#   firewallPolicyId: string, readOnly
#   name: string
#   shortName: string, readOnly
#
# [types.field_overrides]
# name = { required = true }

# --- FirewallPolicyList (5 fields) ---
# [[types]]
# schema = "FirewallPolicyList"
# include_fields = ["id", "items", "kind", "nextPageToken", "warning"]
#
#   id: string
#   items: array<FirewallPolicy>
#   kind: string, readOnly
#   nextPageToken: string
#   warning: object

# --- FirewallPolicyRule (15 fields) ---
# Represents a rule that describes one or more match conditions along with the action to be taken when
# WARNING: reserved words: match
# [[types]]
# schema = "FirewallPolicyRule"
# include_fields = ["action", "description", "direction", "disabled", "enableLogging", "kind", "match", "priority", "ruleName", "ruleTupleCount", "securityProfileGroup", "targetResources", "targetSecureTags", "targetServiceAccounts", "tlsInspect"]
#
#   action: string
#   description: string
#   direction: string, enum: [EGRESS, INGRESS]
#   disabled: boolean
#   enableLogging: boolean
#   kind: string, readOnly
#   match: $ref: FirewallPolicyRuleMatcher, RESERVED_WORD
#   priority: integer, format: int32
#   ruleName: string
#   ruleTupleCount: integer, format: int32, readOnly
#   securityProfileGroup: string
#   targetResources: array<string>
#   targetSecureTags: array<FirewallPolicyRuleSecureTag>
#   targetServiceAccounts: array<string>
#   tlsInspect: boolean
#
# [types.field_overrides]
# match = { rust_name = "match_value", serde_rename = "match" }
# # direction = { enum_type = "FirewallPolicyRuleDirection" }

# --- FirewallPolicyRuleMatcher (17 fields) ---
# Represents a match condition that incoming traffic is evaluated against. Exactly one field must be s
# [[types]]
# schema = "FirewallPolicyRuleMatcher"
# include_fields = ["destAddressGroups", "destFqdns", "destIpRanges", "destNetworkContext", "destNetworkType", "destRegionCodes", "destThreatIntelligences", "layer4Configs", "srcAddressGroups", "srcFqdns", "srcIpRanges", "srcNetworkContext", "srcNetworkType", "srcNetworks", "srcRegionCodes", "srcSecureTags", "srcThreatIntelligences"]
#
#   destAddressGroups: array<string>
#   destFqdns: array<string>
#   destIpRanges: array<string>
#   destNetworkContext: string, enum: [INTERNET, INTRA_VPC, NON_INTERNET, UNSPECIFIED, VPC_NETWORKS]
#   destNetworkType: string, enum: [INTERNET, INTRA_VPC, NON_INTERNET, UNSPECIFIED, VPC_NETWORKS]
#   destRegionCodes: array<string>
#   destThreatIntelligences: array<string>
#   layer4Configs: array<FirewallPolicyRuleMatcherLayer4Config>
#   srcAddressGroups: array<string>
#   srcFqdns: array<string>
#   srcIpRanges: array<string>
#   srcNetworkContext: string, enum: [INTERNET, INTRA_VPC, NON_INTERNET, UNSPECIFIED, VPC_NETWORKS]
#   srcNetworkType: string, enum: [INTERNET, INTRA_VPC, NON_INTERNET, UNSPECIFIED, VPC_NETWORKS]
#   srcNetworks: array<string>
#   srcRegionCodes: array<string>
#   srcSecureTags: array<FirewallPolicyRuleSecureTag>
#   srcThreatIntelligences: array<string>
#
# [types.field_overrides]
# # srcNetworkContext = { enum_type = "FirewallPolicyRuleMatcherSrcNetworkContext" }
# # destNetworkContext = { enum_type = "FirewallPolicyRuleMatcherDestNetworkContext" }
# # srcNetworkType = { enum_type = "FirewallPolicyRuleMatcherSrcNetworkType" }
# # destNetworkType = { enum_type = "FirewallPolicyRuleMatcherDestNetworkType" }

# --- FirewallPolicyRuleMatcherLayer4Config (2 fields) ---
# [[types]]
# schema = "FirewallPolicyRuleMatcherLayer4Config"
# include_fields = ["ipProtocol", "ports"]
#
#   ipProtocol: string
#   ports: array<string>

# --- FirewallPolicyRuleSecureTag (2 fields) ---
# [[types]]
# schema = "FirewallPolicyRuleSecureTag"
# include_fields = ["name", "state"]
#
#   name: string
#   state: string, enum: [EFFECTIVE, INEFFECTIVE], readOnly
#
# [types.field_overrides]
# name = { required = true }
# # state = { enum_type = "FirewallPolicyRuleSecureTagState" }

# --- FixedOrPercent (3 fields) ---
# Encapsulates numeric value that can be either absolute or relative.
# [[types]]
# schema = "FixedOrPercent"
# include_fields = ["calculated", "fixed", "percent"]
#
#   calculated: integer, format: int32, readOnly
#   fixed: integer, format: int32
#   percent: integer, format: int32

# --- FlexibleTimeRange (4 fields) ---
# Specifies a flexible time range with flexible start time and duration. It is possible to specify a c
# [[types]]
# schema = "FlexibleTimeRange"
# include_fields = ["maxDuration", "minDuration", "startTimeNotEarlierThan", "startTimeNotLaterThan"]
#
#   maxDuration: string, format: google-duration
#   minDuration: string, format: google-duration
#   startTimeNotEarlierThan: string, format: google-datetime
#   startTimeNotLaterThan: string, format: google-datetime

# --- ForwardingRule (38 fields) ---
# Represents a Forwarding Rule resource. Forwarding rule resources in Google Cloud can be either regio
# WARNING: format:"byte" fields: labelFingerprint, fingerprint
# [[types]]
# schema = "ForwardingRule"
# include_fields = ["IPAddress", "IPProtocol", "allPorts", "allowGlobalAccess", "allowPscGlobalAccess", "backendService", "baseForwardingRule", "creationTimestamp", "description", "externalManagedBackendBucketMigrationState", "externalManagedBackendBucketMigrationTestingPercentage", "fingerprint", "id", "ipCollection", "ipVersion", "isMirroringCollector", "kind", "labelFingerprint", "labels", "loadBalancingScheme", "metadataFilters", "name", "network", "networkTier", "noAutomateDnsZone", "portRange", "ports", "pscConnectionId", "pscConnectionStatus", "region", "selfLink", "selfLinkWithId", "serviceDirectoryRegistrations", "serviceLabel", "serviceName", "sourceIpRanges", "subnetwork", "target"]
#
#   IPAddress: string
#   IPProtocol: string, enum: [AH, ESP, ICMP, L3_DEFAULT, ... +3]
#   allPorts: boolean
#   allowGlobalAccess: boolean
#   allowPscGlobalAccess: boolean
#   backendService: string
#   baseForwardingRule: string, readOnly
#   creationTimestamp: string, readOnly
#   description: string
#   externalManagedBackendBucketMigrationState: string, enum: [PREPARE, TEST_ALL_TRAFFIC, TEST_BY_PERCENTAGE]
#   externalManagedBackendBucketMigrationTestingPercentage: number, format: float
#   fingerprint: string, format: byte
#   id: string, format: uint64
#   ipCollection: string
#   ipVersion: string, enum: [IPV4, IPV6, UNSPECIFIED_VERSION]
#   isMirroringCollector: boolean
#   kind: string, readOnly
#   labelFingerprint: string, format: byte
#   labels: map<string, string>
#   loadBalancingScheme: string, enum: [EXTERNAL, EXTERNAL_MANAGED, INTERNAL, INTERNAL_MANAGED, ... +2]
#   metadataFilters: array<MetadataFilter>
#   name: string
#   network: string
#   networkTier: string, enum: [FIXED_STANDARD, PREMIUM, STANDARD, STANDARD_OVERRIDES_FIXED_STANDARD]
#   noAutomateDnsZone: boolean
#   portRange: string
#   ports: array<string>
#   pscConnectionId: string, format: uint64
#   pscConnectionStatus: string, enum: [ACCEPTED, CLOSED, NEEDS_ATTENTION, PENDING, ... +2], readOnly
#   region: string, readOnly
#   selfLink: string
#   selfLinkWithId: string, readOnly
#   serviceDirectoryRegistrations: array<ForwardingRuleServiceDirectoryRegistration>
#   serviceLabel: string
#   serviceName: string
#   sourceIpRanges: array<string>
#   subnetwork: string
#   target: string
#
# [types.field_overrides]
# name = { required = true }
# labelFingerprint = { format = "bytes" }
# fingerprint = { format = "bytes" }
# # pscConnectionStatus = { enum_type = "ForwardingRulePscConnectionStatus" }
# # externalManagedBackendBucketMigrationState = { enum_type = "ForwardingRuleExternalManagedBackendBucketMigrationState" }
# # networkTier = { enum_type = "ForwardingRuleNetworkTier" }
# # IPProtocol = { enum_type = "ForwardingRuleIPProtocol" }
# # loadBalancingScheme = { enum_type = "ForwardingRuleLoadBalancingScheme" }
# # ipVersion = { enum_type = "ForwardingRuleIpVersion" }

# --- ForwardingRuleAggregatedList (7 fields) ---
# [[types]]
# schema = "ForwardingRuleAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, ForwardingRulesScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- ForwardingRuleList (6 fields) ---
# Contains a list of ForwardingRule resources.
# [[types]]
# schema = "ForwardingRuleList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<ForwardingRule>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- ForwardingRuleReference (1 fields) ---
# [[types]]
# schema = "ForwardingRuleReference"
# include_fields = ["forwardingRule"]
#
#   forwardingRule: string

# --- ForwardingRuleServiceDirectoryRegistration (3 fields) ---
# Describes the auto-registration of the forwarding rule to Service Directory. The region and project 
# [[types]]
# schema = "ForwardingRuleServiceDirectoryRegistration"
# include_fields = ["namespace", "service", "serviceDirectoryRegion"]
#
#   namespace: string
#   service: string
#   serviceDirectoryRegion: string

# --- ForwardingRulesScopedList (2 fields) ---
# [[types]]
# schema = "ForwardingRulesScopedList"
# include_fields = ["forwardingRules", "warning"]
#
#   forwardingRules: array<ForwardingRule>
#   warning: object

# --- FutureReservation (25 fields) ---
# [[types]]
# schema = "FutureReservation"
# include_fields = ["aggregateReservation", "autoCreatedReservationsDeleteTime", "autoCreatedReservationsDuration", "autoDeleteAutoCreatedReservations", "commitmentInfo", "creationTimestamp", "deploymentType", "description", "enableEmergentMaintenance", "id", "kind", "name", "namePrefix", "planningStatus", "reservationMode", "reservationName", "schedulingType", "selfLink", "selfLinkWithId", "shareSettings", "specificReservationRequired", "specificSkuProperties", "status", "timeWindow", "zone"]
#
#   aggregateReservation: $ref: AllocationAggregateReservation
#   autoCreatedReservationsDeleteTime: string
#   autoCreatedReservationsDuration: $ref: Duration
#   autoDeleteAutoCreatedReservations: boolean
#   commitmentInfo: $ref: FutureReservationCommitmentInfo
#   creationTimestamp: string, readOnly
#   deploymentType: string, enum: [DENSE, DEPLOYMENT_TYPE_UNSPECIFIED]
#   description: string
#   enableEmergentMaintenance: boolean
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   name: string
#   namePrefix: string
#   planningStatus: string, enum: [DRAFT, PLANNING_STATUS_UNSPECIFIED, SUBMITTED]
#   reservationMode: string, enum: [CALENDAR, DEFAULT, RESERVATION_MODE_UNSPECIFIED]
#   reservationName: string
#   schedulingType: string, enum: [GROUPED, GROUP_MAINTENANCE_TYPE_UNSPECIFIED, INDEPENDENT]
#   selfLink: string, readOnly
#   selfLinkWithId: string, readOnly
#   shareSettings: $ref: ShareSettings
#   specificReservationRequired: boolean
#   specificSkuProperties: $ref: FutureReservationSpecificSKUProperties
#   status: $ref: FutureReservationStatus, readOnly
#   timeWindow: $ref: FutureReservationTimeWindow
#   zone: string, readOnly
#
# [types.field_overrides]
# name = { required = true }
# # schedulingType = { enum_type = "FutureReservationSchedulingType" }
# # deploymentType = { enum_type = "FutureReservationDeploymentType" }
# # reservationMode = { enum_type = "FutureReservationReservationMode" }
# # planningStatus = { enum_type = "FutureReservationPlanningStatus" }

# --- FutureReservationCommitmentInfo (3 fields) ---
# [[types]]
# schema = "FutureReservationCommitmentInfo"
# include_fields = ["commitmentName", "commitmentPlan", "previousCommitmentTerms"]
#
#   commitmentName: string
#   commitmentPlan: string, enum: [INVALID, THIRTY_SIX_MONTH, TWELVE_MONTH]
#   previousCommitmentTerms: string, enum: [EXTEND, PREVIOUSCOMMITMENTTERM_UNSPECIFIED]
#
# [types.field_overrides]
# # commitmentPlan = { enum_type = "FutureReservationCommitmentInfoCommitmentPlan" }
# # previousCommitmentTerms = { enum_type = "FutureReservationCommitmentInfoPreviousCommitmentTerms" }

# --- FutureReservationSpecificSKUProperties (3 fields) ---
# [[types]]
# schema = "FutureReservationSpecificSKUProperties"
# include_fields = ["instanceProperties", "sourceInstanceTemplate", "totalCount"]
#
#   instanceProperties: $ref: AllocationSpecificSKUAllocationReservedInstanceProperties
#   sourceInstanceTemplate: string
#   totalCount: string, format: int64

# --- FutureReservationStatus (8 fields) ---
# [Output only] Represents status related to the future reservation.
# [[types]]
# schema = "FutureReservationStatus"
# include_fields = ["amendmentStatus", "autoCreatedReservations", "existingMatchingUsageInfo", "fulfilledCount", "lastKnownGoodState", "lockTime", "procurementStatus", "specificSkuProperties"]
#
#   amendmentStatus: string, enum: [AMENDMENT_APPROVED, AMENDMENT_DECLINED, AMENDMENT_IN_REVIEW, AMENDMENT_STATUS_UNSPECIFIED], readOnly
#   autoCreatedReservations: array<string>, readOnly
#   existingMatchingUsageInfo: $ref: FutureReservationStatusExistingMatchingUsageInfo, readOnly
#   fulfilledCount: string, format: int64, readOnly
#   lastKnownGoodState: $ref: FutureReservationStatusLastKnownGoodState, readOnly
#   lockTime: string, readOnly
#   procurementStatus: string, enum: [APPROVED, CANCELLED, COMMITTED, DECLINED, ... +9], readOnly
#   specificSkuProperties: $ref: FutureReservationStatusSpecificSKUProperties
#
# [types.field_overrides]
# # amendmentStatus = { enum_type = "FutureReservationStatusAmendmentStatus" }
# # procurementStatus = { enum_type = "FutureReservationStatusProcurementStatus" }

# --- FutureReservationStatusExistingMatchingUsageInfo (2 fields) ---
# [Output Only] Represents the existing matching usage for the future reservation.
# [[types]]
# schema = "FutureReservationStatusExistingMatchingUsageInfo"
# include_fields = ["count", "timestamp"]
#
#   count: string, format: int64, readOnly
#   timestamp: string, readOnly

# --- FutureReservationStatusLastKnownGoodState (6 fields) ---
# The state that the future reservation will be reverted to should the amendment be declined.
# [[types]]
# schema = "FutureReservationStatusLastKnownGoodState"
# include_fields = ["description", "existingMatchingUsageInfo", "futureReservationSpecs", "lockTime", "namePrefix", "procurementStatus"]
#
#   description: string, readOnly
#   existingMatchingUsageInfo: $ref: FutureReservationStatusExistingMatchingUsageInfo, readOnly
#   futureReservationSpecs: $ref: FutureReservationStatusLastKnownGoodStateFutureReservationSpecs, readOnly
#   lockTime: string, readOnly
#   namePrefix: string, readOnly
#   procurementStatus: string, enum: [APPROVED, CANCELLED, COMMITTED, DECLINED, ... +9], readOnly
#
# [types.field_overrides]
# # procurementStatus = { enum_type = "FutureReservationStatusLastKnownGoodStateProcurementStatus" }

# --- FutureReservationStatusLastKnownGoodStateFutureReservationSpecs (3 fields) ---
# The properties of the last known good state for the Future Reservation.
# [[types]]
# schema = "FutureReservationStatusLastKnownGoodStateFutureReservationSpecs"
# include_fields = ["shareSettings", "specificSkuProperties", "timeWindow"]
#
#   shareSettings: $ref: ShareSettings, readOnly
#   specificSkuProperties: $ref: FutureReservationSpecificSKUProperties, readOnly
#   timeWindow: $ref: FutureReservationTimeWindow, readOnly

# --- FutureReservationStatusSpecificSKUProperties (1 fields) ---
# Properties to be set for the Future Reservation.
# [[types]]
# schema = "FutureReservationStatusSpecificSKUProperties"
# include_fields = ["sourceInstanceTemplateId"]
#
#   sourceInstanceTemplateId: string

# --- FutureReservationTimeWindow (3 fields) ---
# [[types]]
# schema = "FutureReservationTimeWindow"
# include_fields = ["duration", "endTime", "startTime"]
#
#   duration: $ref: Duration
#   endTime: string
#   startTime: string

# --- FutureReservationsAggregatedListResponse (8 fields) ---
# Contains a list of future reservations.
# [[types]]
# schema = "FutureReservationsAggregatedListResponse"
# include_fields = ["etag", "id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   etag: string
#   id: string
#   items: map<string, FutureReservationsScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- FutureReservationsListResponse (8 fields) ---
# [[types]]
# schema = "FutureReservationsListResponse"
# include_fields = ["etag", "id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   etag: string
#   id: string
#   items: array<FutureReservation>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- FutureReservationsScopedList (2 fields) ---
# [[types]]
# schema = "FutureReservationsScopedList"
# include_fields = ["futureReservations", "warning"]
#
#   futureReservations: array<FutureReservation>
#   warning: object

# --- FutureResourcesRecommendation (6 fields) ---
# Recommendation for single resources specification, to be created in the future.
# [[types]]
# schema = "FutureResourcesRecommendation"
# include_fields = ["endTime", "location", "otherLocations", "recommendationId", "recommendationType", "startTime"]
#
#   endTime: string, format: google-datetime
#   location: string
#   otherLocations: map<string, FutureResourcesRecommendationOtherLocation>
#   recommendationId: string
#   recommendationType: string, enum: [FUTURE_RESERVATION, RECOMMENDATION_TYPE_UNSPECIFIED]
#   startTime: string, format: google-datetime
#
# [types.field_overrides]
# # recommendationType = { enum_type = "FutureResourcesRecommendationRecommendationType" }

# --- FutureResourcesRecommendationOtherLocation (2 fields) ---
# Information about recommendation status for locations that were allowed but not used by the response
# [[types]]
# schema = "FutureResourcesRecommendationOtherLocation"
# include_fields = ["details", "status"]
#
#   details: string
#   status: string, enum: [CONDITIONS_NOT_MET, NOT_SUPPORTED, NO_CAPACITY, OTHER_LOCATION_STATUS_UNDEFINED, RECOMMENDED]
#
# [types.field_overrides]
# # status = { enum_type = "FutureResourcesRecommendationOtherLocationStatus" }

# --- FutureResourcesSpec (4 fields) ---
# Specification of resources to be created at some time in the future within an optionally specified s
# [[types]]
# schema = "FutureResourcesSpec"
# include_fields = ["deploymentType", "locationPolicy", "targetResources", "timeRangeSpec"]
#
#   deploymentType: string, enum: [DENSE, DEPLOYMENT_TYPE_UNSPECIFIED]
#   locationPolicy: $ref: FutureResourcesSpecLocationPolicy
#   targetResources: $ref: FutureResourcesSpecTargetResources
#   timeRangeSpec: $ref: FlexibleTimeRange
#
# [types.field_overrides]
# # deploymentType = { enum_type = "FutureResourcesSpecDeploymentType" }

# --- FutureResourcesSpecAggregateResources (3 fields) ---
# [[types]]
# schema = "FutureResourcesSpecAggregateResources"
# include_fields = ["acceleratorCount", "vmFamily", "workloadType"]
#
#   acceleratorCount: string, format: int64
#   vmFamily: string, enum: [VM_FAMILY_CLOUD_TPU_DEVICE_CT3, VM_FAMILY_CLOUD_TPU_LITE_DEVICE_CT5L, VM_FAMILY_CLOUD_TPU_LITE_POD_SLICE_CT5LP, VM_FAMILY_CLOUD_TPU_LITE_POD_SLICE_CT6E, ... +4]
#   workloadType: string, enum: [BATCH, SERVING, UNSPECIFIED]
#
# [types.field_overrides]
# # vmFamily = { enum_type = "FutureResourcesSpecAggregateResourcesVmFamily" }
# # workloadType = { enum_type = "FutureResourcesSpecAggregateResourcesWorkloadType" }

# --- FutureResourcesSpecLocalSsdPartition (2 fields) ---
# [[types]]
# schema = "FutureResourcesSpecLocalSsdPartition"
# include_fields = ["diskInterface", "diskSizeGb"]
#
#   diskInterface: string, enum: [NVME, SCSI]
#   diskSizeGb: string, format: int64
#
# [types.field_overrides]
# # diskInterface = { enum_type = "FutureResourcesSpecLocalSsdPartitionDiskInterface" }

# --- FutureResourcesSpecLocationPolicy (1 fields) ---
# Specification of locations to create resources in.
# [[types]]
# schema = "FutureResourcesSpecLocationPolicy"
# include_fields = ["locations"]
#
#   locations: map<string, FutureResourcesSpecLocationPolicyLocation>

# --- FutureResourcesSpecLocationPolicyLocation (1 fields) ---
# Preference for a single specified location.
# [[types]]
# schema = "FutureResourcesSpecLocationPolicyLocation"
# include_fields = ["preference"]
#
#   preference: string, enum: [ALLOW, DENY, PREFERENCE_UNSPECIFIED]
#
# [types.field_overrides]
# # preference = { enum_type = "FutureResourcesSpecLocationPolicyLocationPreference" }

# --- FutureResourcesSpecSpecificSKUResources (3 fields) ---
# [[types]]
# schema = "FutureResourcesSpecSpecificSKUResources"
# include_fields = ["instanceCount", "localSsdPartitions", "machineType"]
#
#   instanceCount: string, format: int64
#   localSsdPartitions: array<FutureResourcesSpecLocalSsdPartition>
#   machineType: string

# --- FutureResourcesSpecTargetResources (2 fields) ---
# Specification of reserved resources.
# [[types]]
# schema = "FutureResourcesSpecTargetResources"
# include_fields = ["aggregateResources", "specificSkuResources"]
#
#   aggregateResources: $ref: FutureResourcesSpecAggregateResources
#   specificSkuResources: $ref: FutureResourcesSpecSpecificSKUResources

# --- GRPCHealthCheck (4 fields) ---
# [[types]]
# schema = "GRPCHealthCheck"
# include_fields = ["grpcServiceName", "port", "portName", "portSpecification"]
#
#   grpcServiceName: string
#   port: integer, format: int32
#   portName: string
#   portSpecification: string, enum: [USE_FIXED_PORT, USE_NAMED_PORT, USE_SERVING_PORT]
#
# [types.field_overrides]
# # portSpecification = { enum_type = "GRPCHealthCheckPortSpecification" }

# --- GRPCTLSHealthCheck (3 fields) ---
# [[types]]
# schema = "GRPCTLSHealthCheck"
# include_fields = ["grpcServiceName", "port", "portSpecification"]
#
#   grpcServiceName: string
#   port: integer, format: int32
#   portSpecification: string, enum: [USE_FIXED_PORT, USE_NAMED_PORT, USE_SERVING_PORT]
#
# [types.field_overrides]
# # portSpecification = { enum_type = "GRPCTLSHealthCheckPortSpecification" }

# --- GlobalAddressesMoveRequest (2 fields) ---
# [[types]]
# schema = "GlobalAddressesMoveRequest"
# include_fields = ["description", "destinationAddress"]
#
#   description: string
#   destinationAddress: string

# --- GlobalNetworkEndpointGroupsAttachEndpointsRequest (1 fields) ---
# [[types]]
# schema = "GlobalNetworkEndpointGroupsAttachEndpointsRequest"
# include_fields = ["networkEndpoints"]
#
#   networkEndpoints: array<NetworkEndpoint>

# --- GlobalNetworkEndpointGroupsDetachEndpointsRequest (1 fields) ---
# [[types]]
# schema = "GlobalNetworkEndpointGroupsDetachEndpointsRequest"
# include_fields = ["networkEndpoints"]
#
#   networkEndpoints: array<NetworkEndpoint>

# --- GlobalOrganizationSetPolicyRequest (3 fields) ---
# WARNING: format:"byte" fields: etag
# [[types]]
# schema = "GlobalOrganizationSetPolicyRequest"
# include_fields = ["bindings", "etag", "policy"]
#
#   bindings: array<Binding>
#   etag: string, format: byte
#   policy: $ref: Policy
#
# [types.field_overrides]
# etag = { format = "bytes" }

# --- GlobalSetLabelsRequest (2 fields) ---
# WARNING: format:"byte" fields: labelFingerprint
# [[types]]
# schema = "GlobalSetLabelsRequest"
# include_fields = ["labelFingerprint", "labels"]
#
#   labelFingerprint: string, format: byte
#   labels: map<string, string>
#
# [types.field_overrides]
# labelFingerprint = { format = "bytes" }

# --- GlobalSetPolicyRequest (3 fields) ---
# WARNING: format:"byte" fields: etag
# [[types]]
# schema = "GlobalSetPolicyRequest"
# include_fields = ["bindings", "etag", "policy"]
#
#   bindings: array<Binding>
#   etag: string, format: byte
#   policy: $ref: Policy
#
# [types.field_overrides]
# etag = { format = "bytes" }

# --- GroupMaintenanceInfo (8 fields) ---
# Maintenance Info for ReservationBlocks.
# [[types]]
# schema = "GroupMaintenanceInfo"
# include_fields = ["instanceMaintenanceOngoingCount", "instanceMaintenancePendingCount", "maintenanceOngoingCount", "maintenancePendingCount", "schedulingType", "subblockInfraMaintenanceOngoingCount", "subblockInfraMaintenancePendingCount", "upcomingGroupMaintenance"]
#
#   instanceMaintenanceOngoingCount: integer, format: int32
#   instanceMaintenancePendingCount: integer, format: int32
#   maintenanceOngoingCount: integer, format: int32
#   maintenancePendingCount: integer, format: int32
#   schedulingType: string, enum: [GROUPED, GROUP_MAINTENANCE_TYPE_UNSPECIFIED, INDEPENDENT]
#   subblockInfraMaintenanceOngoingCount: integer, format: int32
#   subblockInfraMaintenancePendingCount: integer, format: int32
#   upcomingGroupMaintenance: $ref: UpcomingMaintenance
#
# [types.field_overrides]
# # schedulingType = { enum_type = "GroupMaintenanceInfoSchedulingType" }

# --- GuestAttributes (6 fields) ---
# A guest attributes entry.
# [[types]]
# schema = "GuestAttributes"
# include_fields = ["kind", "queryPath", "queryValue", "selfLink", "variableKey", "variableValue"]
#
#   kind: string, readOnly
#   queryPath: string
#   queryValue: $ref: GuestAttributesValue, readOnly
#   selfLink: string, readOnly
#   variableKey: string
#   variableValue: string, readOnly

# --- GuestAttributesEntry (3 fields) ---
# A guest attributes namespace/key/value entry.
# [[types]]
# schema = "GuestAttributesEntry"
# include_fields = ["key", "namespace", "value"]
#
#   key: string
#   namespace: string
#   value: string

# --- GuestAttributesValue (1 fields) ---
# Array of guest attribute namespace/key/value tuples.
# [[types]]
# schema = "GuestAttributesValue"
# include_fields = ["items"]
#
#   items: array<GuestAttributesEntry>

# --- GuestOsFeature (1 fields) [IN MANIFEST] ---
# Guest OS features.
# WARNING: reserved words: type
# [[types]]
# schema = "GuestOsFeature"
# include_fields = ["type"]
#
#   type: string, enum: [BARE_METAL_LINUX_COMPATIBLE, FEATURE_TYPE_UNSPECIFIED, GVNIC, IDPF, ... +11], RESERVED_WORD
#
# [types.field_overrides]
# type = { rust_name = "type_value", serde_rename = "type" }
# # type = { enum_type = "GuestOsFeatureType" }

# --- HTTP2HealthCheck (7 fields) ---
# [[types]]
# schema = "HTTP2HealthCheck"
# include_fields = ["host", "port", "portName", "portSpecification", "proxyHeader", "requestPath", "response"]
#
#   host: string
#   port: integer, format: int32
#   portName: string
#   portSpecification: string, enum: [USE_FIXED_PORT, USE_NAMED_PORT, USE_SERVING_PORT]
#   proxyHeader: string, enum: [NONE, PROXY_V1]
#   requestPath: string
#   response: string
#
# [types.field_overrides]
# # proxyHeader = { enum_type = "HTTP2HealthCheckProxyHeader" }
# # portSpecification = { enum_type = "HTTP2HealthCheckPortSpecification" }

# --- HTTPHealthCheck (7 fields) ---
# [[types]]
# schema = "HTTPHealthCheck"
# include_fields = ["host", "port", "portName", "portSpecification", "proxyHeader", "requestPath", "response"]
#
#   host: string
#   port: integer, format: int32
#   portName: string
#   portSpecification: string, enum: [USE_FIXED_PORT, USE_NAMED_PORT, USE_SERVING_PORT]
#   proxyHeader: string, enum: [NONE, PROXY_V1]
#   requestPath: string
#   response: string
#
# [types.field_overrides]
# # portSpecification = { enum_type = "HTTPHealthCheckPortSpecification" }
# # proxyHeader = { enum_type = "HTTPHealthCheckProxyHeader" }

# --- HTTPSHealthCheck (7 fields) ---
# [[types]]
# schema = "HTTPSHealthCheck"
# include_fields = ["host", "port", "portName", "portSpecification", "proxyHeader", "requestPath", "response"]
#
#   host: string
#   port: integer, format: int32
#   portName: string
#   portSpecification: string, enum: [USE_FIXED_PORT, USE_NAMED_PORT, USE_SERVING_PORT]
#   proxyHeader: string, enum: [NONE, PROXY_V1]
#   requestPath: string
#   response: string
#
# [types.field_overrides]
# # proxyHeader = { enum_type = "HTTPSHealthCheckProxyHeader" }
# # portSpecification = { enum_type = "HTTPSHealthCheckPortSpecification" }

# --- HealthCheck (21 fields) ---
# Represents a health check resource. Google Compute Engine has two health check resources: * [Regiona
# WARNING: reserved words: type
# [[types]]
# schema = "HealthCheck"
# include_fields = ["checkIntervalSec", "creationTimestamp", "description", "grpcHealthCheck", "grpcTlsHealthCheck", "healthyThreshold", "http2HealthCheck", "httpHealthCheck", "httpsHealthCheck", "id", "kind", "logConfig", "name", "region", "selfLink", "sourceRegions", "sslHealthCheck", "tcpHealthCheck", "timeoutSec", "type", "unhealthyThreshold"]
#
#   checkIntervalSec: integer, format: int32
#   creationTimestamp: string, readOnly
#   description: string
#   grpcHealthCheck: $ref: GRPCHealthCheck
#   grpcTlsHealthCheck: $ref: GRPCTLSHealthCheck
#   healthyThreshold: integer, format: int32
#   http2HealthCheck: $ref: HTTP2HealthCheck
#   httpHealthCheck: $ref: HTTPHealthCheck
#   httpsHealthCheck: $ref: HTTPSHealthCheck
#   id: string, format: uint64
#   kind: string, readOnly
#   logConfig: $ref: HealthCheckLogConfig
#   name: string
#   region: string, readOnly
#   selfLink: string
#   sourceRegions: array<string>
#   sslHealthCheck: $ref: SSLHealthCheck
#   tcpHealthCheck: $ref: TCPHealthCheck
#   timeoutSec: integer, format: int32
#   type: string, enum: [GRPC, GRPC_WITH_TLS, HTTP, HTTP2, ... +4], RESERVED_WORD
#   unhealthyThreshold: integer, format: int32
#
# [types.field_overrides]
# name = { required = true }
# type = { rust_name = "type_value", serde_rename = "type" }
# # type = { enum_type = "HealthCheckType" }

# --- HealthCheckList (6 fields) ---
# Contains a list of HealthCheck resources.
# [[types]]
# schema = "HealthCheckList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<HealthCheck>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- HealthCheckLogConfig (1 fields) ---
# Configuration of logging on a health check. If logging is enabled, logs will be exported to Stackdri
# [[types]]
# schema = "HealthCheckLogConfig"
# include_fields = ["enable"]
#
#   enable: boolean

# --- HealthCheckReference (1 fields) ---
# A full or valid partial URL to a health check. For example, the following are valid URLs: - https://
# [[types]]
# schema = "HealthCheckReference"
# include_fields = ["healthCheck"]
#
#   healthCheck: string

# --- HealthCheckService (12 fields) ---
# Represents a Health-Check as a Service resource.
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "HealthCheckService"
# include_fields = ["creationTimestamp", "description", "fingerprint", "healthChecks", "healthStatusAggregationPolicy", "id", "kind", "name", "networkEndpointGroups", "notificationEndpoints", "region", "selfLink"]
#
#   creationTimestamp: string, readOnly
#   description: string
#   fingerprint: string, format: byte
#   healthChecks: array<string>
#   healthStatusAggregationPolicy: string, enum: [AND, NO_AGGREGATION]
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   name: string
#   networkEndpointGroups: array<string>
#   notificationEndpoints: array<string>
#   region: string, readOnly
#   selfLink: string, readOnly
#
# [types.field_overrides]
# name = { required = true }
# fingerprint = { format = "bytes" }
# # healthStatusAggregationPolicy = { enum_type = "HealthCheckServiceHealthStatusAggregationPolicy" }

# --- HealthCheckServiceReference (1 fields) ---
# A full or valid partial URL to a health check service. For example, the following are valid URLs: - 
# [[types]]
# schema = "HealthCheckServiceReference"
# include_fields = ["healthCheckService"]
#
#   healthCheckService: string

# --- HealthCheckServicesList (6 fields) ---
# [[types]]
# schema = "HealthCheckServicesList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string, readOnly
#   items: array<HealthCheckService>, readOnly
#   kind: string, readOnly
#   nextPageToken: string, readOnly
#   selfLink: string, readOnly
#   warning: object

# --- HealthChecksAggregatedList (7 fields) ---
# [[types]]
# schema = "HealthChecksAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, HealthChecksScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- HealthChecksScopedList (2 fields) ---
# [[types]]
# schema = "HealthChecksScopedList"
# include_fields = ["healthChecks", "warning"]
#
#   healthChecks: array<HealthCheck>
#   warning: object

# --- HealthStatus (11 fields) ---
# [[types]]
# schema = "HealthStatus"
# include_fields = ["annotations", "forwardingRule", "forwardingRuleIp", "healthState", "instance", "ipAddress", "ipv6Address", "ipv6HealthState", "port", "weight", "weightError"]
#
#   annotations: map<string, string>
#   forwardingRule: string
#   forwardingRuleIp: string
#   healthState: string, enum: [HEALTHY, UNHEALTHY]
#   instance: string
#   ipAddress: string
#   ipv6Address: string
#   ipv6HealthState: string, enum: [HEALTHY, UNHEALTHY]
#   port: integer, format: int32
#   weight: string
#   weightError: string, enum: [INVALID_WEIGHT, MISSING_WEIGHT, UNAVAILABLE_WEIGHT, WEIGHT_NONE]
#
# [types.field_overrides]
# # ipv6HealthState = { enum_type = "HealthStatusIpv6HealthState" }
# # healthState = { enum_type = "HealthStatusHealthState" }
# # weightError = { enum_type = "HealthStatusWeightError" }

# --- HealthStatusForNetworkEndpoint (6 fields) ---
# [[types]]
# schema = "HealthStatusForNetworkEndpoint"
# include_fields = ["backendService", "forwardingRule", "healthCheck", "healthCheckService", "healthState", "ipv6HealthState"]
#
#   backendService: $ref: BackendServiceReference
#   forwardingRule: $ref: ForwardingRuleReference
#   healthCheck: $ref: HealthCheckReference
#   healthCheckService: $ref: HealthCheckServiceReference
#   healthState: string, enum: [DRAINING, HEALTHY, UNHEALTHY, UNKNOWN]
#   ipv6HealthState: string, enum: [DRAINING, HEALTHY, UNHEALTHY, UNKNOWN]
#
# [types.field_overrides]
# # healthState = { enum_type = "HealthStatusForNetworkEndpointHealthState" }
# # ipv6HealthState = { enum_type = "HealthStatusForNetworkEndpointIpv6HealthState" }

# --- Help (1 fields) ---
# Provides links to documentation or for performing an out of band action. For example, if a quota che
# [[types]]
# schema = "Help"
# include_fields = ["links"]
#
#   links: array<HelpLink>

# --- HelpLink (2 fields) ---
# Describes a URL link.
# [[types]]
# schema = "HelpLink"
# include_fields = ["description", "url"]
#
#   description: string
#   url: string

# --- HostRule (3 fields) ---
# UrlMaps A host-matching rule for a URL. If matched, will use the namedPathMatcher to select the Back
# [[types]]
# schema = "HostRule"
# include_fields = ["description", "hosts", "pathMatcher"]
#
#   description: string
#   hosts: array<string>
#   pathMatcher: string

# --- HttpFaultAbort (2 fields) ---
# Specification for how requests are aborted as part of fault injection.
# [[types]]
# schema = "HttpFaultAbort"
# include_fields = ["httpStatus", "percentage"]
#
#   httpStatus: integer, format: uint32
#   percentage: number, format: double

# --- HttpFaultDelay (2 fields) ---
# Specifies the delay introduced by the load balancer before forwarding the request to the backend ser
# [[types]]
# schema = "HttpFaultDelay"
# include_fields = ["fixedDelay", "percentage"]
#
#   fixedDelay: $ref: Duration
#   percentage: number, format: double

# --- HttpFaultInjection (2 fields) ---
# The specification for fault injection introduced into traffic to test the resiliency of clients to b
# [[types]]
# schema = "HttpFaultInjection"
# include_fields = ["abort", "delay"]
#
#   abort: $ref: HttpFaultAbort
#   delay: $ref: HttpFaultDelay

# --- HttpHeaderAction (4 fields) ---
# The request and response header transformations that take effect before the request is passed along 
# [[types]]
# schema = "HttpHeaderAction"
# include_fields = ["requestHeadersToAdd", "requestHeadersToRemove", "responseHeadersToAdd", "responseHeadersToRemove"]
#
#   requestHeadersToAdd: array<HttpHeaderOption>
#   requestHeadersToRemove: array<string>
#   responseHeadersToAdd: array<HttpHeaderOption>
#   responseHeadersToRemove: array<string>

# --- HttpHeaderMatch (8 fields) ---
# matchRule criteria for request header matches.
# [[types]]
# schema = "HttpHeaderMatch"
# include_fields = ["exactMatch", "headerName", "invertMatch", "prefixMatch", "presentMatch", "rangeMatch", "regexMatch", "suffixMatch"]
#
#   exactMatch: string
#   headerName: string
#   invertMatch: boolean
#   prefixMatch: string
#   presentMatch: boolean
#   rangeMatch: $ref: Int64RangeMatch
#   regexMatch: string
#   suffixMatch: string

# --- HttpHeaderOption (3 fields) ---
# Specification determining how headers are added to requests or responses.
# [[types]]
# schema = "HttpHeaderOption"
# include_fields = ["headerName", "headerValue", "replace"]
#
#   headerName: string
#   headerValue: string
#   replace: boolean

# --- HttpHealthCheck (13 fields) ---
# Represents a legacy HTTP Health Check resource. Legacy HTTP health checks are now only required by t
# [[types]]
# schema = "HttpHealthCheck"
# include_fields = ["checkIntervalSec", "creationTimestamp", "description", "healthyThreshold", "host", "id", "kind", "name", "port", "requestPath", "selfLink", "timeoutSec", "unhealthyThreshold"]
#
#   checkIntervalSec: integer, format: int32
#   creationTimestamp: string
#   description: string
#   healthyThreshold: integer, format: int32
#   host: string
#   id: string, format: uint64
#   kind: string, readOnly
#   name: string
#   port: integer, format: int32
#   requestPath: string
#   selfLink: string
#   timeoutSec: integer, format: int32
#   unhealthyThreshold: integer, format: int32
#
# [types.field_overrides]
# name = { required = true }

# --- HttpHealthCheckList (6 fields) ---
# Contains a list of HttpHealthCheck resources.
# [[types]]
# schema = "HttpHealthCheckList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<HttpHealthCheck>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- HttpQueryParameterMatch (4 fields) ---
# HttpRouteRuleMatch criteria for a request's query parameter.
# [[types]]
# schema = "HttpQueryParameterMatch"
# include_fields = ["exactMatch", "name", "presentMatch", "regexMatch"]
#
#   exactMatch: string
#   name: string
#   presentMatch: boolean
#   regexMatch: string
#
# [types.field_overrides]
# name = { required = true }

# --- HttpRedirectAction (6 fields) ---
# Specifies settings for an HTTP redirect.
# [[types]]
# schema = "HttpRedirectAction"
# include_fields = ["hostRedirect", "httpsRedirect", "pathRedirect", "prefixRedirect", "redirectResponseCode", "stripQuery"]
#
#   hostRedirect: string
#   httpsRedirect: boolean
#   pathRedirect: string
#   prefixRedirect: string
#   redirectResponseCode: string, enum: [FOUND, MOVED_PERMANENTLY_DEFAULT, PERMANENT_REDIRECT, SEE_OTHER, TEMPORARY_REDIRECT]
#   stripQuery: boolean
#
# [types.field_overrides]
# # redirectResponseCode = { enum_type = "HttpRedirectActionRedirectResponseCode" }

# --- HttpRetryPolicy (3 fields) ---
# The retry policy associates with HttpRouteRule
# [[types]]
# schema = "HttpRetryPolicy"
# include_fields = ["numRetries", "perTryTimeout", "retryConditions"]
#
#   numRetries: integer, format: uint32
#   perTryTimeout: $ref: Duration
#   retryConditions: array<string>

# --- HttpRouteAction (8 fields) ---
# [[types]]
# schema = "HttpRouteAction"
# include_fields = ["corsPolicy", "faultInjectionPolicy", "maxStreamDuration", "requestMirrorPolicy", "retryPolicy", "timeout", "urlRewrite", "weightedBackendServices"]
#
#   corsPolicy: $ref: CorsPolicy
#   faultInjectionPolicy: $ref: HttpFaultInjection
#   maxStreamDuration: $ref: Duration
#   requestMirrorPolicy: $ref: RequestMirrorPolicy
#   retryPolicy: $ref: HttpRetryPolicy
#   timeout: $ref: Duration
#   urlRewrite: $ref: UrlRewrite
#   weightedBackendServices: array<WeightedBackendService>

# --- HttpRouteRule (8 fields) ---
# The HttpRouteRule setting specifies how to match an HTTP request and the corresponding routing actio
# [[types]]
# schema = "HttpRouteRule"
# include_fields = ["customErrorResponsePolicy", "description", "headerAction", "matchRules", "priority", "routeAction", "service", "urlRedirect"]
#
#   customErrorResponsePolicy: $ref: CustomErrorResponsePolicy
#   description: string
#   headerAction: $ref: HttpHeaderAction
#   matchRules: array<HttpRouteRuleMatch>
#   priority: integer, format: int32
#   routeAction: $ref: HttpRouteAction
#   service: string
#   urlRedirect: $ref: HttpRedirectAction

# --- HttpRouteRuleMatch (8 fields) ---
# HttpRouteRuleMatch specifies a set of criteria for matching requests to an HttpRouteRule. All specif
# [[types]]
# schema = "HttpRouteRuleMatch"
# include_fields = ["fullPathMatch", "headerMatches", "ignoreCase", "metadataFilters", "pathTemplateMatch", "prefixMatch", "queryParameterMatches", "regexMatch"]
#
#   fullPathMatch: string
#   headerMatches: array<HttpHeaderMatch>
#   ignoreCase: boolean
#   metadataFilters: array<MetadataFilter>
#   pathTemplateMatch: string
#   prefixMatch: string
#   queryParameterMatches: array<HttpQueryParameterMatch>
#   regexMatch: string

# --- HttpsHealthCheck (13 fields) ---
# Represents a legacy HTTPS Health Check resource. Legacy HTTPS health checks have been deprecated. If
# [[types]]
# schema = "HttpsHealthCheck"
# include_fields = ["checkIntervalSec", "creationTimestamp", "description", "healthyThreshold", "host", "id", "kind", "name", "port", "requestPath", "selfLink", "timeoutSec", "unhealthyThreshold"]
#
#   checkIntervalSec: integer, format: int32
#   creationTimestamp: string
#   description: string
#   healthyThreshold: integer, format: int32
#   host: string
#   id: string, format: uint64
#   kind: string, readOnly
#   name: string
#   port: integer, format: int32
#   requestPath: string
#   selfLink: string
#   timeoutSec: integer, format: int32
#   unhealthyThreshold: integer, format: int32
#
# [types.field_overrides]
# name = { required = true }

# --- HttpsHealthCheckList (6 fields) ---
# Contains a list of HttpsHealthCheck resources.
# [[types]]
# schema = "HttpsHealthCheckList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<HttpsHealthCheck>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- Image (35 fields) ---
# Represents an Image resource. You can use images to create boot disks for your VM instances. For mor
# WARNING: format:"byte" fields: labelFingerprint
# [[types]]
# schema = "Image"
# include_fields = ["architecture", "archiveSizeBytes", "creationTimestamp", "deprecated", "description", "diskSizeGb", "enableConfidentialCompute", "family", "guestOsFeatures", "id", "imageEncryptionKey", "kind", "labelFingerprint", "labels", "licenseCodes", "licenses", "name", "params", "rawDisk", "satisfiesPzi", "satisfiesPzs", "selfLink", "shieldedInstanceInitialState", "sourceDisk", "sourceDiskEncryptionKey", "sourceDiskId", "sourceImage", "sourceImageEncryptionKey", "sourceImageId", "sourceSnapshot", "sourceSnapshotEncryptionKey", "sourceSnapshotId", "sourceType", "status", "storageLocations"]
#
#   architecture: string, enum: [ARCHITECTURE_UNSPECIFIED, ARM64, X86_64]
#   archiveSizeBytes: string, format: int64
#   creationTimestamp: string, readOnly
#   deprecated: $ref: DeprecationStatus, readOnly
#   description: string
#   diskSizeGb: string, format: int64
#   enableConfidentialCompute: boolean, readOnly
#   family: string
#   guestOsFeatures: array<GuestOsFeature>
#   id: string, format: uint64, readOnly
#   imageEncryptionKey: $ref: CustomerEncryptionKey
#   kind: string, readOnly
#   labelFingerprint: string, format: byte
#   labels: map<string, string>
#   licenseCodes: array<string>
#   licenses: array<string>
#   name: string
#   params: $ref: ImageParams
#   rawDisk: object
#   satisfiesPzi: boolean, readOnly
#   satisfiesPzs: boolean, readOnly
#   selfLink: string, readOnly
#   shieldedInstanceInitialState: $ref: InitialStateConfig
#   sourceDisk: string
#   sourceDiskEncryptionKey: $ref: CustomerEncryptionKey
#   sourceDiskId: string, readOnly
#   sourceImage: string
#   sourceImageEncryptionKey: $ref: CustomerEncryptionKey
#   sourceImageId: string, readOnly
#   sourceSnapshot: string
#   sourceSnapshotEncryptionKey: $ref: CustomerEncryptionKey
#   sourceSnapshotId: string, readOnly
#   sourceType: string, enum: [RAW]
#   status: string, enum: [DELETING, FAILED, PENDING, READY], readOnly
#   storageLocations: array<string>
#
# [types.field_overrides]
# name = { required = true }
# labelFingerprint = { format = "bytes" }
# # architecture = { enum_type = "ImageArchitecture" }
# # sourceType = { enum_type = "ImageSourceType" }
# # status = { enum_type = "ImageStatus" }

# --- ImageFamilyView (1 fields) ---
# [[types]]
# schema = "ImageFamilyView"
# include_fields = ["image"]
#
#   image: $ref: Image

# --- ImageList (6 fields) ---
# Contains a list of images.
# [[types]]
# schema = "ImageList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<Image>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- ImageParams (1 fields) ---
# Additional image params.
# [[types]]
# schema = "ImageParams"
# include_fields = ["resourceManagerTags"]
#
#   resourceManagerTags: map<string, string>

# --- InitialStateConfig (4 fields) ---
# Initial State for shielded instance, these are public keys which are safe to store in public
# [[types]]
# schema = "InitialStateConfig"
# include_fields = ["dbs", "dbxs", "keks", "pk"]
#
#   dbs: array<FileContentBuffer>
#   dbxs: array<FileContentBuffer>
#   keks: array<FileContentBuffer>
#   pk: $ref: FileContentBuffer

# --- Instance (46 fields) [IN MANIFEST] ---
# Represents an Instance resource. An instance is a virtual machine that is hosted on Google Cloud Pla
# WARNING: format:"byte" fields: labelFingerprint, fingerprint
# [[types]]
# schema = "Instance"
# include_fields = ["advancedMachineFeatures", "canIpForward", "confidentialInstanceConfig", "cpuPlatform", "creationTimestamp", "deletionProtection", "description", "disks", "displayDevice", "fingerprint", "guestAccelerators", "hostname", "id", "instanceEncryptionKey", "keyRevocationActionType", "kind", "labelFingerprint", "labels", "lastStartTimestamp", "lastStopTimestamp", "lastSuspendedTimestamp", "machineType", "metadata", "minCpuPlatform", "name", "networkInterfaces", "networkPerformanceConfig", "params", "privateIpv6GoogleAccess", "reservationAffinity", "resourcePolicies", "resourceStatus", "satisfiesPzi", "satisfiesPzs", "scheduling", "selfLink", "serviceAccounts", "shieldedInstanceConfig", "shieldedInstanceIntegrityPolicy", "sourceMachineImage", "sourceMachineImageEncryptionKey", "startRestricted", "status", "statusMessage", "tags", "zone"]
#
#   advancedMachineFeatures: $ref: AdvancedMachineFeatures
#   canIpForward: boolean
#   confidentialInstanceConfig: $ref: ConfidentialInstanceConfig
#   cpuPlatform: string, readOnly
#   creationTimestamp: string, readOnly
#   deletionProtection: boolean
#   description: string
#   disks: array<AttachedDisk>
#   displayDevice: $ref: DisplayDevice
#   fingerprint: string, format: byte
#   guestAccelerators: array<AcceleratorConfig>
#   hostname: string
#   id: string, format: uint64, readOnly
#   instanceEncryptionKey: $ref: CustomerEncryptionKey
#   keyRevocationActionType: string, enum: [KEY_REVOCATION_ACTION_TYPE_UNSPECIFIED, NONE, STOP]
#   kind: string, readOnly
#   labelFingerprint: string, format: byte
#   labels: map<string, string>
#   lastStartTimestamp: string, readOnly
#   lastStopTimestamp: string, readOnly
#   lastSuspendedTimestamp: string, readOnly
#   machineType: string
#   metadata: $ref: Metadata
#   minCpuPlatform: string
#   name: string
#   networkInterfaces: array<NetworkInterface>
#   networkPerformanceConfig: $ref: NetworkPerformanceConfig
#   params: $ref: InstanceParams
#   privateIpv6GoogleAccess: string, enum: [ENABLE_BIDIRECTIONAL_ACCESS_TO_GOOGLE, ENABLE_OUTBOUND_VM_ACCESS_TO_GOOGLE, INHERIT_FROM_SUBNETWORK]
#   reservationAffinity: $ref: ReservationAffinity
#   resourcePolicies: array<string>
#   resourceStatus: $ref: ResourceStatus, readOnly
#   satisfiesPzi: boolean, readOnly
#   satisfiesPzs: boolean, readOnly
#   scheduling: $ref: Scheduling
#   selfLink: string, readOnly
#   serviceAccounts: array<ServiceAccount>
#   shieldedInstanceConfig: $ref: ShieldedInstanceConfig
#   shieldedInstanceIntegrityPolicy: $ref: ShieldedInstanceIntegrityPolicy
#   sourceMachineImage: string
#   sourceMachineImageEncryptionKey: $ref: CustomerEncryptionKey
#   startRestricted: boolean, readOnly
#   status: string, enum: [DEPROVISIONING, PENDING, PROVISIONING, REPAIRING, ... +7], readOnly
#   statusMessage: string, readOnly
#   tags: $ref: Tags
#   zone: string, readOnly
#
# [types.field_overrides]
# name = { required = true }
# labelFingerprint = { format = "bytes" }
# fingerprint = { format = "bytes" }
# # privateIpv6GoogleAccess = { enum_type = "InstancePrivateIpv6GoogleAccess" }
# # status = { enum_type = "InstanceStatus" }
# # keyRevocationActionType = { enum_type = "InstanceKeyRevocationActionType" }

# --- InstanceAggregatedList (7 fields) ---
# [[types]]
# schema = "InstanceAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, InstancesScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- InstanceConsumptionData (2 fields) ---
# [[types]]
# schema = "InstanceConsumptionData"
# include_fields = ["consumptionInfo", "instance"]
#
#   consumptionInfo: $ref: InstanceConsumptionInfo, readOnly
#   instance: string, readOnly

# --- InstanceConsumptionInfo (4 fields) ---
# [[types]]
# schema = "InstanceConsumptionInfo"
# include_fields = ["guestCpus", "localSsdGb", "memoryMb", "minNodeCpus"]
#
#   guestCpus: integer, format: int32, readOnly
#   localSsdGb: integer, format: int32, readOnly
#   memoryMb: integer, format: int32, readOnly
#   minNodeCpus: integer, format: int32, readOnly

# --- InstanceFlexibilityPolicy (1 fields) ---
# A flexible specification of machine types for instances to create.
# [[types]]
# schema = "InstanceFlexibilityPolicy"
# include_fields = ["instanceSelections"]
#
#   instanceSelections: map<string, InstanceFlexibilityPolicyInstanceSelection>

# --- InstanceFlexibilityPolicyInstanceSelection (3 fields) ---
# Specification of machine type to use. Every position inside this message is an alternative. The coun
# [[types]]
# schema = "InstanceFlexibilityPolicyInstanceSelection"
# include_fields = ["disks", "machineTypes", "rank"]
#
#   disks: array<AttachedDisk>
#   machineTypes: array<string>
#   rank: string, format: int64

# --- InstanceGroup (13 fields) ---
# Represents an Instance Group resource. Instance Groups can be used to configure a target forload bal
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "InstanceGroup"
# include_fields = ["creationTimestamp", "description", "fingerprint", "id", "kind", "name", "namedPorts", "network", "region", "selfLink", "size", "subnetwork", "zone"]
#
#   creationTimestamp: string, readOnly
#   description: string
#   fingerprint: string, format: byte, readOnly
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   name: string
#   namedPorts: array<NamedPort>
#   network: string
#   region: string, readOnly
#   selfLink: string, readOnly
#   size: integer, format: int32, readOnly
#   subnetwork: string, readOnly
#   zone: string, readOnly
#
# [types.field_overrides]
# name = { required = true }
# fingerprint = { format = "bytes" }

# --- InstanceGroupAggregatedList (7 fields) ---
# [[types]]
# schema = "InstanceGroupAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string, readOnly
#   items: map<string, InstanceGroupsScopedList>
#   kind: string, readOnly
#   nextPageToken: string, readOnly
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object, readOnly

# --- InstanceGroupList (6 fields) ---
# A list of InstanceGroup resources.
# [[types]]
# schema = "InstanceGroupList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string, readOnly
#   items: array<InstanceGroup>
#   kind: string, readOnly
#   nextPageToken: string, readOnly
#   selfLink: string, readOnly
#   warning: object, readOnly

# --- InstanceGroupManager (32 fields) ---
# Represents a Managed Instance Group resource. An instance group is a collection of VM instances that
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "InstanceGroupManager"
# include_fields = ["allInstancesConfig", "autoHealingPolicies", "baseInstanceName", "creationTimestamp", "currentActions", "description", "distributionPolicy", "fingerprint", "id", "instanceFlexibilityPolicy", "instanceGroup", "instanceLifecyclePolicy", "instanceTemplate", "kind", "listManagedInstancesResults", "name", "namedPorts", "region", "resourcePolicies", "satisfiesPzi", "satisfiesPzs", "selfLink", "standbyPolicy", "statefulPolicy", "status", "targetPools", "targetSize", "targetStoppedSize", "targetSuspendedSize", "updatePolicy", "versions", "zone"]
#
#   allInstancesConfig: $ref: InstanceGroupManagerAllInstancesConfig
#   autoHealingPolicies: array<InstanceGroupManagerAutoHealingPolicy>
#   baseInstanceName: string
#   creationTimestamp: string, readOnly
#   currentActions: $ref: InstanceGroupManagerActionsSummary, readOnly
#   description: string
#   distributionPolicy: $ref: DistributionPolicy
#   fingerprint: string, format: byte
#   id: string, format: uint64, readOnly
#   instanceFlexibilityPolicy: $ref: InstanceGroupManagerInstanceFlexibilityPolicy
#   instanceGroup: string, readOnly
#   instanceLifecyclePolicy: $ref: InstanceGroupManagerInstanceLifecyclePolicy
#   instanceTemplate: string
#   kind: string, readOnly
#   listManagedInstancesResults: string, enum: [PAGELESS, PAGINATED]
#   name: string
#   namedPorts: array<NamedPort>
#   region: string, readOnly
#   resourcePolicies: $ref: InstanceGroupManagerResourcePolicies
#   satisfiesPzi: boolean, readOnly
#   satisfiesPzs: boolean, readOnly
#   selfLink: string, readOnly
#   standbyPolicy: $ref: InstanceGroupManagerStandbyPolicy
#   statefulPolicy: $ref: StatefulPolicy
#   status: $ref: InstanceGroupManagerStatus, readOnly
#   targetPools: array<string>
#   targetSize: integer, format: int32
#   targetStoppedSize: integer, format: int32
#   targetSuspendedSize: integer, format: int32
#   updatePolicy: $ref: InstanceGroupManagerUpdatePolicy
#   versions: array<InstanceGroupManagerVersion>
#   zone: string, readOnly
#
# [types.field_overrides]
# name = { required = true }
# fingerprint = { format = "bytes" }
# # listManagedInstancesResults = { enum_type = "InstanceGroupManagerListManagedInstancesResults" }

# --- InstanceGroupManagerActionsSummary (13 fields) ---
# [[types]]
# schema = "InstanceGroupManagerActionsSummary"
# include_fields = ["abandoning", "creating", "creatingWithoutRetries", "deleting", "none", "recreating", "refreshing", "restarting", "resuming", "starting", "stopping", "suspending", "verifying"]
#
#   abandoning: integer, format: int32, readOnly
#   creating: integer, format: int32, readOnly
#   creatingWithoutRetries: integer, format: int32, readOnly
#   deleting: integer, format: int32, readOnly
#   none: integer, format: int32, readOnly
#   recreating: integer, format: int32, readOnly
#   refreshing: integer, format: int32, readOnly
#   restarting: integer, format: int32, readOnly
#   resuming: integer, format: int32, readOnly
#   starting: integer, format: int32, readOnly
#   stopping: integer, format: int32, readOnly
#   suspending: integer, format: int32, readOnly
#   verifying: integer, format: int32, readOnly

# --- InstanceGroupManagerAggregatedList (7 fields) ---
# [[types]]
# schema = "InstanceGroupManagerAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string, readOnly
#   items: map<string, InstanceGroupManagersScopedList>
#   kind: string, readOnly
#   nextPageToken: string, readOnly
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object, readOnly

# --- InstanceGroupManagerAllInstancesConfig (1 fields) ---
# [[types]]
# schema = "InstanceGroupManagerAllInstancesConfig"
# include_fields = ["properties"]
#
#   properties: $ref: InstancePropertiesPatch

# --- InstanceGroupManagerAutoHealingPolicy (2 fields) ---
# [[types]]
# schema = "InstanceGroupManagerAutoHealingPolicy"
# include_fields = ["healthCheck", "initialDelaySec"]
#
#   healthCheck: string
#   initialDelaySec: integer, format: int32

# --- InstanceGroupManagerInstanceFlexibilityPolicy (1 fields) ---
# [[types]]
# schema = "InstanceGroupManagerInstanceFlexibilityPolicy"
# include_fields = ["instanceSelections"]
#
#   instanceSelections: map<string, InstanceGroupManagerInstanceFlexibilityPolicyInstanceSelection>

# --- InstanceGroupManagerInstanceFlexibilityPolicyInstanceSelection (2 fields) ---
# [[types]]
# schema = "InstanceGroupManagerInstanceFlexibilityPolicyInstanceSelection"
# include_fields = ["machineTypes", "rank"]
#
#   machineTypes: array<string>
#   rank: integer, format: int32

# --- InstanceGroupManagerInstanceLifecyclePolicy (2 fields) ---
# [[types]]
# schema = "InstanceGroupManagerInstanceLifecyclePolicy"
# include_fields = ["defaultActionOnFailure", "forceUpdateOnRepair"]
#
#   defaultActionOnFailure: string, enum: [DO_NOTHING, REPAIR]
#   forceUpdateOnRepair: string, enum: [NO, YES]
#
# [types.field_overrides]
# # forceUpdateOnRepair = { enum_type = "InstanceGroupManagerInstanceLifecyclePolicyForceUpdateOnRepair" }
# # defaultActionOnFailure = { enum_type = "InstanceGroupManagerInstanceLifecyclePolicyDefaultActionOnFailure" }

# --- InstanceGroupManagerList (6 fields) ---
# [Output Only] A list of managed instance groups.
# [[types]]
# schema = "InstanceGroupManagerList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string, readOnly
#   items: array<InstanceGroupManager>
#   kind: string, readOnly
#   nextPageToken: string, readOnly
#   selfLink: string, readOnly
#   warning: object, readOnly

# --- InstanceGroupManagerResizeRequest (12 fields) ---
# InstanceGroupManagerResizeRequest represents a request to create a number of VMs: either immediately
# [[types]]
# schema = "InstanceGroupManagerResizeRequest"
# include_fields = ["creationTimestamp", "description", "id", "kind", "name", "requestedRunDuration", "resizeBy", "selfLink", "selfLinkWithId", "state", "status", "zone"]
#
#   creationTimestamp: string, readOnly
#   description: string
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   name: string
#   requestedRunDuration: $ref: Duration
#   resizeBy: integer, format: int32
#   selfLink: string, readOnly
#   selfLinkWithId: string, readOnly
#   state: string, enum: [ACCEPTED, CANCELLED, CREATING, FAILED, ... +2], readOnly
#   status: $ref: InstanceGroupManagerResizeRequestStatus, readOnly
#   zone: string, readOnly
#
# [types.field_overrides]
# name = { required = true }
# # state = { enum_type = "InstanceGroupManagerResizeRequestState" }

# --- InstanceGroupManagerResizeRequestStatus (2 fields) ---
# [[types]]
# schema = "InstanceGroupManagerResizeRequestStatus"
# include_fields = ["error", "lastAttempt"]
#
#   error: object, readOnly
#   lastAttempt: $ref: InstanceGroupManagerResizeRequestStatusLastAttempt, readOnly

# --- InstanceGroupManagerResizeRequestStatusLastAttempt (1 fields) ---
# [[types]]
# schema = "InstanceGroupManagerResizeRequestStatusLastAttempt"
# include_fields = ["error"]
#
#   error: object, readOnly

# --- InstanceGroupManagerResizeRequestsListResponse (6 fields) ---
# [Output Only] A list of resize requests.
# [[types]]
# schema = "InstanceGroupManagerResizeRequestsListResponse"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string, readOnly
#   items: array<InstanceGroupManagerResizeRequest>
#   kind: string, readOnly
#   nextPageToken: string, readOnly
#   selfLink: string, readOnly
#   warning: object, readOnly

# --- InstanceGroupManagerResourcePolicies (1 fields) ---
# [[types]]
# schema = "InstanceGroupManagerResourcePolicies"
# include_fields = ["workloadPolicy"]
#
#   workloadPolicy: string

# --- InstanceGroupManagerStandbyPolicy (2 fields) ---
# [[types]]
# schema = "InstanceGroupManagerStandbyPolicy"
# include_fields = ["initialDelaySec", "mode"]
#
#   initialDelaySec: integer, format: int32
#   mode: string, enum: [MANUAL, SCALE_OUT_POOL]
#
# [types.field_overrides]
# # mode = { enum_type = "InstanceGroupManagerStandbyPolicyMode" }

# --- InstanceGroupManagerStatus (5 fields) ---
# [[types]]
# schema = "InstanceGroupManagerStatus"
# include_fields = ["allInstancesConfig", "autoscaler", "isStable", "stateful", "versionTarget"]
#
#   allInstancesConfig: $ref: InstanceGroupManagerStatusAllInstancesConfig, readOnly
#   autoscaler: string, readOnly
#   isStable: boolean, readOnly
#   stateful: $ref: InstanceGroupManagerStatusStateful, readOnly
#   versionTarget: $ref: InstanceGroupManagerStatusVersionTarget, readOnly

# --- InstanceGroupManagerStatusAllInstancesConfig (2 fields) ---
# [[types]]
# schema = "InstanceGroupManagerStatusAllInstancesConfig"
# include_fields = ["currentRevision", "effective"]
#
#   currentRevision: string, readOnly
#   effective: boolean, readOnly

# --- InstanceGroupManagerStatusStateful (2 fields) ---
# [[types]]
# schema = "InstanceGroupManagerStatusStateful"
# include_fields = ["hasStatefulConfig", "perInstanceConfigs"]
#
#   hasStatefulConfig: boolean, readOnly
#   perInstanceConfigs: $ref: InstanceGroupManagerStatusStatefulPerInstanceConfigs, readOnly

# --- InstanceGroupManagerStatusStatefulPerInstanceConfigs (1 fields) ---
# [[types]]
# schema = "InstanceGroupManagerStatusStatefulPerInstanceConfigs"
# include_fields = ["allEffective"]
#
#   allEffective: boolean, readOnly

# --- InstanceGroupManagerStatusVersionTarget (1 fields) ---
# [[types]]
# schema = "InstanceGroupManagerStatusVersionTarget"
# include_fields = ["isReached"]
#
#   isReached: boolean, readOnly

# --- InstanceGroupManagerUpdatePolicy (7 fields) ---
# WARNING: reserved words: type
# [[types]]
# schema = "InstanceGroupManagerUpdatePolicy"
# include_fields = ["instanceRedistributionType", "maxSurge", "maxUnavailable", "minimalAction", "mostDisruptiveAllowedAction", "replacementMethod", "type"]
#
#   instanceRedistributionType: string, enum: [NONE, PROACTIVE]
#   maxSurge: $ref: FixedOrPercent
#   maxUnavailable: $ref: FixedOrPercent
#   minimalAction: string, enum: [NONE, REFRESH, REPLACE, RESTART]
#   mostDisruptiveAllowedAction: string, enum: [NONE, REFRESH, REPLACE, RESTART]
#   replacementMethod: string, enum: [RECREATE, SUBSTITUTE]
#   type: string, enum: [OPPORTUNISTIC, PROACTIVE], RESERVED_WORD
#
# [types.field_overrides]
# type = { rust_name = "type_value", serde_rename = "type" }
# # replacementMethod = { enum_type = "InstanceGroupManagerUpdatePolicyReplacementMethod" }
# # type = { enum_type = "InstanceGroupManagerUpdatePolicyType" }
# # instanceRedistributionType = { enum_type = "InstanceGroupManagerUpdatePolicyInstanceRedistributionType" }
# # minimalAction = { enum_type = "InstanceGroupManagerUpdatePolicyMinimalAction" }
# # mostDisruptiveAllowedAction = { enum_type = "InstanceGroupManagerUpdatePolicyMostDisruptiveAllowedAction" }

# --- InstanceGroupManagerVersion (3 fields) ---
# [[types]]
# schema = "InstanceGroupManagerVersion"
# include_fields = ["instanceTemplate", "name", "targetSize"]
#
#   instanceTemplate: string
#   name: string
#   targetSize: $ref: FixedOrPercent
#
# [types.field_overrides]
# name = { required = true }

# --- InstanceGroupManagersAbandonInstancesRequest (1 fields) ---
# [[types]]
# schema = "InstanceGroupManagersAbandonInstancesRequest"
# include_fields = ["instances"]
#
#   instances: array<string>

# --- InstanceGroupManagersApplyUpdatesRequest (4 fields) ---
# InstanceGroupManagers.applyUpdatesToInstances
# [[types]]
# schema = "InstanceGroupManagersApplyUpdatesRequest"
# include_fields = ["allInstances", "instances", "minimalAction", "mostDisruptiveAllowedAction"]
#
#   allInstances: boolean
#   instances: array<string>
#   minimalAction: string, enum: [NONE, REFRESH, REPLACE, RESTART]
#   mostDisruptiveAllowedAction: string, enum: [NONE, REFRESH, REPLACE, RESTART]
#
# [types.field_overrides]
# # minimalAction = { enum_type = "InstanceGroupManagersApplyUpdatesRequestMinimalAction" }
# # mostDisruptiveAllowedAction = { enum_type = "InstanceGroupManagersApplyUpdatesRequestMostDisruptiveAllowedAction" }

# --- InstanceGroupManagersCreateInstancesRequest (1 fields) ---
# InstanceGroupManagers.createInstances
# [[types]]
# schema = "InstanceGroupManagersCreateInstancesRequest"
# include_fields = ["instances"]
#
#   instances: array<PerInstanceConfig>

# --- InstanceGroupManagersDeleteInstancesRequest (2 fields) ---
# [[types]]
# schema = "InstanceGroupManagersDeleteInstancesRequest"
# include_fields = ["instances", "skipInstancesOnValidationError"]
#
#   instances: array<string>
#   skipInstancesOnValidationError: boolean

# --- InstanceGroupManagersDeletePerInstanceConfigsReq (1 fields) ---
# InstanceGroupManagers.deletePerInstanceConfigs
# [[types]]
# schema = "InstanceGroupManagersDeletePerInstanceConfigsReq"
# include_fields = ["names"]
#
#   names: array<string>

# --- InstanceGroupManagersListErrorsResponse (2 fields) ---
# [[types]]
# schema = "InstanceGroupManagersListErrorsResponse"
# include_fields = ["items", "nextPageToken"]
#
#   items: array<InstanceManagedByIgmError>, readOnly
#   nextPageToken: string, readOnly

# --- InstanceGroupManagersListManagedInstancesResponse (2 fields) ---
# [[types]]
# schema = "InstanceGroupManagersListManagedInstancesResponse"
# include_fields = ["managedInstances", "nextPageToken"]
#
#   managedInstances: array<ManagedInstance>, readOnly
#   nextPageToken: string, readOnly

# --- InstanceGroupManagersListPerInstanceConfigsResp (3 fields) ---
# [[types]]
# schema = "InstanceGroupManagersListPerInstanceConfigsResp"
# include_fields = ["items", "nextPageToken", "warning"]
#
#   items: array<PerInstanceConfig>, readOnly
#   nextPageToken: string, readOnly
#   warning: object, readOnly

# --- InstanceGroupManagersPatchPerInstanceConfigsReq (1 fields) ---
# InstanceGroupManagers.patchPerInstanceConfigs
# [[types]]
# schema = "InstanceGroupManagersPatchPerInstanceConfigsReq"
# include_fields = ["perInstanceConfigs"]
#
#   perInstanceConfigs: array<PerInstanceConfig>

# --- InstanceGroupManagersRecreateInstancesRequest (1 fields) ---
# [[types]]
# schema = "InstanceGroupManagersRecreateInstancesRequest"
# include_fields = ["instances"]
#
#   instances: array<string>

# --- InstanceGroupManagersResumeInstancesRequest (1 fields) ---
# [[types]]
# schema = "InstanceGroupManagersResumeInstancesRequest"
# include_fields = ["instances"]
#
#   instances: array<string>

# --- InstanceGroupManagersScopedList (2 fields) ---
# [[types]]
# schema = "InstanceGroupManagersScopedList"
# include_fields = ["instanceGroupManagers", "warning"]
#
#   instanceGroupManagers: array<InstanceGroupManager>, readOnly
#   warning: object, readOnly

# --- InstanceGroupManagersSetInstanceTemplateRequest (1 fields) ---
# [[types]]
# schema = "InstanceGroupManagersSetInstanceTemplateRequest"
# include_fields = ["instanceTemplate"]
#
#   instanceTemplate: string

# --- InstanceGroupManagersSetTargetPoolsRequest (2 fields) ---
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "InstanceGroupManagersSetTargetPoolsRequest"
# include_fields = ["fingerprint", "targetPools"]
#
#   fingerprint: string, format: byte
#   targetPools: array<string>
#
# [types.field_overrides]
# fingerprint = { format = "bytes" }

# --- InstanceGroupManagersStartInstancesRequest (1 fields) ---
# [[types]]
# schema = "InstanceGroupManagersStartInstancesRequest"
# include_fields = ["instances"]
#
#   instances: array<string>

# --- InstanceGroupManagersStopInstancesRequest (2 fields) ---
# [[types]]
# schema = "InstanceGroupManagersStopInstancesRequest"
# include_fields = ["forceStop", "instances"]
#
#   forceStop: boolean
#   instances: array<string>

# --- InstanceGroupManagersSuspendInstancesRequest (2 fields) ---
# [[types]]
# schema = "InstanceGroupManagersSuspendInstancesRequest"
# include_fields = ["forceSuspend", "instances"]
#
#   forceSuspend: boolean
#   instances: array<string>

# --- InstanceGroupManagersUpdatePerInstanceConfigsReq (1 fields) ---
# InstanceGroupManagers.updatePerInstanceConfigs
# [[types]]
# schema = "InstanceGroupManagersUpdatePerInstanceConfigsReq"
# include_fields = ["perInstanceConfigs"]
#
#   perInstanceConfigs: array<PerInstanceConfig>

# --- InstanceGroupsAddInstancesRequest (1 fields) ---
# [[types]]
# schema = "InstanceGroupsAddInstancesRequest"
# include_fields = ["instances"]
#
#   instances: array<InstanceReference>

# --- InstanceGroupsListInstances (6 fields) ---
# [[types]]
# schema = "InstanceGroupsListInstances"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string, readOnly
#   items: array<InstanceWithNamedPorts>
#   kind: string, readOnly
#   nextPageToken: string, readOnly
#   selfLink: string, readOnly
#   warning: object, readOnly

# --- InstanceGroupsListInstancesRequest (1 fields) ---
# [[types]]
# schema = "InstanceGroupsListInstancesRequest"
# include_fields = ["instanceState"]
#
#   instanceState: string, enum: [ALL, RUNNING]
#
# [types.field_overrides]
# # instanceState = { enum_type = "InstanceGroupsListInstancesRequestInstanceState" }

# --- InstanceGroupsRemoveInstancesRequest (1 fields) ---
# [[types]]
# schema = "InstanceGroupsRemoveInstancesRequest"
# include_fields = ["instances"]
#
#   instances: array<InstanceReference>

# --- InstanceGroupsScopedList (2 fields) ---
# [[types]]
# schema = "InstanceGroupsScopedList"
# include_fields = ["instanceGroups", "warning"]
#
#   instanceGroups: array<InstanceGroup>, readOnly
#   warning: object, readOnly

# --- InstanceGroupsSetNamedPortsRequest (2 fields) ---
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "InstanceGroupsSetNamedPortsRequest"
# include_fields = ["fingerprint", "namedPorts"]
#
#   fingerprint: string, format: byte
#   namedPorts: array<NamedPort>
#
# [types.field_overrides]
# fingerprint = { format = "bytes" }

# --- InstanceList (6 fields) ---
# Contains a list of instances.
# [[types]]
# schema = "InstanceList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<Instance>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- InstanceListReferrers (6 fields) ---
# Contains a list of instance referrers.
# [[types]]
# schema = "InstanceListReferrers"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<Reference>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- InstanceManagedByIgmError (3 fields) ---
# [[types]]
# schema = "InstanceManagedByIgmError"
# include_fields = ["error", "instanceActionDetails", "timestamp"]
#
#   error: $ref: InstanceManagedByIgmErrorManagedInstanceError, readOnly
#   instanceActionDetails: $ref: InstanceManagedByIgmErrorInstanceActionDetails, readOnly
#   timestamp: string, readOnly

# --- InstanceManagedByIgmErrorInstanceActionDetails (3 fields) ---
# [[types]]
# schema = "InstanceManagedByIgmErrorInstanceActionDetails"
# include_fields = ["action", "instance", "version"]
#
#   action: string, enum: [ABANDONING, CREATING, CREATING_WITHOUT_RETRIES, DELETING, ... +9], readOnly
#   instance: string, readOnly
#   version: $ref: ManagedInstanceVersion, readOnly
#
# [types.field_overrides]
# # action = { enum_type = "InstanceManagedByIgmErrorInstanceActionDetailsAction" }

# --- InstanceManagedByIgmErrorManagedInstanceError (2 fields) ---
# [[types]]
# schema = "InstanceManagedByIgmErrorManagedInstanceError"
# include_fields = ["code", "message"]
#
#   code: string, readOnly
#   message: string, readOnly

# --- InstanceMoveRequest (2 fields) ---
# [[types]]
# schema = "InstanceMoveRequest"
# include_fields = ["destinationZone", "targetInstance"]
#
#   destinationZone: string
#   targetInstance: string

# --- InstanceParams (2 fields) ---
# Additional instance params.
# [[types]]
# schema = "InstanceParams"
# include_fields = ["requestValidForDuration", "resourceManagerTags"]
#
#   requestValidForDuration: $ref: Duration
#   resourceManagerTags: map<string, string>

# --- InstanceProperties (21 fields) ---
# [[types]]
# schema = "InstanceProperties"
# include_fields = ["advancedMachineFeatures", "canIpForward", "confidentialInstanceConfig", "description", "disks", "guestAccelerators", "keyRevocationActionType", "labels", "machineType", "metadata", "minCpuPlatform", "networkInterfaces", "networkPerformanceConfig", "privateIpv6GoogleAccess", "reservationAffinity", "resourceManagerTags", "resourcePolicies", "scheduling", "serviceAccounts", "shieldedInstanceConfig", "tags"]
#
#   advancedMachineFeatures: $ref: AdvancedMachineFeatures
#   canIpForward: boolean
#   confidentialInstanceConfig: $ref: ConfidentialInstanceConfig
#   description: string
#   disks: array<AttachedDisk>
#   guestAccelerators: array<AcceleratorConfig>
#   keyRevocationActionType: string, enum: [KEY_REVOCATION_ACTION_TYPE_UNSPECIFIED, NONE, STOP]
#   labels: map<string, string>
#   machineType: string
#   metadata: $ref: Metadata
#   minCpuPlatform: string
#   networkInterfaces: array<NetworkInterface>
#   networkPerformanceConfig: $ref: NetworkPerformanceConfig
#   privateIpv6GoogleAccess: string, enum: [ENABLE_BIDIRECTIONAL_ACCESS_TO_GOOGLE, ENABLE_OUTBOUND_VM_ACCESS_TO_GOOGLE, INHERIT_FROM_SUBNETWORK]
#   reservationAffinity: $ref: ReservationAffinity
#   resourceManagerTags: map<string, string>
#   resourcePolicies: array<string>
#   scheduling: $ref: Scheduling
#   serviceAccounts: array<ServiceAccount>
#   shieldedInstanceConfig: $ref: ShieldedInstanceConfig
#   tags: $ref: Tags
#
# [types.field_overrides]
# # keyRevocationActionType = { enum_type = "InstancePropertiesKeyRevocationActionType" }
# # privateIpv6GoogleAccess = { enum_type = "InstancePropertiesPrivateIpv6GoogleAccess" }

# --- InstancePropertiesPatch (2 fields) ---
# Represents the change that you want to make to the instance properties.
# [[types]]
# schema = "InstancePropertiesPatch"
# include_fields = ["labels", "metadata"]
#
#   labels: map<string, string>
#   metadata: map<string, string>

# --- InstanceReference (1 fields) ---
# [[types]]
# schema = "InstanceReference"
# include_fields = ["instance"]
#
#   instance: string

# --- InstanceSettings (4 fields) ---
# Represents a Instance Settings resource. You can use instance settings to configure default settings
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "InstanceSettings"
# include_fields = ["fingerprint", "kind", "metadata", "zone"]
#
#   fingerprint: string, format: byte
#   kind: string, readOnly
#   metadata: $ref: InstanceSettingsMetadata
#   zone: string, readOnly
#
# [types.field_overrides]
# fingerprint = { format = "bytes" }

# --- InstanceSettingsMetadata (2 fields) ---
# [[types]]
# schema = "InstanceSettingsMetadata"
# include_fields = ["items", "kind"]
#
#   items: map<string, string>
#   kind: string, readOnly

# --- InstanceTemplate (10 fields) ---
# Represents an Instance Template resource. Google Compute Engine has two Instance Template resources:
# [[types]]
# schema = "InstanceTemplate"
# include_fields = ["creationTimestamp", "description", "id", "kind", "name", "properties", "region", "selfLink", "sourceInstance", "sourceInstanceParams"]
#
#   creationTimestamp: string, readOnly
#   description: string
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   name: string
#   properties: $ref: InstanceProperties
#   region: string, readOnly
#   selfLink: string, readOnly
#   sourceInstance: string
#   sourceInstanceParams: $ref: SourceInstanceParams
#
# [types.field_overrides]
# name = { required = true }

# --- InstanceTemplateAggregatedList (6 fields) ---
# Contains a list of InstanceTemplatesScopedList.
# [[types]]
# schema = "InstanceTemplateAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: map<string, InstanceTemplatesScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- InstanceTemplateList (6 fields) ---
# A list of instance templates.
# [[types]]
# schema = "InstanceTemplateList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<InstanceTemplate>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- InstanceTemplatesScopedList (2 fields) ---
# [[types]]
# schema = "InstanceTemplatesScopedList"
# include_fields = ["instanceTemplates", "warning"]
#
#   instanceTemplates: array<InstanceTemplate>
#   warning: object

# --- InstanceWithNamedPorts (3 fields) ---
# [[types]]
# schema = "InstanceWithNamedPorts"
# include_fields = ["instance", "namedPorts", "status"]
#
#   instance: string, readOnly
#   namedPorts: array<NamedPort>, readOnly
#   status: string, enum: [DEPROVISIONING, PENDING, PROVISIONING, REPAIRING, ... +7], readOnly
#
# [types.field_overrides]
# # status = { enum_type = "InstanceWithNamedPortsStatus" }

# --- InstancesAddResourcePoliciesRequest (1 fields) ---
# [[types]]
# schema = "InstancesAddResourcePoliciesRequest"
# include_fields = ["resourcePolicies"]
#
#   resourcePolicies: array<string>

# --- InstancesBulkInsertOperationMetadata (1 fields) ---
# [[types]]
# schema = "InstancesBulkInsertOperationMetadata"
# include_fields = ["perLocationStatus"]
#
#   perLocationStatus: map<string, BulkInsertOperationStatus>

# --- InstancesGetEffectiveFirewallsResponse (2 fields) ---
# [[types]]
# schema = "InstancesGetEffectiveFirewallsResponse"
# include_fields = ["firewallPolicys", "firewalls"]
#
#   firewallPolicys: array<InstancesGetEffectiveFirewallsResponseEffectiveFirewallPolicy>
#   firewalls: array<Firewall>

# --- InstancesGetEffectiveFirewallsResponseEffectiveFirewallPolicy (7 fields) ---
# WARNING: reserved words: type
# [[types]]
# schema = "InstancesGetEffectiveFirewallsResponseEffectiveFirewallPolicy"
# include_fields = ["displayName", "name", "packetMirroringRules", "priority", "rules", "shortName", "type"]
#
#   displayName: string, readOnly
#   name: string, readOnly
#   packetMirroringRules: array<FirewallPolicyRule>, readOnly
#   priority: integer, format: int32, readOnly
#   rules: array<FirewallPolicyRule>
#   shortName: string, readOnly
#   type: string, enum: [HIERARCHY, NETWORK, NETWORK_REGIONAL, SYSTEM_GLOBAL, ... +2], readOnly, RESERVED_WORD
#
# [types.field_overrides]
# name = { required = true }
# type = { rust_name = "type_value", serde_rename = "type" }
# # type = { enum_type = "InstancesGetEffectiveFirewallsResponseEffectiveFirewallPolicyType" }

# --- InstancesRemoveResourcePoliciesRequest (1 fields) ---
# [[types]]
# schema = "InstancesRemoveResourcePoliciesRequest"
# include_fields = ["resourcePolicies"]
#
#   resourcePolicies: array<string>

# --- InstancesReportHostAsFaultyRequest (2 fields) ---
# [[types]]
# schema = "InstancesReportHostAsFaultyRequest"
# include_fields = ["disruptionSchedule", "faultReasons"]
#
#   disruptionSchedule: string, enum: [DISRUPTION_SCHEDULE_UNSPECIFIED, FUTURE, IMMEDIATE]
#   faultReasons: array<InstancesReportHostAsFaultyRequestFaultReason>
#
# [types.field_overrides]
# # disruptionSchedule = { enum_type = "InstancesReportHostAsFaultyRequestDisruptionSchedule" }

# --- InstancesReportHostAsFaultyRequestFaultReason (2 fields) ---
# [[types]]
# schema = "InstancesReportHostAsFaultyRequestFaultReason"
# include_fields = ["behavior", "description"]
#
#   behavior: string, enum: [BEHAVIOR_UNSPECIFIED, CHIP_ERROR, PERFORMANCE, SILENT_DATA_CORRUPTION, UNRECOVERABLE_GPU_ERROR]
#   description: string
#
# [types.field_overrides]
# # behavior = { enum_type = "InstancesReportHostAsFaultyRequestFaultReasonBehavior" }

# --- InstancesScopedList (2 fields) ---
# [[types]]
# schema = "InstancesScopedList"
# include_fields = ["instances", "warning"]
#
#   instances: array<Instance>
#   warning: object

# --- InstancesSetLabelsRequest (2 fields) ---
# WARNING: format:"byte" fields: labelFingerprint
# [[types]]
# schema = "InstancesSetLabelsRequest"
# include_fields = ["labelFingerprint", "labels"]
#
#   labelFingerprint: string, format: byte
#   labels: map<string, string>
#
# [types.field_overrides]
# labelFingerprint = { format = "bytes" }

# --- InstancesSetMachineResourcesRequest (1 fields) ---
# [[types]]
# schema = "InstancesSetMachineResourcesRequest"
# include_fields = ["guestAccelerators"]
#
#   guestAccelerators: array<AcceleratorConfig>

# --- InstancesSetMachineTypeRequest (1 fields) [IN MANIFEST] ---
# [[types]]
# schema = "InstancesSetMachineTypeRequest"
# include_fields = ["machineType"]
#
#   machineType: string

# --- InstancesSetMinCpuPlatformRequest (1 fields) ---
# [[types]]
# schema = "InstancesSetMinCpuPlatformRequest"
# include_fields = ["minCpuPlatform"]
#
#   minCpuPlatform: string

# --- InstancesSetNameRequest (2 fields) ---
# [[types]]
# schema = "InstancesSetNameRequest"
# include_fields = ["currentName", "name"]
#
#   currentName: string
#   name: string
#
# [types.field_overrides]
# name = { required = true }

# --- InstancesSetSecurityPolicyRequest (2 fields) ---
# [[types]]
# schema = "InstancesSetSecurityPolicyRequest"
# include_fields = ["networkInterfaces", "securityPolicy"]
#
#   networkInterfaces: array<string>
#   securityPolicy: string

# --- InstancesSetServiceAccountRequest (2 fields) ---
# [[types]]
# schema = "InstancesSetServiceAccountRequest"
# include_fields = ["email", "scopes"]
#
#   email: string
#   scopes: array<string>

# --- InstancesStartWithEncryptionKeyRequest (1 fields) ---
# [[types]]
# schema = "InstancesStartWithEncryptionKeyRequest"
# include_fields = ["disks"]
#
#   disks: array<CustomerEncryptionKeyProtectedDisk>

# --- InstantSnapshot (19 fields) ---
# Represents a InstantSnapshot resource. You can use instant snapshots to create disk rollback points 
# WARNING: format:"byte" fields: labelFingerprint
# [[types]]
# schema = "InstantSnapshot"
# include_fields = ["architecture", "creationTimestamp", "description", "diskSizeGb", "id", "kind", "labelFingerprint", "labels", "name", "region", "resourceStatus", "satisfiesPzi", "satisfiesPzs", "selfLink", "selfLinkWithId", "sourceDisk", "sourceDiskId", "status", "zone"]
#
#   architecture: string, enum: [ARCHITECTURE_UNSPECIFIED, ARM64, X86_64], readOnly
#   creationTimestamp: string, readOnly
#   description: string
#   diskSizeGb: string, format: int64, readOnly
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   labelFingerprint: string, format: byte
#   labels: map<string, string>
#   name: string
#   region: string, readOnly
#   resourceStatus: $ref: InstantSnapshotResourceStatus, readOnly
#   satisfiesPzi: boolean, readOnly
#   satisfiesPzs: boolean, readOnly
#   selfLink: string, readOnly
#   selfLinkWithId: string, readOnly
#   sourceDisk: string
#   sourceDiskId: string, readOnly
#   status: string, enum: [CREATING, DELETING, FAILED, READY, UNAVAILABLE], readOnly
#   zone: string, readOnly
#
# [types.field_overrides]
# name = { required = true }
# labelFingerprint = { format = "bytes" }
# # status = { enum_type = "InstantSnapshotStatus" }
# # architecture = { enum_type = "InstantSnapshotArchitecture" }

# --- InstantSnapshotAggregatedList (7 fields) ---
# [[types]]
# schema = "InstantSnapshotAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, InstantSnapshotsScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- InstantSnapshotList (6 fields) ---
# Contains a list of InstantSnapshot resources.
# [[types]]
# schema = "InstantSnapshotList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<InstantSnapshot>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- InstantSnapshotResourceStatus (1 fields) ---
# [[types]]
# schema = "InstantSnapshotResourceStatus"
# include_fields = ["storageSizeBytes"]
#
#   storageSizeBytes: string, format: int64

# --- InstantSnapshotsScopedList (2 fields) ---
# [[types]]
# schema = "InstantSnapshotsScopedList"
# include_fields = ["instantSnapshots", "warning"]
#
#   instantSnapshots: array<InstantSnapshot>
#   warning: object

# --- Int64RangeMatch (2 fields) ---
# HttpRouteRuleMatch criteria for field values that must stay within the specified integer range.
# [[types]]
# schema = "Int64RangeMatch"
# include_fields = ["rangeEnd", "rangeStart"]
#
#   rangeEnd: string, format: int64
#   rangeStart: string, format: int64

# --- Interconnect (36 fields) ---
# Represents an Interconnect resource. An Interconnect resource is a dedicated connection between the 
# WARNING: format:"byte" fields: labelFingerprint
# [[types]]
# schema = "Interconnect"
# include_fields = ["aaiEnabled", "adminEnabled", "applicationAwareInterconnect", "availableFeatures", "circuitInfos", "creationTimestamp", "customerName", "description", "expectedOutages", "googleIpAddress", "googleReferenceId", "id", "interconnectAttachments", "interconnectGroups", "interconnectType", "kind", "labelFingerprint", "labels", "linkType", "location", "macsec", "macsecEnabled", "name", "nocContactEmail", "operationalStatus", "params", "peerIpAddress", "provisionedLinkCount", "remoteLocation", "requestedFeatures", "requestedLinkCount", "satisfiesPzs", "selfLink", "state", "subzone", "wireGroups"]
#
#   aaiEnabled: boolean
#   adminEnabled: boolean
#   applicationAwareInterconnect: $ref: InterconnectApplicationAwareInterconnect
#   availableFeatures: array<string>
#   circuitInfos: array<InterconnectCircuitInfo>, readOnly
#   creationTimestamp: string, readOnly
#   customerName: string
#   description: string
#   expectedOutages: array<InterconnectOutageNotification>, readOnly
#   googleIpAddress: string, readOnly
#   googleReferenceId: string, readOnly
#   id: string, format: uint64, readOnly
#   interconnectAttachments: array<string>, readOnly
#   interconnectGroups: array<string>, readOnly
#   interconnectType: string, enum: [DEDICATED, IT_PRIVATE, PARTNER]
#   kind: string, readOnly
#   labelFingerprint: string, format: byte
#   labels: map<string, string>
#   linkType: string, enum: [LINK_TYPE_ETHERNET_100G_LR, LINK_TYPE_ETHERNET_10G_LR, LINK_TYPE_ETHERNET_400G_LR4]
#   location: string
#   macsec: $ref: InterconnectMacsec
#   macsecEnabled: boolean
#   name: string
#   nocContactEmail: string
#   operationalStatus: string, enum: [OS_ACTIVE, OS_UNPROVISIONED], readOnly
#   params: $ref: InterconnectParams
#   peerIpAddress: string, readOnly
#   provisionedLinkCount: integer, format: int32, readOnly
#   remoteLocation: string
#   requestedFeatures: array<string>
#   requestedLinkCount: integer, format: int32
#   satisfiesPzs: boolean, readOnly
#   selfLink: string, readOnly
#   state: string, enum: [ACTIVE, UNPROVISIONED], readOnly
#   subzone: string, enum: [SUBZONE_A, SUBZONE_B]
#   wireGroups: array<string>, readOnly
#
# [types.field_overrides]
# name = { required = true }
# labelFingerprint = { format = "bytes" }
# # linkType = { enum_type = "InterconnectLinkType" }
# # interconnectType = { enum_type = "InterconnectInterconnectType" }
# # state = { enum_type = "InterconnectState" }
# # subzone = { enum_type = "InterconnectSubzone" }
# # operationalStatus = { enum_type = "InterconnectOperationalStatus" }

# --- InterconnectApplicationAwareInterconnect (4 fields) ---
# Configuration information for application awareness on this Cloud Interconnect.
# [[types]]
# schema = "InterconnectApplicationAwareInterconnect"
# include_fields = ["bandwidthPercentagePolicy", "profileDescription", "shapeAveragePercentages", "strictPriorityPolicy"]
#
#   bandwidthPercentagePolicy: $ref: InterconnectApplicationAwareInterconnectBandwidthPercentagePolicy
#   profileDescription: string
#   shapeAveragePercentages: array<InterconnectApplicationAwareInterconnectBandwidthPercentage>
#   strictPriorityPolicy: $ref: InterconnectApplicationAwareInterconnectStrictPriorityPolicy

# --- InterconnectApplicationAwareInterconnectBandwidthPercentage (2 fields) ---
# Specify bandwidth percentages [1-100] for various traffic classes in BandwidthPercentagePolicy. The 
# [[types]]
# schema = "InterconnectApplicationAwareInterconnectBandwidthPercentage"
# include_fields = ["percentage", "trafficClass"]
#
#   percentage: integer, format: uint32
#   trafficClass: string, enum: [TC1, TC2, TC3, TC4, ... +2]
#
# [types.field_overrides]
# # trafficClass = { enum_type = "InterconnectApplicationAwareInterconnectBandwidthPercentageTrafficClass" }

# --- InterconnectApplicationAwareInterconnectBandwidthPercentagePolicy (1 fields) ---
# [[types]]
# schema = "InterconnectApplicationAwareInterconnectBandwidthPercentagePolicy"
# include_fields = ["bandwidthPercentages"]
#
#   bandwidthPercentages: array<InterconnectApplicationAwareInterconnectBandwidthPercentage>

# --- InterconnectApplicationAwareInterconnectStrictPriorityPolicy (0 fields) ---
# Specify configuration for StrictPriorityPolicy.
# [[types]]
# schema = "InterconnectApplicationAwareInterconnectStrictPriorityPolicy"

# --- InterconnectAttachment (47 fields) ---
# Represents an Interconnect Attachment (VLAN) resource. You can use Interconnect attachments (VLANS) 
# WARNING: format:"byte" fields: labelFingerprint
# WARNING: reserved words: type
# [[types]]
# schema = "InterconnectAttachment"
# include_fields = ["adminEnabled", "attachmentGroup", "bandwidth", "candidateCloudRouterIpAddress", "candidateCloudRouterIpv6Address", "candidateCustomerRouterIpAddress", "candidateCustomerRouterIpv6Address", "candidateIpv6Subnets", "candidateSubnets", "cloudRouterIpAddress", "cloudRouterIpv6Address", "cloudRouterIpv6InterfaceId", "configurationConstraints", "creationTimestamp", "customerRouterIpAddress", "customerRouterIpv6Address", "customerRouterIpv6InterfaceId", "dataplaneVersion", "description", "edgeAvailabilityDomain", "encryption", "googleReferenceId", "id", "interconnect", "ipsecInternalAddresses", "kind", "l2Forwarding", "labelFingerprint", "labels", "mtu", "name", "operationalStatus", "pairingKey", "params", "partnerAsn", "partnerMetadata", "privateInterconnectInfo", "region", "remoteService", "router", "satisfiesPzs", "selfLink", "stackType", "state", "subnetLength", "type", "vlanTag8021q"]
#
#   adminEnabled: boolean
#   attachmentGroup: string, readOnly
#   bandwidth: string, enum: [BPS_100G, BPS_100M, BPS_10G, BPS_1G, ... +10]
#   candidateCloudRouterIpAddress: string
#   candidateCloudRouterIpv6Address: string
#   candidateCustomerRouterIpAddress: string
#   candidateCustomerRouterIpv6Address: string
#   candidateIpv6Subnets: array<string>
#   candidateSubnets: array<string>
#   cloudRouterIpAddress: string, readOnly
#   cloudRouterIpv6Address: string, readOnly
#   cloudRouterIpv6InterfaceId: string
#   configurationConstraints: $ref: InterconnectAttachmentConfigurationConstraints, readOnly
#   creationTimestamp: string, readOnly
#   customerRouterIpAddress: string, readOnly
#   customerRouterIpv6Address: string, readOnly
#   customerRouterIpv6InterfaceId: string
#   dataplaneVersion: integer, format: int32, readOnly
#   description: string
#   edgeAvailabilityDomain: string, enum: [AVAILABILITY_DOMAIN_1, AVAILABILITY_DOMAIN_2, AVAILABILITY_DOMAIN_ANY]
#   encryption: string, enum: [IPSEC, NONE]
#   googleReferenceId: string, readOnly
#   id: string, format: uint64, readOnly
#   interconnect: string
#   ipsecInternalAddresses: array<string>
#   kind: string, readOnly
#   l2Forwarding: $ref: InterconnectAttachmentL2Forwarding
#   labelFingerprint: string, format: byte
#   labels: map<string, string>
#   mtu: integer, format: int32
#   name: string
#   operationalStatus: string, enum: [OS_ACTIVE, OS_UNPROVISIONED], readOnly
#   pairingKey: string
#   params: $ref: InterconnectAttachmentParams
#   partnerAsn: string, format: int64
#   partnerMetadata: $ref: InterconnectAttachmentPartnerMetadata
#   privateInterconnectInfo: $ref: InterconnectAttachmentPrivateInfo, readOnly
#   region: string, readOnly
#   remoteService: string, readOnly
#   router: string
#   satisfiesPzs: boolean, readOnly
#   selfLink: string, readOnly
#   stackType: string, enum: [IPV4_IPV6, IPV4_ONLY]
#   state: string, enum: [ACTIVE, DEFUNCT, PARTNER_REQUEST_RECEIVED, PENDING_CUSTOMER, ... +3], readOnly
#   subnetLength: integer, format: int32
#   type: string, enum: [DEDICATED, L2_DEDICATED, PARTNER, PARTNER_PROVIDER], RESERVED_WORD
#   vlanTag8021q: integer, format: int32
#
# [types.field_overrides]
# name = { required = true }
# type = { rust_name = "type_value", serde_rename = "type" }
# labelFingerprint = { format = "bytes" }
# # stackType = { enum_type = "InterconnectAttachmentStackType" }
# # edgeAvailabilityDomain = { enum_type = "InterconnectAttachmentEdgeAvailabilityDomain" }
# # encryption = { enum_type = "InterconnectAttachmentEncryption" }
# # operationalStatus = { enum_type = "InterconnectAttachmentOperationalStatus" }
# # type = { enum_type = "InterconnectAttachmentType" }
# # bandwidth = { enum_type = "InterconnectAttachmentBandwidth" }
# # state = { enum_type = "InterconnectAttachmentState" }

# --- InterconnectAttachmentAggregatedList (7 fields) ---
# [[types]]
# schema = "InterconnectAttachmentAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, InterconnectAttachmentsScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- InterconnectAttachmentConfigurationConstraints (2 fields) ---
# [[types]]
# schema = "InterconnectAttachmentConfigurationConstraints"
# include_fields = ["bgpMd5", "bgpPeerAsnRanges"]
#
#   bgpMd5: string, enum: [MD5_OPTIONAL, MD5_REQUIRED, MD5_UNSUPPORTED], readOnly
#   bgpPeerAsnRanges: array<InterconnectAttachmentConfigurationConstraintsBgpPeerASNRange>, readOnly
#
# [types.field_overrides]
# # bgpMd5 = { enum_type = "InterconnectAttachmentConfigurationConstraintsBgpMd5" }

# --- InterconnectAttachmentConfigurationConstraintsBgpPeerASNRange (2 fields) ---
# [[types]]
# schema = "InterconnectAttachmentConfigurationConstraintsBgpPeerASNRange"
# include_fields = ["max", "min"]
#
#   max: integer, format: uint32
#   min: integer, format: uint32

# --- InterconnectAttachmentGroup (12 fields) ---
# An interconnect attachment group resource allows customers to create, analyze, and expand highly ava
# [[types]]
# schema = "InterconnectAttachmentGroup"
# include_fields = ["attachments", "configured", "creationTimestamp", "description", "etag", "id", "intent", "interconnectGroup", "kind", "logicalStructure", "name", "selfLink"]
#
#   attachments: map<string, InterconnectAttachmentGroupAttachment>
#   configured: $ref: InterconnectAttachmentGroupConfigured, readOnly
#   creationTimestamp: string, readOnly
#   description: string
#   etag: string
#   id: string, format: uint64, readOnly
#   intent: $ref: InterconnectAttachmentGroupIntent
#   interconnectGroup: string
#   kind: string, readOnly
#   logicalStructure: $ref: InterconnectAttachmentGroupLogicalStructure, readOnly
#   name: string
#   selfLink: string, readOnly
#
# [types.field_overrides]
# name = { required = true }

# --- InterconnectAttachmentGroupAttachment (1 fields) ---
# An Attachment in this AttachmentGroup.
# [[types]]
# schema = "InterconnectAttachmentGroupAttachment"
# include_fields = ["attachment"]
#
#   attachment: string

# --- InterconnectAttachmentGroupConfigured (1 fields) ---
# [Output Only] The redundancy this group is configured to support. The way a user queries what SLA th
# [[types]]
# schema = "InterconnectAttachmentGroupConfigured"
# include_fields = ["availabilitySla"]
#
#   availabilitySla: $ref: InterconnectAttachmentGroupConfiguredAvailabilitySLA, readOnly

# --- InterconnectAttachmentGroupConfiguredAvailabilitySLA (2 fields) ---
# [Output Only] Which SLA this group is configured to support, and why this group does or does not mee
# [[types]]
# schema = "InterconnectAttachmentGroupConfiguredAvailabilitySLA"
# include_fields = ["effectiveSla", "intendedSlaBlockers"]
#
#   effectiveSla: string, enum: [EFFECTIVE_SLA_UNSPECIFIED, NO_SLA, PRODUCTION_CRITICAL, PRODUCTION_NON_CRITICAL], readOnly
#   intendedSlaBlockers: array<InterconnectAttachmentGroupConfiguredAvailabilitySLAIntendedSlaBlockers>, readOnly
#
# [types.field_overrides]
# # effectiveSla = { enum_type = "InterconnectAttachmentGroupConfiguredAvailabilitySLAEffectiveSla" }

# --- InterconnectAttachmentGroupConfiguredAvailabilitySLAIntendedSlaBlockers (7 fields) ---
# [Output Only] Reasons why configuration.availabilitySLA.sla differs from intent.availabilitySLA. Thi
# [[types]]
# schema = "InterconnectAttachmentGroupConfiguredAvailabilitySLAIntendedSlaBlockers"
# include_fields = ["attachments", "blockerType", "documentationLink", "explanation", "metros", "regions", "zones"]
#
#   attachments: array<string>, readOnly
#   blockerType: string, enum: [BLOCKER_TYPE_UNSPECIFIED, INCOMPATIBLE_METROS, INCOMPATIBLE_REGIONS, MISSING_GLOBAL_ROUTING, ... +3], readOnly
#   documentationLink: string, readOnly
#   explanation: string, readOnly
#   metros: array<string>, readOnly
#   regions: array<string>, readOnly
#   zones: array<string>, readOnly
#
# [types.field_overrides]
# # blockerType = { enum_type = "InterconnectAttachmentGroupConfiguredAvailabilitySLAIntendedSlaBlockersBlockerType" }

# --- InterconnectAttachmentGroupIntent (1 fields) ---
# The user's intent for this AttachmentGroup. This is the only required field besides the name that mu
# [[types]]
# schema = "InterconnectAttachmentGroupIntent"
# include_fields = ["availabilitySla"]
#
#   availabilitySla: string, enum: [AVAILABILITY_SLA_UNSPECIFIED, NO_SLA, PRODUCTION_CRITICAL, PRODUCTION_NON_CRITICAL]
#
# [types.field_overrides]
# # availabilitySla = { enum_type = "InterconnectAttachmentGroupIntentAvailabilitySla" }

# --- InterconnectAttachmentGroupLogicalStructure (1 fields) ---
# [Output Only] An analysis of the logical layout of Attachments in this group. Every Attachment in th
# [[types]]
# schema = "InterconnectAttachmentGroupLogicalStructure"
# include_fields = ["regions"]
#
#   regions: array<InterconnectAttachmentGroupLogicalStructureRegion>, readOnly

# --- InterconnectAttachmentGroupLogicalStructureRegion (2 fields) ---
# [Output Only] The regions Attachments in this group are in.
# [[types]]
# schema = "InterconnectAttachmentGroupLogicalStructureRegion"
# include_fields = ["metros", "region"]
#
#   metros: array<InterconnectAttachmentGroupLogicalStructureRegionMetro>, readOnly
#   region: string, readOnly

# --- InterconnectAttachmentGroupLogicalStructureRegionMetro (2 fields) ---
# [Output Only] The metros of Attachments in this group in this region.
# [[types]]
# schema = "InterconnectAttachmentGroupLogicalStructureRegionMetro"
# include_fields = ["facilities", "metro"]
#
#   facilities: array<InterconnectAttachmentGroupLogicalStructureRegionMetroFacility>, readOnly
#   metro: string, readOnly

# --- InterconnectAttachmentGroupLogicalStructureRegionMetroFacility (2 fields) ---
# [Output Only] The facilities used for this group's Attachments' Interconnects.
# [[types]]
# schema = "InterconnectAttachmentGroupLogicalStructureRegionMetroFacility"
# include_fields = ["facility", "zones"]
#
#   facility: string, readOnly
#   zones: array<InterconnectAttachmentGroupLogicalStructureRegionMetroFacilityZone>, readOnly

# --- InterconnectAttachmentGroupLogicalStructureRegionMetroFacilityZone (2 fields) ---
# [Output Only] The zones that Attachments in this group are present in, in the given facilities. This
# [[types]]
# schema = "InterconnectAttachmentGroupLogicalStructureRegionMetroFacilityZone"
# include_fields = ["attachments", "zone"]
#
#   attachments: array<string>, readOnly
#   zone: string, readOnly

# --- InterconnectAttachmentGroupsGetOperationalStatusResponse (2 fields) ---
# Response for the InterconnectAttachmentGroupsGetOperationalStatusResponse.
# [[types]]
# schema = "InterconnectAttachmentGroupsGetOperationalStatusResponse"
# include_fields = ["etag", "result"]
#
#   etag: string
#   result: $ref: InterconnectAttachmentGroupsOperationalStatus

# --- InterconnectAttachmentGroupsListResponse (8 fields) ---
# [[types]]
# schema = "InterconnectAttachmentGroupsListResponse"
# include_fields = ["etag", "id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   etag: string
#   id: string
#   items: array<InterconnectAttachmentGroup>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string
#   unreachables: array<string>, readOnly
#   warning: object

# --- InterconnectAttachmentGroupsOperationalStatus (5 fields) ---
# [[types]]
# schema = "InterconnectAttachmentGroupsOperationalStatus"
# include_fields = ["attachmentStatuses", "configured", "groupStatus", "intent", "operational"]
#
#   attachmentStatuses: array<InterconnectAttachmentGroupsOperationalStatusAttachmentStatus>, readOnly
#   configured: $ref: InterconnectAttachmentGroupConfigured, readOnly
#   groupStatus: string, enum: [DEGRADED, FULLY_DOWN, FULLY_UP, UNSPECIFIED], readOnly
#   intent: $ref: InterconnectAttachmentGroupIntent, readOnly
#   operational: $ref: InterconnectAttachmentGroupConfigured, readOnly
#
# [types.field_overrides]
# # groupStatus = { enum_type = "InterconnectAttachmentGroupsOperationalStatusGroupStatus" }

# --- InterconnectAttachmentGroupsOperationalStatusAttachmentStatus (4 fields) ---
# The status of one Attachment in the group. List order is arbitrary.
# [[types]]
# schema = "InterconnectAttachmentGroupsOperationalStatusAttachmentStatus"
# include_fields = ["adminEnabled", "attachment", "isActive", "status"]
#
#   adminEnabled: boolean, readOnly
#   attachment: string, readOnly
#   isActive: string, enum: [ACTIVE, INACTIVE, UNSPECIFIED], readOnly
#   status: string, enum: [ATTACHMENT_STATUS_UNKNOWN, CONNECTION_DISABLED, CONNECTION_DOWN, CONNECTION_UP, ... +11], readOnly
#
# [types.field_overrides]
# # isActive = { enum_type = "InterconnectAttachmentGroupsOperationalStatusAttachmentStatusIsActive" }
# # status = { enum_type = "InterconnectAttachmentGroupsOperationalStatusAttachmentStatusStatus" }

# --- InterconnectAttachmentL2Forwarding (5 fields) ---
# L2 Interconnect Attachment related configuration.
# [[types]]
# schema = "InterconnectAttachmentL2Forwarding"
# include_fields = ["applianceMappings", "defaultApplianceIpAddress", "geneveHeader", "network", "tunnelEndpointIpAddress"]
#
#   applianceMappings: map<string, InterconnectAttachmentL2ForwardingApplianceMapping>
#   defaultApplianceIpAddress: string
#   geneveHeader: $ref: InterconnectAttachmentL2ForwardingGeneveHeader
#   network: string
#   tunnelEndpointIpAddress: string

# --- InterconnectAttachmentL2ForwardingApplianceMapping (3 fields) ---
# Two-level VLAN-to-Appliance mapping rule.
# [[types]]
# schema = "InterconnectAttachmentL2ForwardingApplianceMapping"
# include_fields = ["applianceIpAddress", "innerVlanToApplianceMappings", "name"]
#
#   applianceIpAddress: string
#   innerVlanToApplianceMappings: array<InterconnectAttachmentL2ForwardingApplianceMappingInnerVlanToApplianceMapping>
#   name: string
#
# [types.field_overrides]
# name = { required = true }

# --- InterconnectAttachmentL2ForwardingApplianceMappingInnerVlanToApplianceMapping (2 fields) ---
# The inner VLAN-to-Appliance mapping.
# [[types]]
# schema = "InterconnectAttachmentL2ForwardingApplianceMappingInnerVlanToApplianceMapping"
# include_fields = ["innerApplianceIpAddress", "innerVlanTags"]
#
#   innerApplianceIpAddress: string
#   innerVlanTags: array<string>

# --- InterconnectAttachmentL2ForwardingGeneveHeader (1 fields) ---
# GeneveHeader related configurations.
# [[types]]
# schema = "InterconnectAttachmentL2ForwardingGeneveHeader"
# include_fields = ["vni"]
#
#   vni: integer, format: uint32

# --- InterconnectAttachmentList (6 fields) ---
# Response to the list request, and contains a list of interconnect attachments.
# [[types]]
# schema = "InterconnectAttachmentList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<InterconnectAttachment>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- InterconnectAttachmentParams (1 fields) ---
# Additional interconnect attachment parameters.
# [[types]]
# schema = "InterconnectAttachmentParams"
# include_fields = ["resourceManagerTags"]
#
#   resourceManagerTags: map<string, string>

# --- InterconnectAttachmentPartnerMetadata (3 fields) ---
# Informational metadata about Partner attachments from Partners to display to customers. These fields
# [[types]]
# schema = "InterconnectAttachmentPartnerMetadata"
# include_fields = ["interconnectName", "partnerName", "portalUrl"]
#
#   interconnectName: string
#   partnerName: string
#   portalUrl: string

# --- InterconnectAttachmentPrivateInfo (1 fields) ---
# Information for an interconnect attachment when this belongs to an interconnect of type DEDICATED.
# [[types]]
# schema = "InterconnectAttachmentPrivateInfo"
# include_fields = ["tag8021q"]
#
#   tag8021q: integer, format: uint32

# --- InterconnectAttachmentsScopedList (2 fields) ---
# [[types]]
# schema = "InterconnectAttachmentsScopedList"
# include_fields = ["interconnectAttachments", "warning"]
#
#   interconnectAttachments: array<InterconnectAttachment>
#   warning: object

# --- InterconnectCircuitInfo (3 fields) ---
# Describes a single physical circuit between the Customer and Google. CircuitInfo objects are created
# [[types]]
# schema = "InterconnectCircuitInfo"
# include_fields = ["customerDemarcId", "googleCircuitId", "googleDemarcId"]
#
#   customerDemarcId: string
#   googleCircuitId: string
#   googleDemarcId: string

# --- InterconnectDiagnostics (5 fields) ---
# Diagnostics information about the Interconnect connection, which contains detailed and current techn
# [[types]]
# schema = "InterconnectDiagnostics"
# include_fields = ["arpCaches", "bundleAggregationType", "bundleOperationalStatus", "links", "macAddress"]
#
#   arpCaches: array<InterconnectDiagnosticsARPEntry>
#   bundleAggregationType: string, enum: [BUNDLE_AGGREGATION_TYPE_LACP, BUNDLE_AGGREGATION_TYPE_STATIC]
#   bundleOperationalStatus: string, enum: [BUNDLE_OPERATIONAL_STATUS_DOWN, BUNDLE_OPERATIONAL_STATUS_UP]
#   links: array<InterconnectDiagnosticsLinkStatus>
#   macAddress: string
#
# [types.field_overrides]
# # bundleAggregationType = { enum_type = "InterconnectDiagnosticsBundleAggregationType" }
# # bundleOperationalStatus = { enum_type = "InterconnectDiagnosticsBundleOperationalStatus" }

# --- InterconnectDiagnosticsARPEntry (2 fields) ---
# Describing the ARP neighbor entries seen on this link
# [[types]]
# schema = "InterconnectDiagnosticsARPEntry"
# include_fields = ["ipAddress", "macAddress"]
#
#   ipAddress: string
#   macAddress: string

# --- InterconnectDiagnosticsLinkLACPStatus (3 fields) ---
# [[types]]
# schema = "InterconnectDiagnosticsLinkLACPStatus"
# include_fields = ["googleSystemId", "neighborSystemId", "state"]
#
#   googleSystemId: string
#   neighborSystemId: string
#   state: string, enum: [ACTIVE, DETACHED]
#
# [types.field_overrides]
# # state = { enum_type = "InterconnectDiagnosticsLinkLACPStatusState" }

# --- InterconnectDiagnosticsLinkOpticalPower (2 fields) ---
# [[types]]
# schema = "InterconnectDiagnosticsLinkOpticalPower"
# include_fields = ["state", "value"]
#
#   state: string, enum: [HIGH_ALARM, HIGH_WARNING, LOW_ALARM, LOW_WARNING, OK]
#   value: number, format: float
#
# [types.field_overrides]
# # state = { enum_type = "InterconnectDiagnosticsLinkOpticalPowerState" }

# --- InterconnectDiagnosticsLinkStatus (8 fields) ---
# [[types]]
# schema = "InterconnectDiagnosticsLinkStatus"
# include_fields = ["arpCaches", "circuitId", "googleDemarc", "lacpStatus", "macsec", "operationalStatus", "receivingOpticalPower", "transmittingOpticalPower"]
#
#   arpCaches: array<InterconnectDiagnosticsARPEntry>
#   circuitId: string
#   googleDemarc: string
#   lacpStatus: $ref: InterconnectDiagnosticsLinkLACPStatus
#   macsec: $ref: InterconnectDiagnosticsMacsecStatus
#   operationalStatus: string, enum: [LINK_OPERATIONAL_STATUS_DOWN, LINK_OPERATIONAL_STATUS_UP]
#   receivingOpticalPower: $ref: InterconnectDiagnosticsLinkOpticalPower
#   transmittingOpticalPower: $ref: InterconnectDiagnosticsLinkOpticalPower
#
# [types.field_overrides]
# # operationalStatus = { enum_type = "InterconnectDiagnosticsLinkStatusOperationalStatus" }

# --- InterconnectDiagnosticsMacsecStatus (2 fields) ---
# Describes the status of MACsec encryption on the link.
# [[types]]
# schema = "InterconnectDiagnosticsMacsecStatus"
# include_fields = ["ckn", "operational"]
#
#   ckn: string
#   operational: boolean

# --- InterconnectGroup (11 fields) ---
# An interconnect group resource allows customers to create, analyze, and expand their redundant conne
# [[types]]
# schema = "InterconnectGroup"
# include_fields = ["configured", "creationTimestamp", "description", "etag", "id", "intent", "interconnects", "kind", "name", "physicalStructure", "selfLink"]
#
#   configured: $ref: InterconnectGroupConfigured, readOnly
#   creationTimestamp: string, readOnly
#   description: string
#   etag: string
#   id: string, format: uint64, readOnly
#   intent: $ref: InterconnectGroupIntent
#   interconnects: map<string, InterconnectGroupInterconnect>
#   kind: string, readOnly
#   name: string
#   physicalStructure: $ref: InterconnectGroupPhysicalStructure, readOnly
#   selfLink: string, readOnly
#
# [types.field_overrides]
# name = { required = true }

# --- InterconnectGroupConfigured (1 fields) ---
# [Output Only] The status of the group as configured. This has the same structure as the operational 
# [[types]]
# schema = "InterconnectGroupConfigured"
# include_fields = ["topologyCapability"]
#
#   topologyCapability: $ref: InterconnectGroupConfiguredTopologyCapability, readOnly

# --- InterconnectGroupConfiguredTopologyCapability (2 fields) ---
# [Output Only] How reliable this topology is configured to be, and why this group does or does not me
# [[types]]
# schema = "InterconnectGroupConfiguredTopologyCapability"
# include_fields = ["intendedCapabilityBlockers", "supportedSla"]
#
#   intendedCapabilityBlockers: array<InterconnectGroupConfiguredTopologyCapabilityIntendedCapabilityBlockers>, readOnly
#   supportedSla: string, enum: [NO_SLA, PRODUCTION_CRITICAL, PRODUCTION_NON_CRITICAL, UNSPECIFIED], readOnly
#
# [types.field_overrides]
# # supportedSla = { enum_type = "InterconnectGroupConfiguredTopologyCapabilitySupportedSla" }

# --- InterconnectGroupConfiguredTopologyCapabilityIntendedCapabilityBlockers (7 fields) ---
# [Output Only] Reasons why configuration.topologyCapability.sla differs from intent.topologyCapabilit
# [[types]]
# schema = "InterconnectGroupConfiguredTopologyCapabilityIntendedCapabilityBlockers"
# include_fields = ["blockerType", "documentationLink", "explanation", "facilities", "interconnects", "metros", "zones"]
#
#   blockerType: string, enum: [INCOMPATIBLE_METROS, NOT_AVAILABLE, NO_INTERCONNECTS, NO_INTERCONNECTS_IN_METRO_AND_ZONE, ... +2], readOnly
#   documentationLink: string, readOnly
#   explanation: string, readOnly
#   facilities: array<string>, readOnly
#   interconnects: array<string>, readOnly
#   metros: array<string>, readOnly
#   zones: array<string>, readOnly
#
# [types.field_overrides]
# # blockerType = { enum_type = "InterconnectGroupConfiguredTopologyCapabilityIntendedCapabilityBlockersBlockerType" }

# --- InterconnectGroupIntent (1 fields) ---
# The user's intent for this group. This is the only required field besides the name that must be spec
# [[types]]
# schema = "InterconnectGroupIntent"
# include_fields = ["topologyCapability"]
#
#   topologyCapability: string, enum: [NO_SLA, PRODUCTION_CRITICAL, PRODUCTION_NON_CRITICAL, UNSPECIFIED]
#
# [types.field_overrides]
# # topologyCapability = { enum_type = "InterconnectGroupIntentTopologyCapability" }

# --- InterconnectGroupInterconnect (1 fields) ---
# An Interconnect in this InterconnectGroup.
# [[types]]
# schema = "InterconnectGroupInterconnect"
# include_fields = ["interconnect"]
#
#   interconnect: string

# --- InterconnectGroupPhysicalStructure (1 fields) ---
# [Output Only] An analysis of the physical layout of Interconnects in this group. Every Interconnect 
# [[types]]
# schema = "InterconnectGroupPhysicalStructure"
# include_fields = ["metros"]
#
#   metros: array<InterconnectGroupPhysicalStructureMetros>, readOnly

# --- InterconnectGroupPhysicalStructureMetros (2 fields) ---
# [Output Only] The metros Interconnects in this group are in.
# [[types]]
# schema = "InterconnectGroupPhysicalStructureMetros"
# include_fields = ["facilities", "metro"]
#
#   facilities: array<InterconnectGroupPhysicalStructureMetrosFacilities>, readOnly
#   metro: string, readOnly

# --- InterconnectGroupPhysicalStructureMetrosFacilities (2 fields) ---
# [Output Only] The facilities Interconnects in this metro are present in.
# [[types]]
# schema = "InterconnectGroupPhysicalStructureMetrosFacilities"
# include_fields = ["facility", "zones"]
#
#   facility: string, readOnly
#   zones: array<InterconnectGroupPhysicalStructureMetrosFacilitiesZones>, readOnly

# --- InterconnectGroupPhysicalStructureMetrosFacilitiesZones (2 fields) ---
# [Output Only] The zones that Interconnects in this facility are present in.
# [[types]]
# schema = "InterconnectGroupPhysicalStructureMetrosFacilitiesZones"
# include_fields = ["interconnects", "zone"]
#
#   interconnects: array<string>, readOnly
#   zone: string, readOnly

# --- InterconnectGroupsCreateMembers (3 fields) ---
# [[types]]
# schema = "InterconnectGroupsCreateMembers"
# include_fields = ["intentMismatchBehavior", "interconnects", "templateInterconnect"]
#
#   intentMismatchBehavior: string, enum: [CREATE, REJECT, UNSPECIFIED]
#   interconnects: array<InterconnectGroupsCreateMembersInterconnectInput>
#   templateInterconnect: $ref: InterconnectGroupsCreateMembersInterconnectInput
#
# [types.field_overrides]
# # intentMismatchBehavior = { enum_type = "InterconnectGroupsCreateMembersIntentMismatchBehavior" }

# --- InterconnectGroupsCreateMembersInterconnectInput (11 fields) ---
# LINT.IfChange
# [[types]]
# schema = "InterconnectGroupsCreateMembersInterconnectInput"
# include_fields = ["adminEnabled", "customerName", "description", "facility", "interconnectType", "linkType", "name", "nocContactEmail", "remoteLocation", "requestedFeatures", "requestedLinkCount"]
#
#   adminEnabled: boolean
#   customerName: string
#   description: string
#   facility: string
#   interconnectType: string, enum: [DEDICATED, IT_PRIVATE, PARTNER]
#   linkType: string, enum: [LINK_TYPE_ETHERNET_100G_LR, LINK_TYPE_ETHERNET_10G_LR, LINK_TYPE_ETHERNET_400G_LR4]
#   name: string
#   nocContactEmail: string
#   remoteLocation: string
#   requestedFeatures: array<string>
#   requestedLinkCount: integer, format: int32
#
# [types.field_overrides]
# name = { required = true }
# # interconnectType = { enum_type = "InterconnectGroupsCreateMembersInterconnectInputInterconnectType" }
# # linkType = { enum_type = "InterconnectGroupsCreateMembersInterconnectInputLinkType" }

# --- InterconnectGroupsCreateMembersRequest (1 fields) ---
# [[types]]
# schema = "InterconnectGroupsCreateMembersRequest"
# include_fields = ["request"]
#
#   request: $ref: InterconnectGroupsCreateMembers

# --- InterconnectGroupsGetOperationalStatusResponse (2 fields) ---
# Response for the InterconnectGroupsGetOperationalStatusResponse.
# [[types]]
# schema = "InterconnectGroupsGetOperationalStatusResponse"
# include_fields = ["etag", "result"]
#
#   etag: string
#   result: $ref: InterconnectGroupsOperationalStatus

# --- InterconnectGroupsListResponse (8 fields) ---
# [[types]]
# schema = "InterconnectGroupsListResponse"
# include_fields = ["etag", "id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   etag: string
#   id: string
#   items: array<InterconnectGroup>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string
#   unreachables: array<string>, readOnly
#   warning: object

# --- InterconnectGroupsOperationalStatus (5 fields) ---
# Request to get the status of the interconnect group with extra detail.
# [[types]]
# schema = "InterconnectGroupsOperationalStatus"
# include_fields = ["configured", "groupStatus", "intent", "interconnectStatuses", "operational"]
#
#   configured: $ref: InterconnectGroupConfigured, readOnly
#   groupStatus: string, enum: [DEGRADED, FULLY_DOWN, FULLY_UP, GROUPS_STATUS_UNSPECIFIED], readOnly
#   intent: $ref: InterconnectGroupIntent, readOnly
#   interconnectStatuses: array<InterconnectGroupsOperationalStatusInterconnectStatus>, readOnly
#   operational: $ref: InterconnectGroupConfigured, readOnly
#
# [types.field_overrides]
# # groupStatus = { enum_type = "InterconnectGroupsOperationalStatusGroupStatus" }

# --- InterconnectGroupsOperationalStatusInterconnectStatus (4 fields) ---
# The status of one Interconnect in the group. The order is arbitrary.
# [[types]]
# schema = "InterconnectGroupsOperationalStatusInterconnectStatus"
# include_fields = ["adminEnabled", "diagnostics", "interconnect", "isActive"]
#
#   adminEnabled: boolean, readOnly
#   diagnostics: $ref: InterconnectDiagnostics, readOnly
#   interconnect: string, readOnly
#   isActive: string, enum: [ACTIVE, INACTIVE, IS_ACTIVE_UNSPECIFIED], readOnly
#
# [types.field_overrides]
# # isActive = { enum_type = "InterconnectGroupsOperationalStatusInterconnectStatusIsActive" }

# --- InterconnectList (6 fields) ---
# Response to the list request, and contains a list of interconnects.
# [[types]]
# schema = "InterconnectList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<Interconnect>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- InterconnectLocation (20 fields) ---
# Represents an Interconnect Attachment (VLAN) Location resource. You can use this resource to find lo
# [[types]]
# schema = "InterconnectLocation"
# include_fields = ["address", "availabilityZone", "availableFeatures", "availableLinkTypes", "city", "continent", "creationTimestamp", "crossSiteInterconnectInfos", "description", "facilityProvider", "facilityProviderFacilityId", "id", "kind", "name", "peeringdbFacilityId", "regionInfos", "selfLink", "singleRegionProductionCriticalPeerLocations", "status", "supportsPzs"]
#
#   address: string, readOnly
#   availabilityZone: string
#   availableFeatures: array<string>
#   availableLinkTypes: array<string>
#   city: string
#   continent: string, enum: [AFRICA, ASIA_PAC, C_AFRICA, C_ASIA_PAC, ... +6]
#   creationTimestamp: string, readOnly
#   crossSiteInterconnectInfos: array<InterconnectLocationCrossSiteInterconnectInfo>
#   description: string, readOnly
#   facilityProvider: string, readOnly
#   facilityProviderFacilityId: string, readOnly
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   name: string, readOnly
#   peeringdbFacilityId: string, readOnly
#   regionInfos: array<InterconnectLocationRegionInfo>, readOnly
#   selfLink: string, readOnly
#   singleRegionProductionCriticalPeerLocations: array<string>, readOnly
#   status: string, enum: [AVAILABLE, CLOSED]
#   supportsPzs: boolean, readOnly
#
# [types.field_overrides]
# name = { required = true }
# # status = { enum_type = "InterconnectLocationStatus" }
# # continent = { enum_type = "InterconnectLocationContinent" }

# --- InterconnectLocationCrossSiteInterconnectInfo (1 fields) ---
# Information about Cross-Site Interconnect wires which may be created between the containing location
# [[types]]
# schema = "InterconnectLocationCrossSiteInterconnectInfo"
# include_fields = ["city"]
#
#   city: string, readOnly

# --- InterconnectLocationList (6 fields) ---
# Response to the list request, and contains a list of interconnect locations.
# [[types]]
# schema = "InterconnectLocationList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<InterconnectLocation>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- InterconnectLocationRegionInfo (4 fields) ---
# Information about any potential InterconnectAttachments between an Interconnect at a specific Interc
# [[types]]
# schema = "InterconnectLocationRegionInfo"
# include_fields = ["expectedRttMs", "l2ForwardingEnabled", "locationPresence", "region"]
#
#   expectedRttMs: string, format: int64, readOnly
#   l2ForwardingEnabled: boolean, readOnly
#   locationPresence: string, enum: [GLOBAL, LOCAL_REGION, LP_GLOBAL, LP_LOCAL_REGION], readOnly
#   region: string, readOnly
#
# [types.field_overrides]
# # locationPresence = { enum_type = "InterconnectLocationRegionInfoLocationPresence" }

# --- InterconnectMacsec (2 fields) ---
# Configuration information for enabling Media Access Control security (MACsec) on this Cloud Intercon
# [[types]]
# schema = "InterconnectMacsec"
# include_fields = ["failOpen", "preSharedKeys"]
#
#   failOpen: boolean
#   preSharedKeys: array<InterconnectMacsecPreSharedKey>

# --- InterconnectMacsecConfig (1 fields) ---
# MACsec configuration information for the Interconnect connection. Contains the generated Connectivit
# [[types]]
# schema = "InterconnectMacsecConfig"
# include_fields = ["preSharedKeys"]
#
#   preSharedKeys: array<InterconnectMacsecConfigPreSharedKey>

# --- InterconnectMacsecConfigPreSharedKey (4 fields) ---
# Describes a pre-shared key used to setup MACsec in static connectivity association key (CAK) mode.
# [[types]]
# schema = "InterconnectMacsecConfigPreSharedKey"
# include_fields = ["cak", "ckn", "name", "startTime"]
#
#   cak: string
#   ckn: string
#   name: string
#   startTime: string
#
# [types.field_overrides]
# name = { required = true }

# --- InterconnectMacsecPreSharedKey (2 fields) ---
# Describes a pre-shared key used to setup MACsec in static connectivity association key (CAK) mode.
# [[types]]
# schema = "InterconnectMacsecPreSharedKey"
# include_fields = ["name", "startTime"]
#
#   name: string
#   startTime: string
#
# [types.field_overrides]
# name = { required = true }

# --- InterconnectOutageNotification (8 fields) ---
# Description of a planned outage on this Interconnect.
# [[types]]
# schema = "InterconnectOutageNotification"
# include_fields = ["affectedCircuits", "description", "endTime", "issueType", "name", "source", "startTime", "state"]
#
#   affectedCircuits: array<string>
#   description: string
#   endTime: string, format: int64
#   issueType: string, enum: [IT_OUTAGE, IT_PARTIAL_OUTAGE, OUTAGE, PARTIAL_OUTAGE]
#   name: string
#   source: string, enum: [GOOGLE, NSRC_GOOGLE]
#   startTime: string, format: int64
#   state: string, enum: [ACTIVE, CANCELLED, COMPLETED, NS_ACTIVE, NS_CANCELED]
#
# [types.field_overrides]
# name = { required = true }
# # issueType = { enum_type = "InterconnectOutageNotificationIssueType" }
# # source = { enum_type = "InterconnectOutageNotificationSource" }
# # state = { enum_type = "InterconnectOutageNotificationState" }

# --- InterconnectParams (1 fields) ---
# Additional interconnect parameters.
# [[types]]
# schema = "InterconnectParams"
# include_fields = ["resourceManagerTags"]
#
#   resourceManagerTags: map<string, string>

# --- InterconnectRemoteLocation (21 fields) ---
# Represents a Cross-Cloud Interconnect Remote Location resource. You can use this resource to find re
# [[types]]
# schema = "InterconnectRemoteLocation"
# include_fields = ["address", "attachmentConfigurationConstraints", "city", "constraints", "continent", "creationTimestamp", "description", "facilityProvider", "facilityProviderFacilityId", "id", "kind", "lacp", "maxLagSize100Gbps", "maxLagSize10Gbps", "maxLagSize400Gbps", "name", "peeringdbFacilityId", "permittedConnections", "remoteService", "selfLink", "status"]
#
#   address: string, readOnly
#   attachmentConfigurationConstraints: $ref: InterconnectAttachmentConfigurationConstraints, readOnly
#   city: string, readOnly
#   constraints: $ref: InterconnectRemoteLocationConstraints, readOnly
#   continent: string, enum: [AFRICA, ASIA_PAC, EUROPE, NORTH_AMERICA, SOUTH_AMERICA], readOnly
#   creationTimestamp: string, readOnly
#   description: string, readOnly
#   facilityProvider: string, readOnly
#   facilityProviderFacilityId: string, readOnly
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   lacp: string, enum: [LACP_SUPPORTED, LACP_UNSUPPORTED], readOnly
#   maxLagSize100Gbps: integer, format: int32, readOnly
#   maxLagSize10Gbps: integer, format: int32, readOnly
#   maxLagSize400Gbps: integer, format: int32, readOnly
#   name: string, readOnly
#   peeringdbFacilityId: string, readOnly
#   permittedConnections: array<InterconnectRemoteLocationPermittedConnections>, readOnly
#   remoteService: string, readOnly
#   selfLink: string, readOnly
#   status: string, enum: [AVAILABLE, CLOSED], readOnly
#
# [types.field_overrides]
# name = { required = true }
# # continent = { enum_type = "InterconnectRemoteLocationContinent" }
# # status = { enum_type = "InterconnectRemoteLocationStatus" }
# # lacp = { enum_type = "InterconnectRemoteLocationLacp" }

# --- InterconnectRemoteLocationConstraints (3 fields) ---
# [[types]]
# schema = "InterconnectRemoteLocationConstraints"
# include_fields = ["portPairRemoteLocation", "portPairVlan", "subnetLengthRange"]
#
#   portPairRemoteLocation: string, enum: [PORT_PAIR_MATCHING_REMOTE_LOCATION, PORT_PAIR_UNCONSTRAINED_REMOTE_LOCATION], readOnly
#   portPairVlan: string, enum: [PORT_PAIR_MATCHING_VLAN, PORT_PAIR_UNCONSTRAINED_VLAN], readOnly
#   subnetLengthRange: $ref: InterconnectRemoteLocationConstraintsSubnetLengthRange, readOnly
#
# [types.field_overrides]
# # portPairRemoteLocation = { enum_type = "InterconnectRemoteLocationConstraintsPortPairRemoteLocation" }
# # portPairVlan = { enum_type = "InterconnectRemoteLocationConstraintsPortPairVlan" }

# --- InterconnectRemoteLocationConstraintsSubnetLengthRange (2 fields) ---
# [[types]]
# schema = "InterconnectRemoteLocationConstraintsSubnetLengthRange"
# include_fields = ["max", "min"]
#
#   max: integer, format: int32
#   min: integer, format: int32

# --- InterconnectRemoteLocationList (6 fields) ---
# Response to the list request, and contains a list of interconnect remote locations.
# [[types]]
# schema = "InterconnectRemoteLocationList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<InterconnectRemoteLocation>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- InterconnectRemoteLocationPermittedConnections (1 fields) ---
# [[types]]
# schema = "InterconnectRemoteLocationPermittedConnections"
# include_fields = ["interconnectLocation"]
#
#   interconnectLocation: string, readOnly

# --- InterconnectsGetDiagnosticsResponse (1 fields) ---
# Response for the InterconnectsGetDiagnosticsRequest.
# [[types]]
# schema = "InterconnectsGetDiagnosticsResponse"
# include_fields = ["result"]
#
#   result: $ref: InterconnectDiagnostics

# --- InterconnectsGetMacsecConfigResponse (2 fields) ---
# Response for the InterconnectsGetMacsecConfigRequest.
# [[types]]
# schema = "InterconnectsGetMacsecConfigResponse"
# include_fields = ["etag", "result"]
#
#   etag: string
#   result: $ref: InterconnectMacsecConfig

# --- License (22 fields) ---
# Represents a License resource. A License represents billing and aggregate usage data forpublic andma
# [[types]]
# schema = "License"
# include_fields = ["allowedReplacementLicenses", "appendableToDisk", "chargesUseFee", "creationTimestamp", "description", "id", "incompatibleLicenses", "kind", "licenseCode", "minimumRetention", "multiTenantOnly", "name", "osLicense", "params", "removableFromDisk", "requiredCoattachedLicenses", "resourceRequirements", "selfLink", "selfLinkWithId", "soleTenantOnly", "transferable", "updateTimestamp"]
#
#   allowedReplacementLicenses: array<string>
#   appendableToDisk: boolean
#   chargesUseFee: boolean
#   creationTimestamp: string, readOnly
#   description: string
#   id: string, format: uint64
#   incompatibleLicenses: array<string>
#   kind: string, readOnly
#   licenseCode: string, format: uint64
#   minimumRetention: $ref: Duration
#   multiTenantOnly: boolean
#   name: string
#   osLicense: boolean
#   params: $ref: LicenseParams
#   removableFromDisk: boolean
#   requiredCoattachedLicenses: array<string>
#   resourceRequirements: $ref: LicenseResourceRequirements
#   selfLink: string, readOnly
#   selfLinkWithId: string, readOnly
#   soleTenantOnly: boolean
#   transferable: boolean
#   updateTimestamp: string, readOnly
#
# [types.field_overrides]
# name = { required = true }

# --- LicenseCode (9 fields) ---
# Represents a License Code resource. A License Code is a unique identifier used to represent alicense
# [[types]]
# schema = "LicenseCode"
# include_fields = ["creationTimestamp", "description", "id", "kind", "licenseAlias", "name", "selfLink", "state", "transferable"]
#
#   creationTimestamp: string, readOnly
#   description: string, readOnly
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   licenseAlias: array<LicenseCodeLicenseAlias>
#   name: string, readOnly
#   selfLink: string, readOnly
#   state: string, enum: [DISABLED, ENABLED, RESTRICTED, STATE_UNSPECIFIED, TERMINATED], readOnly
#   transferable: boolean, readOnly
#
# [types.field_overrides]
# name = { required = true }
# # state = { enum_type = "LicenseCodeState" }

# --- LicenseCodeLicenseAlias (2 fields) ---
# [[types]]
# schema = "LicenseCodeLicenseAlias"
# include_fields = ["description", "selfLink"]
#
#   description: string, readOnly
#   selfLink: string, readOnly

# --- LicenseParams (1 fields) ---
# Additional license params.
# [[types]]
# schema = "LicenseParams"
# include_fields = ["resourceManagerTags"]
#
#   resourceManagerTags: map<string, string>

# --- LicenseResourceCommitment (3 fields) ---
# Commitment for a particular license resource.
# [[types]]
# schema = "LicenseResourceCommitment"
# include_fields = ["amount", "coresPerLicense", "license"]
#
#   amount: string, format: int64
#   coresPerLicense: string
#   license: string

# --- LicenseResourceRequirements (2 fields) ---
# [[types]]
# schema = "LicenseResourceRequirements"
# include_fields = ["minGuestCpuCount", "minMemoryMb"]
#
#   minGuestCpuCount: integer, format: int32
#   minMemoryMb: integer, format: int32

# --- LicensesListResponse (5 fields) ---
# [[types]]
# schema = "LicensesListResponse"
# include_fields = ["id", "items", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<License>
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- LocalDisk (3 fields) ---
# [[types]]
# schema = "LocalDisk"
# include_fields = ["diskCount", "diskSizeGb", "diskType"]
#
#   diskCount: integer, format: int32
#   diskSizeGb: integer, format: int32
#   diskType: string

# --- LocalizedMessage (2 fields) ---
# Provides a localized error message that is safe to return to the user which can be attached to an RP
# [[types]]
# schema = "LocalizedMessage"
# include_fields = ["locale", "message"]
#
#   locale: string
#   message: string

# --- LocationPolicy (2 fields) ---
# Configuration for location policy among multiple possible locations (e.g. preferences for zone selec
# [[types]]
# schema = "LocationPolicy"
# include_fields = ["locations", "targetShape"]
#
#   locations: map<string, LocationPolicyLocation>
#   targetShape: string, enum: [ANY, ANY_SINGLE_ZONE, BALANCED]
#
# [types.field_overrides]
# # targetShape = { enum_type = "LocationPolicyTargetShape" }

# --- LocationPolicyLocation (2 fields) ---
# [[types]]
# schema = "LocationPolicyLocation"
# include_fields = ["constraints", "preference"]
#
#   constraints: $ref: LocationPolicyLocationConstraints
#   preference: string, enum: [ALLOW, DENY, PREFERENCE_UNSPECIFIED]
#
# [types.field_overrides]
# # preference = { enum_type = "LocationPolicyLocationPreference" }

# --- LocationPolicyLocationConstraints (1 fields) ---
# Per-zone constraints on location policy for this zone.
# [[types]]
# schema = "LocationPolicyLocationConstraints"
# include_fields = ["maxCount"]
#
#   maxCount: integer, format: int32

# --- MachineImage (21 fields) ---
# Represents a machine image resource. A machine image is a Compute Engine resource that stores all th
# WARNING: format:"byte" fields: labelFingerprint
# [[types]]
# schema = "MachineImage"
# include_fields = ["creationTimestamp", "description", "guestFlush", "id", "instanceProperties", "kind", "labelFingerprint", "labels", "machineImageEncryptionKey", "name", "params", "satisfiesPzi", "satisfiesPzs", "savedDisks", "selfLink", "sourceDiskEncryptionKeys", "sourceInstance", "sourceInstanceProperties", "status", "storageLocations", "totalStorageBytes"]
#
#   creationTimestamp: string, readOnly
#   description: string
#   guestFlush: boolean
#   id: string, format: uint64, readOnly
#   instanceProperties: $ref: InstanceProperties
#   kind: string, readOnly
#   labelFingerprint: string, format: byte
#   labels: map<string, string>
#   machineImageEncryptionKey: $ref: CustomerEncryptionKey
#   name: string
#   params: $ref: MachineImageParams
#   satisfiesPzi: boolean, readOnly
#   satisfiesPzs: boolean, readOnly
#   savedDisks: array<SavedDisk>, readOnly
#   selfLink: string, readOnly
#   sourceDiskEncryptionKeys: array<SourceDiskEncryptionKey>
#   sourceInstance: string
#   sourceInstanceProperties: $ref: SourceInstanceProperties, readOnly
#   status: string, enum: [CREATING, DELETING, INVALID, READY, UPLOADING], readOnly
#   storageLocations: array<string>
#   totalStorageBytes: string, format: int64, readOnly
#
# [types.field_overrides]
# name = { required = true }
# labelFingerprint = { format = "bytes" }
# # status = { enum_type = "MachineImageStatus" }

# --- MachineImageList (6 fields) ---
# A list of machine images.
# [[types]]
# schema = "MachineImageList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<MachineImage>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- MachineImageParams (1 fields) ---
# Machine Image parameters
# [[types]]
# schema = "MachineImageParams"
# include_fields = ["resourceManagerTags"]
#
#   resourceManagerTags: map<string, string>

# --- MachineType (17 fields) ---
# Represents a Machine Type resource. You can use specific machine types for your VM instances based o
# [[types]]
# schema = "MachineType"
# include_fields = ["accelerators", "architecture", "bundledLocalSsds", "creationTimestamp", "deprecated", "description", "guestCpus", "id", "imageSpaceGb", "isSharedCpu", "kind", "maximumPersistentDisks", "maximumPersistentDisksSizeGb", "memoryMb", "name", "selfLink", "zone"]
#
#   accelerators: array<object>
#   architecture: string, enum: [ARCHITECTURE_UNSPECIFIED, ARM64, X86_64]
#   bundledLocalSsds: $ref: BundledLocalSsds
#   creationTimestamp: string
#   deprecated: $ref: DeprecationStatus
#   description: string
#   guestCpus: integer, format: int32
#   id: string, format: uint64
#   imageSpaceGb: integer, format: int32
#   isSharedCpu: boolean
#   kind: string, readOnly
#   maximumPersistentDisks: integer, format: int32
#   maximumPersistentDisksSizeGb: string, format: int64
#   memoryMb: integer, format: int32
#   name: string
#   selfLink: string
#   zone: string
#
# [types.field_overrides]
# name = { required = true }
# # architecture = { enum_type = "MachineTypeArchitecture" }

# --- MachineTypeAggregatedList (7 fields) ---
# [[types]]
# schema = "MachineTypeAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, MachineTypesScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- MachineTypeList (6 fields) ---
# Contains a list of machine types.
# [[types]]
# schema = "MachineTypeList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<MachineType>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- MachineTypesScopedList (2 fields) ---
# [[types]]
# schema = "MachineTypesScopedList"
# include_fields = ["machineTypes", "warning"]
#
#   machineTypes: array<MachineType>
#   warning: object

# --- ManagedInstance (11 fields) ---
# A Managed Instance resource.
# [[types]]
# schema = "ManagedInstance"
# include_fields = ["currentAction", "id", "instance", "instanceHealth", "instanceStatus", "lastAttempt", "name", "preservedStateFromConfig", "preservedStateFromPolicy", "propertiesFromFlexibilityPolicy", "version"]
#
#   currentAction: string, enum: [ABANDONING, CREATING, CREATING_WITHOUT_RETRIES, DELETING, ... +9], readOnly
#   id: string, format: uint64, readOnly
#   instance: string, readOnly
#   instanceHealth: array<ManagedInstanceInstanceHealth>, readOnly
#   instanceStatus: string, enum: [DEPROVISIONING, PENDING, PROVISIONING, REPAIRING, ... +7], readOnly
#   lastAttempt: $ref: ManagedInstanceLastAttempt, readOnly
#   name: string, readOnly
#   preservedStateFromConfig: $ref: PreservedState, readOnly
#   preservedStateFromPolicy: $ref: PreservedState, readOnly
#   propertiesFromFlexibilityPolicy: $ref: ManagedInstancePropertiesFromFlexibilityPolicy, readOnly
#   version: $ref: ManagedInstanceVersion, readOnly
#
# [types.field_overrides]
# name = { required = true }
# # instanceStatus = { enum_type = "ManagedInstanceInstanceStatus" }
# # currentAction = { enum_type = "ManagedInstanceCurrentAction" }

# --- ManagedInstanceInstanceHealth (2 fields) ---
# [[types]]
# schema = "ManagedInstanceInstanceHealth"
# include_fields = ["detailedHealthState", "healthCheck"]
#
#   detailedHealthState: string, enum: [DRAINING, HEALTHY, TIMEOUT, UNHEALTHY, UNKNOWN], readOnly
#   healthCheck: string, readOnly
#
# [types.field_overrides]
# # detailedHealthState = { enum_type = "ManagedInstanceInstanceHealthDetailedHealthState" }

# --- ManagedInstanceLastAttempt (1 fields) ---
# [[types]]
# schema = "ManagedInstanceLastAttempt"
# include_fields = ["errors"]
#
#   errors: object, readOnly

# --- ManagedInstancePropertiesFromFlexibilityPolicy (1 fields) ---
# [[types]]
# schema = "ManagedInstancePropertiesFromFlexibilityPolicy"
# include_fields = ["machineType"]
#
#   machineType: string, readOnly

# --- ManagedInstanceVersion (2 fields) ---
# [[types]]
# schema = "ManagedInstanceVersion"
# include_fields = ["instanceTemplate", "name"]
#
#   instanceTemplate: string, readOnly
#   name: string, readOnly
#
# [types.field_overrides]
# name = { required = true }

# --- Metadata (3 fields) [IN MANIFEST] ---
# A metadata key/value entry.
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "Metadata"
# include_fields = ["fingerprint", "items", "kind"]
#
#   fingerprint: string, format: byte
#   items: array<object>
#   kind: string, readOnly
#
# [types.field_overrides]
# fingerprint = { format = "bytes" }

# --- MetadataFilter (2 fields) ---
# Opaque filter criteria used by load balancers to restrict routing configuration to a limited set of 
# [[types]]
# schema = "MetadataFilter"
# include_fields = ["filterLabels", "filterMatchCriteria"]
#
#   filterLabels: array<MetadataFilterLabelMatch>
#   filterMatchCriteria: string, enum: [MATCH_ALL, MATCH_ANY, NOT_SET]
#
# [types.field_overrides]
# # filterMatchCriteria = { enum_type = "MetadataFilterFilterMatchCriteria" }

# --- MetadataFilterLabelMatch (2 fields) ---
# MetadataFilter label name value pairs that are expected to match corresponding labels presented as m
# [[types]]
# schema = "MetadataFilterLabelMatch"
# include_fields = ["name", "value"]
#
#   name: string
#   value: string
#
# [types.field_overrides]
# name = { required = true }

# --- NamedPort (2 fields) ---
# The named port. For example: <"http", 80>.
# [[types]]
# schema = "NamedPort"
# include_fields = ["name", "port"]
#
#   name: string
#   port: integer, format: int32
#
# [types.field_overrides]
# name = { required = true }

# --- NatIpInfo (2 fields) ---
# Contains NAT IP information of a NAT config (i.e. usage status, mode).
# [[types]]
# schema = "NatIpInfo"
# include_fields = ["natIpInfoMappings", "natName"]
#
#   natIpInfoMappings: array<NatIpInfoNatIpInfoMapping>, readOnly
#   natName: string, readOnly

# --- NatIpInfoNatIpInfoMapping (3 fields) ---
# Contains information of a NAT IP.
# [[types]]
# schema = "NatIpInfoNatIpInfoMapping"
# include_fields = ["mode", "natIp", "usage"]
#
#   mode: string, enum: [AUTO, MANUAL], readOnly
#   natIp: string, readOnly
#   usage: string, enum: [IN_USE, UNUSED], readOnly
#
# [types.field_overrides]
# # mode = { enum_type = "NatIpInfoNatIpInfoMappingMode" }
# # usage = { enum_type = "NatIpInfoNatIpInfoMappingUsage" }

# --- NatIpInfoResponse (1 fields) ---
# [[types]]
# schema = "NatIpInfoResponse"
# include_fields = ["result"]
#
#   result: array<NatIpInfo>

# --- Network (20 fields) ---
# Represents a VPC Network resource. Networks connect resources to each other and to the internet. For
# [[types]]
# schema = "Network"
# include_fields = ["IPv4Range", "autoCreateSubnetworks", "creationTimestamp", "description", "enableUlaInternalIpv6", "firewallPolicy", "gatewayIPv4", "id", "internalIpv6Range", "kind", "mtu", "name", "networkFirewallPolicyEnforcementOrder", "networkProfile", "params", "peerings", "routingConfig", "selfLink", "selfLinkWithId", "subnetworks"]
#
#   IPv4Range: string
#   autoCreateSubnetworks: boolean
#   creationTimestamp: string, readOnly
#   description: string
#   enableUlaInternalIpv6: boolean
#   firewallPolicy: string, readOnly
#   gatewayIPv4: string
#   id: string, format: uint64, readOnly
#   internalIpv6Range: string
#   kind: string, readOnly
#   mtu: integer, format: int32
#   name: string
#   networkFirewallPolicyEnforcementOrder: string, enum: [AFTER_CLASSIC_FIREWALL, BEFORE_CLASSIC_FIREWALL]
#   networkProfile: string
#   params: $ref: NetworkParams
#   peerings: array<NetworkPeering>, readOnly
#   routingConfig: $ref: NetworkRoutingConfig
#   selfLink: string
#   selfLinkWithId: string, readOnly
#   subnetworks: array<string>
#
# [types.field_overrides]
# name = { required = true }
# # networkFirewallPolicyEnforcementOrder = { enum_type = "NetworkNetworkFirewallPolicyEnforcementOrder" }

# --- NetworkAttachment (15 fields) ---
# NetworkAttachments A network attachment resource ...
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "NetworkAttachment"
# include_fields = ["connectionEndpoints", "connectionPreference", "creationTimestamp", "description", "fingerprint", "id", "kind", "name", "network", "producerAcceptLists", "producerRejectLists", "region", "selfLink", "selfLinkWithId", "subnetworks"]
#
#   connectionEndpoints: array<NetworkAttachmentConnectedEndpoint>, readOnly
#   connectionPreference: string, enum: [ACCEPT_AUTOMATIC, ACCEPT_MANUAL, INVALID]
#   creationTimestamp: string, readOnly
#   description: string
#   fingerprint: string, format: byte
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   name: string
#   network: string, readOnly
#   producerAcceptLists: array<string>
#   producerRejectLists: array<string>
#   region: string, readOnly
#   selfLink: string, readOnly
#   selfLinkWithId: string, readOnly
#   subnetworks: array<string>
#
# [types.field_overrides]
# name = { required = true }
# fingerprint = { format = "bytes" }
# # connectionPreference = { enum_type = "NetworkAttachmentConnectionPreference" }

# --- NetworkAttachmentAggregatedList (6 fields) ---
# Contains a list of NetworkAttachmentsScopedList.
# [[types]]
# schema = "NetworkAttachmentAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: map<string, NetworkAttachmentsScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string
#   warning: object

# --- NetworkAttachmentConnectedEndpoint (7 fields) ---
# [Output Only] A connection connected to this network attachment.
# [[types]]
# schema = "NetworkAttachmentConnectedEndpoint"
# include_fields = ["ipAddress", "ipv6Address", "projectIdOrNum", "secondaryIpCidrRanges", "status", "subnetwork", "subnetworkCidrRange"]
#
#   ipAddress: string
#   ipv6Address: string
#   projectIdOrNum: string
#   secondaryIpCidrRanges: array<string>
#   status: string, enum: [ACCEPTED, CLOSED, NEEDS_ATTENTION, PENDING, ... +2]
#   subnetwork: string
#   subnetworkCidrRange: string, readOnly
#
# [types.field_overrides]
# # status = { enum_type = "NetworkAttachmentConnectedEndpointStatus" }

# --- NetworkAttachmentList (6 fields) ---
# [[types]]
# schema = "NetworkAttachmentList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<NetworkAttachment>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string
#   warning: object

# --- NetworkAttachmentsScopedList (2 fields) ---
# [[types]]
# schema = "NetworkAttachmentsScopedList"
# include_fields = ["networkAttachments", "warning"]
#
#   networkAttachments: array<NetworkAttachment>
#   warning: object

# --- NetworkEdgeSecurityService (10 fields) ---
# Represents a Google Cloud Armor network edge security service resource.
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "NetworkEdgeSecurityService"
# include_fields = ["creationTimestamp", "description", "fingerprint", "id", "kind", "name", "region", "securityPolicy", "selfLink", "selfLinkWithId"]
#
#   creationTimestamp: string, readOnly
#   description: string
#   fingerprint: string, format: byte
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   name: string
#   region: string, readOnly
#   securityPolicy: string
#   selfLink: string, readOnly
#   selfLinkWithId: string, readOnly
#
# [types.field_overrides]
# name = { required = true }
# fingerprint = { format = "bytes" }

# --- NetworkEdgeSecurityServiceAggregatedList (8 fields) ---
# [[types]]
# schema = "NetworkEdgeSecurityServiceAggregatedList"
# include_fields = ["etag", "id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   etag: string
#   id: string
#   items: map<string, NetworkEdgeSecurityServicesScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- NetworkEdgeSecurityServicesScopedList (2 fields) ---
# [[types]]
# schema = "NetworkEdgeSecurityServicesScopedList"
# include_fields = ["networkEdgeSecurityServices", "warning"]
#
#   networkEdgeSecurityServices: array<NetworkEdgeSecurityService>
#   warning: object

# --- NetworkEndpoint (7 fields) ---
# The network endpoint.
# [[types]]
# schema = "NetworkEndpoint"
# include_fields = ["annotations", "clientDestinationPort", "fqdn", "instance", "ipAddress", "ipv6Address", "port"]
#
#   annotations: map<string, string>
#   clientDestinationPort: integer, format: int32
#   fqdn: string
#   instance: string
#   ipAddress: string
#   ipv6Address: string
#   port: integer, format: int32

# --- NetworkEndpointGroup (19 fields) ---
# Represents a collection of network endpoints. A network endpoint group (NEG) defines how a set of en
# [[types]]
# schema = "NetworkEndpointGroup"
# include_fields = ["annotations", "appEngine", "cloudFunction", "cloudRun", "creationTimestamp", "defaultPort", "description", "id", "kind", "name", "network", "networkEndpointType", "pscData", "pscTargetService", "region", "selfLink", "size", "subnetwork", "zone"]
#
#   annotations: map<string, string>
#   appEngine: $ref: NetworkEndpointGroupAppEngine
#   cloudFunction: $ref: NetworkEndpointGroupCloudFunction
#   cloudRun: $ref: NetworkEndpointGroupCloudRun
#   creationTimestamp: string, readOnly
#   defaultPort: integer, format: int32
#   description: string
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   name: string
#   network: string
#   networkEndpointType: string, enum: [GCE_VM_IP, GCE_VM_IP_PORT, GCE_VM_IP_PORTMAP, INTERNET_FQDN_PORT, ... +4]
#   pscData: $ref: NetworkEndpointGroupPscData
#   pscTargetService: string
#   region: string, readOnly
#   selfLink: string, readOnly
#   size: integer, format: int32, readOnly
#   subnetwork: string
#   zone: string, readOnly
#
# [types.field_overrides]
# name = { required = true }
# # networkEndpointType = { enum_type = "NetworkEndpointGroupNetworkEndpointType" }

# --- NetworkEndpointGroupAggregatedList (7 fields) ---
# [[types]]
# schema = "NetworkEndpointGroupAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, NetworkEndpointGroupsScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- NetworkEndpointGroupAppEngine (3 fields) ---
# Configuration for an App Engine network endpoint group (NEG). The service is optional, may be provid
# [[types]]
# schema = "NetworkEndpointGroupAppEngine"
# include_fields = ["service", "urlMask", "version"]
#
#   service: string
#   urlMask: string
#   version: string

# --- NetworkEndpointGroupCloudFunction (2 fields) ---
# Configuration for a Cloud Function network endpoint group (NEG). The function must be provided expli
# [[types]]
# schema = "NetworkEndpointGroupCloudFunction"
# include_fields = ["function", "urlMask"]
#
#   function: string
#   urlMask: string

# --- NetworkEndpointGroupCloudRun (3 fields) ---
# Configuration for a Cloud Run network endpoint group (NEG). The service must be provided explicitly 
# [[types]]
# schema = "NetworkEndpointGroupCloudRun"
# include_fields = ["service", "tag", "urlMask"]
#
#   service: string
#   tag: string
#   urlMask: string

# --- NetworkEndpointGroupList (6 fields) ---
# [[types]]
# schema = "NetworkEndpointGroupList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<NetworkEndpointGroup>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- NetworkEndpointGroupPscData (4 fields) ---
# All data that is specifically relevant to only network endpoint groups of type PRIVATE_SERVICE_CONNE
# [[types]]
# schema = "NetworkEndpointGroupPscData"
# include_fields = ["consumerPscAddress", "producerPort", "pscConnectionId", "pscConnectionStatus"]
#
#   consumerPscAddress: string, readOnly
#   producerPort: integer, format: int32
#   pscConnectionId: string, format: uint64, readOnly
#   pscConnectionStatus: string, enum: [ACCEPTED, CLOSED, NEEDS_ATTENTION, PENDING, ... +2], readOnly
#
# [types.field_overrides]
# # pscConnectionStatus = { enum_type = "NetworkEndpointGroupPscDataPscConnectionStatus" }

# --- NetworkEndpointGroupsAttachEndpointsRequest (1 fields) ---
# [[types]]
# schema = "NetworkEndpointGroupsAttachEndpointsRequest"
# include_fields = ["networkEndpoints"]
#
#   networkEndpoints: array<NetworkEndpoint>

# --- NetworkEndpointGroupsDetachEndpointsRequest (1 fields) ---
# [[types]]
# schema = "NetworkEndpointGroupsDetachEndpointsRequest"
# include_fields = ["networkEndpoints"]
#
#   networkEndpoints: array<NetworkEndpoint>

# --- NetworkEndpointGroupsListEndpointsRequest (1 fields) ---
# [[types]]
# schema = "NetworkEndpointGroupsListEndpointsRequest"
# include_fields = ["healthStatus"]
#
#   healthStatus: string, enum: [SHOW, SKIP]
#
# [types.field_overrides]
# # healthStatus = { enum_type = "NetworkEndpointGroupsListEndpointsRequestHealthStatus" }

# --- NetworkEndpointGroupsListNetworkEndpoints (5 fields) ---
# [[types]]
# schema = "NetworkEndpointGroupsListNetworkEndpoints"
# include_fields = ["id", "items", "kind", "nextPageToken", "warning"]
#
#   id: string
#   items: array<NetworkEndpointWithHealthStatus>
#   kind: string, readOnly
#   nextPageToken: string
#   warning: object

# --- NetworkEndpointGroupsScopedList (2 fields) ---
# [[types]]
# schema = "NetworkEndpointGroupsScopedList"
# include_fields = ["networkEndpointGroups", "warning"]
#
#   networkEndpointGroups: array<NetworkEndpointGroup>, readOnly
#   warning: object, readOnly

# --- NetworkEndpointWithHealthStatus (2 fields) ---
# [[types]]
# schema = "NetworkEndpointWithHealthStatus"
# include_fields = ["healths", "networkEndpoint"]
#
#   healths: array<HealthStatusForNetworkEndpoint>, readOnly
#   networkEndpoint: $ref: NetworkEndpoint, readOnly

# --- NetworkFirewallPolicyAggregatedList (7 fields) ---
# [[types]]
# schema = "NetworkFirewallPolicyAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, FirewallPoliciesScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- NetworkInterface (19 fields) [IN MANIFEST] ---
# A network interface resource attached to an instance.
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "NetworkInterface"
# include_fields = ["accessConfigs", "aliasIpRanges", "fingerprint", "igmpQuery", "internalIpv6PrefixLength", "ipv6AccessConfigs", "ipv6AccessType", "ipv6Address", "kind", "name", "network", "networkAttachment", "networkIP", "nicType", "parentNicName", "queueCount", "stackType", "subnetwork", "vlan"]
#
#   accessConfigs: array<AccessConfig>
#   aliasIpRanges: array<AliasIpRange>
#   fingerprint: string, format: byte
#   igmpQuery: string, enum: [IGMP_QUERY_DISABLED, IGMP_QUERY_V2]
#   internalIpv6PrefixLength: integer, format: int32
#   ipv6AccessConfigs: array<AccessConfig>
#   ipv6AccessType: string, enum: [EXTERNAL, INTERNAL], readOnly
#   ipv6Address: string
#   kind: string, readOnly
#   name: string
#   network: string
#   networkAttachment: string
#   networkIP: string
#   nicType: string, enum: [GVNIC, IDPF, IRDMA, MRDMA, ... +2]
#   parentNicName: string
#   queueCount: integer, format: int32
#   stackType: string, enum: [IPV4_IPV6, IPV4_ONLY, IPV6_ONLY]
#   subnetwork: string
#   vlan: integer, format: int32
#
# [types.field_overrides]
# name = { required = true }
# fingerprint = { format = "bytes" }
# # nicType = { enum_type = "NetworkInterfaceNicType" }
# # ipv6AccessType = { enum_type = "NetworkInterfaceIpv6AccessType" }
# # igmpQuery = { enum_type = "NetworkInterfaceIgmpQuery" }
# # stackType = { enum_type = "NetworkInterfaceStackType" }

# --- NetworkList (6 fields) ---
# Contains a list of networks.
# [[types]]
# schema = "NetworkList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<Network>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- NetworkParams (1 fields) ---
# Additional network parameters.
# [[types]]
# schema = "NetworkParams"
# include_fields = ["resourceManagerTags"]
#
#   resourceManagerTags: map<string, string>

# --- NetworkPeering (14 fields) ---
# A network peering attached to a network resource. The message includes the peering name, peer networ
# [[types]]
# schema = "NetworkPeering"
# include_fields = ["autoCreateRoutes", "connectionStatus", "exchangeSubnetRoutes", "exportCustomRoutes", "exportSubnetRoutesWithPublicIp", "importCustomRoutes", "importSubnetRoutesWithPublicIp", "name", "network", "peerMtu", "stackType", "state", "stateDetails", "updateStrategy"]
#
#   autoCreateRoutes: boolean
#   connectionStatus: $ref: NetworkPeeringConnectionStatus, readOnly
#   exchangeSubnetRoutes: boolean
#   exportCustomRoutes: boolean
#   exportSubnetRoutesWithPublicIp: boolean
#   importCustomRoutes: boolean
#   importSubnetRoutesWithPublicIp: boolean
#   name: string
#   network: string
#   peerMtu: integer, format: int32, readOnly
#   stackType: string, enum: [IPV4_IPV6, IPV4_ONLY]
#   state: string, enum: [ACTIVE, INACTIVE], readOnly
#   stateDetails: string, readOnly
#   updateStrategy: string, enum: [CONSENSUS, INDEPENDENT, UNSPECIFIED]
#
# [types.field_overrides]
# name = { required = true }
# # state = { enum_type = "NetworkPeeringState" }
# # updateStrategy = { enum_type = "NetworkPeeringUpdateStrategy" }
# # stackType = { enum_type = "NetworkPeeringStackType" }

# --- NetworkPeeringConnectionStatus (3 fields) ---
# [Output Only] Describes the state of a peering connection, not just the local peering. This field pr
# [[types]]
# schema = "NetworkPeeringConnectionStatus"
# include_fields = ["consensusState", "trafficConfiguration", "updateStrategy"]
#
#   consensusState: $ref: NetworkPeeringConnectionStatusConsensusState
#   trafficConfiguration: $ref: NetworkPeeringConnectionStatusTrafficConfiguration
#   updateStrategy: string, enum: [CONSENSUS, INDEPENDENT, UNSPECIFIED]
#
# [types.field_overrides]
# # updateStrategy = { enum_type = "NetworkPeeringConnectionStatusUpdateStrategy" }

# --- NetworkPeeringConnectionStatusConsensusState (2 fields) ---
# The status of update/delete for a consensus peering connection. Only set when connection_status.upda
# [[types]]
# schema = "NetworkPeeringConnectionStatusConsensusState"
# include_fields = ["deleteStatus", "updateStatus"]
#
#   deleteStatus: string, enum: [DELETE_ACKNOWLEDGED, DELETE_STATUS_UNSPECIFIED, LOCAL_DELETE_REQUESTED, PEER_DELETE_REQUESTED]
#   updateStatus: string, enum: [IN_SYNC, PENDING_LOCAL_ACKNOWLEDMENT, PENDING_PEER_ACKNOWLEDGEMENT, UPDATE_STATUS_UNSPECIFIED]
#
# [types.field_overrides]
# # deleteStatus = { enum_type = "NetworkPeeringConnectionStatusConsensusStateDeleteStatus" }
# # updateStatus = { enum_type = "NetworkPeeringConnectionStatusConsensusStateUpdateStatus" }

# --- NetworkPeeringConnectionStatusTrafficConfiguration (5 fields) ---
# [[types]]
# schema = "NetworkPeeringConnectionStatusTrafficConfiguration"
# include_fields = ["exportCustomRoutesToPeer", "exportSubnetRoutesWithPublicIpToPeer", "importCustomRoutesFromPeer", "importSubnetRoutesWithPublicIpFromPeer", "stackType"]
#
#   exportCustomRoutesToPeer: boolean
#   exportSubnetRoutesWithPublicIpToPeer: boolean
#   importCustomRoutesFromPeer: boolean
#   importSubnetRoutesWithPublicIpFromPeer: boolean
#   stackType: string, enum: [IPV4_IPV6, IPV4_ONLY]
#
# [types.field_overrides]
# # stackType = { enum_type = "NetworkPeeringConnectionStatusTrafficConfigurationStackType" }

# --- NetworkPerformanceConfig (1 fields) ---
# [[types]]
# schema = "NetworkPerformanceConfig"
# include_fields = ["totalEgressBandwidthTier"]
#
#   totalEgressBandwidthTier: string, enum: [DEFAULT, TIER_1]
#
# [types.field_overrides]
# # totalEgressBandwidthTier = { enum_type = "NetworkPerformanceConfigTotalEgressBandwidthTier" }

# --- NetworkProfile (10 fields) ---
# NetworkProfile represents a Google managed network profile resource.
# [[types]]
# schema = "NetworkProfile"
# include_fields = ["creationTimestamp", "description", "features", "id", "kind", "location", "name", "profileType", "selfLink", "selfLinkWithId"]
#
#   creationTimestamp: string, readOnly
#   description: string, readOnly
#   features: $ref: NetworkProfileNetworkFeatures, readOnly
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   location: $ref: NetworkProfileLocation, readOnly
#   name: string, readOnly
#   profileType: $ref: NetworkProfileProfileType, readOnly
#   selfLink: string, readOnly
#   selfLinkWithId: string, readOnly
#
# [types.field_overrides]
# name = { required = true }

# --- NetworkProfileLocation (2 fields) ---
# [[types]]
# schema = "NetworkProfileLocation"
# include_fields = ["name", "scope"]
#
#   name: string
#   scope: string, enum: [REGION, ZONE]
#
# [types.field_overrides]
# name = { required = true }
# # scope = { enum_type = "NetworkProfileLocationScope" }

# --- NetworkProfileNetworkFeatures (38 fields) ---
# [[types]]
# schema = "NetworkProfileNetworkFeatures"
# include_fields = ["addressPurposes", "allowAddressCreation", "allowAliasIpRanges", "allowAutoModeSubnet", "allowClassDFirewalls", "allowCloudNat", "allowCloudRouter", "allowDefaultNicAttachment", "allowExternalIpAccess", "allowFirewallPolicy", "allowInterconnect", "allowIpForwarding", "allowLoadBalancing", "allowMultiNicInSameNetwork", "allowMultiNicInSameSubnetwork", "allowMulticast", "allowNcc", "allowNetworkMigration", "allowPacketMirroring", "allowPrivateGoogleAccess", "allowPsc", "allowSameNetworkUnicast", "allowStaticRoutes", "allowSubInterfaces", "allowSubnetworkCreation", "allowVpcFirewallRules", "allowVpcPeering", "allowVpn", "firewallPolicyTypes", "interfaceTypes", "multicast", "predefinedNetworkInternalIpv6Range", "predefinedSubnetworkRanges", "subnetPurposes", "subnetStackTypes", "subnetworkPurposes", "subnetworkStackTypes", "unicast"]
#
#   addressPurposes: array<string>
#   allowAddressCreation: string, enum: [ADDRESS_CREATION_ALLOWED, ADDRESS_CREATION_BLOCKED]
#   allowAliasIpRanges: string, enum: [ALIAS_IP_RANGES_ALLOWED, ALIAS_IP_RANGES_BLOCKED]
#   allowAutoModeSubnet: string, enum: [AUTO_MODE_SUBNET_ALLOWED, AUTO_MODE_SUBNET_BLOCKED]
#   allowClassDFirewalls: string, enum: [CLASS_D_FIREWALLS_ALLOWED, CLASS_D_FIREWALLS_BLOCKED]
#   allowCloudNat: string, enum: [CLOUD_NAT_ALLOWED, CLOUD_NAT_BLOCKED]
#   allowCloudRouter: string, enum: [CLOUD_ROUTER_ALLOWED, CLOUD_ROUTER_BLOCKED]
#   allowDefaultNicAttachment: string, enum: [DEFAULT_NIC_ATTACHMENT_ALLOWED, DEFAULT_NIC_ATTACHMENT_BLOCKED]
#   allowExternalIpAccess: string, enum: [EXTERNAL_IP_ACCESS_ALLOWED, EXTERNAL_IP_ACCESS_BLOCKED]
#   allowFirewallPolicy: string, enum: [FIREWALL_POLICY_ALLOWED, FIREWALL_POLICY_BLOCKED]
#   allowInterconnect: string, enum: [INTERCONNECT_ALLOWED, INTERCONNECT_BLOCKED]
#   allowIpForwarding: string, enum: [IP_FORWARDING_ALLOWED, IP_FORWARDING_BLOCKED]
#   allowLoadBalancing: string, enum: [LOAD_BALANCING_ALLOWED, LOAD_BALANCING_BLOCKED]
#   allowMultiNicInSameNetwork: string, enum: [MULTI_NIC_IN_SAME_NETWORK_ALLOWED, MULTI_NIC_IN_SAME_NETWORK_BLOCKED]
#   allowMultiNicInSameSubnetwork: string, enum: [MULTI_NIC_IN_SAME_SUBNETWORK_ALLOWED, MULTI_NIC_IN_SAME_SUBNETWORK_BLOCKED]
#   allowMulticast: string, enum: [MULTICAST_ALLOWED, MULTICAST_BLOCKED]
#   allowNcc: string, enum: [NCC_ALLOWED, NCC_BLOCKED]
#   allowNetworkMigration: string, enum: [NETWORK_MIGRATION_ALLOWED, NETWORK_MIGRATION_BLOCKED]
#   allowPacketMirroring: string, enum: [PACKET_MIRRORING_ALLOWED, PACKET_MIRRORING_BLOCKED]
#   allowPrivateGoogleAccess: string, enum: [PRIVATE_GOOGLE_ACCESS_ALLOWED, PRIVATE_GOOGLE_ACCESS_BLOCKED]
#   allowPsc: string, enum: [PSC_ALLOWED, PSC_BLOCKED]
#   allowSameNetworkUnicast: string, enum: [SAME_NETWORK_UNICAST_ALLOWED, SAME_NETWORK_UNICAST_BLOCKED]
#   allowStaticRoutes: string, enum: [STATIC_ROUTES_ALLOWED, STATIC_ROUTES_BLOCKED]
#   allowSubInterfaces: string, enum: [SUBINTERFACES_ALLOWED, SUBINTERFACES_BLOCKED]
#   allowSubnetworkCreation: string, enum: [SUBNETWORK_CREATION_ALLOWED, SUBNETWORK_CREATION_BLOCKED]
#   allowVpcFirewallRules: string, enum: [VPC_FIREWALL_RULES_ALLOWED, VPC_FIREWALL_RULES_BLOCKED]
#   allowVpcPeering: string, enum: [VPC_PEERING_ALLOWED, VPC_PEERING_BLOCKED]
#   allowVpn: string, enum: [VPN_ALLOWED, VPN_BLOCKED]
#   firewallPolicyTypes: array<string>
#   interfaceTypes: array<string>
#   multicast: string, enum: [MULTICAST_SDN, MULTICAST_ULL]
#   predefinedNetworkInternalIpv6Range: string
#   predefinedSubnetworkRanges: array<NetworkProfileNetworkFeaturesPredefinedSubnetworkRange>
#   subnetPurposes: array<string>
#   subnetStackTypes: array<string>
#   subnetworkPurposes: array<string>, readOnly
#   subnetworkStackTypes: array<string>, readOnly
#   unicast: string, enum: [UNICAST_SDN, UNICAST_ULL]
#
# [types.field_overrides]
# # allowMulticast = { enum_type = "NetworkProfileNetworkFeaturesAllowMulticast" }
# # allowCloudNat = { enum_type = "NetworkProfileNetworkFeaturesAllowCloudNat" }
# # allowInterconnect = { enum_type = "NetworkProfileNetworkFeaturesAllowInterconnect" }
# # allowPrivateGoogleAccess = { enum_type = "NetworkProfileNetworkFeaturesAllowPrivateGoogleAccess" }
# # allowDefaultNicAttachment = { enum_type = "NetworkProfileNetworkFeaturesAllowDefaultNicAttachment" }
# # allowLoadBalancing = { enum_type = "NetworkProfileNetworkFeaturesAllowLoadBalancing" }
# # allowAliasIpRanges = { enum_type = "NetworkProfileNetworkFeaturesAllowAliasIpRanges" }
# # allowPacketMirroring = { enum_type = "NetworkProfileNetworkFeaturesAllowPacketMirroring" }
# # multicast = { enum_type = "NetworkProfileNetworkFeaturesMulticast" }
# # allowCloudRouter = { enum_type = "NetworkProfileNetworkFeaturesAllowCloudRouter" }
# # allowVpcPeering = { enum_type = "NetworkProfileNetworkFeaturesAllowVpcPeering" }
# # allowVpn = { enum_type = "NetworkProfileNetworkFeaturesAllowVpn" }
# # allowNetworkMigration = { enum_type = "NetworkProfileNetworkFeaturesAllowNetworkMigration" }
# # unicast = { enum_type = "NetworkProfileNetworkFeaturesUnicast" }
# # allowSubnetworkCreation = { enum_type = "NetworkProfileNetworkFeaturesAllowSubnetworkCreation" }
# # allowVpcFirewallRules = { enum_type = "NetworkProfileNetworkFeaturesAllowVpcFirewallRules" }
# # allowStaticRoutes = { enum_type = "NetworkProfileNetworkFeaturesAllowStaticRoutes" }
# # allowSubInterfaces = { enum_type = "NetworkProfileNetworkFeaturesAllowSubInterfaces" }
# # allowMultiNicInSameNetwork = { enum_type = "NetworkProfileNetworkFeaturesAllowMultiNicInSameNetwork" }
# # allowAutoModeSubnet = { enum_type = "NetworkProfileNetworkFeaturesAllowAutoModeSubnet" }
# # allowMultiNicInSameSubnetwork = { enum_type = "NetworkProfileNetworkFeaturesAllowMultiNicInSameSubnetwork" }
# # allowSameNetworkUnicast = { enum_type = "NetworkProfileNetworkFeaturesAllowSameNetworkUnicast" }
# # allowNcc = { enum_type = "NetworkProfileNetworkFeaturesAllowNcc" }
# # allowPsc = { enum_type = "NetworkProfileNetworkFeaturesAllowPsc" }
# # allowFirewallPolicy = { enum_type = "NetworkProfileNetworkFeaturesAllowFirewallPolicy" }
# # allowClassDFirewalls = { enum_type = "NetworkProfileNetworkFeaturesAllowClassDFirewalls" }
# # allowAddressCreation = { enum_type = "NetworkProfileNetworkFeaturesAllowAddressCreation" }
# # allowIpForwarding = { enum_type = "NetworkProfileNetworkFeaturesAllowIpForwarding" }
# # allowExternalIpAccess = { enum_type = "NetworkProfileNetworkFeaturesAllowExternalIpAccess" }

# --- NetworkProfileNetworkFeaturesPredefinedSubnetworkRange (2 fields) ---
# [[types]]
# schema = "NetworkProfileNetworkFeaturesPredefinedSubnetworkRange"
# include_fields = ["ipv6Range", "namePrefix"]
#
#   ipv6Range: string
#   namePrefix: string

# --- NetworkProfileProfileType (4 fields) ---
# [[types]]
# schema = "NetworkProfileProfileType"
# include_fields = ["networkType", "rdmaSubtype", "ullSubtype", "vpcSubtype"]
#
#   networkType: string, enum: [RDMA, ULL, VPC]
#   rdmaSubtype: string, enum: [FALCON, ROCE, ROCE_METAL]
#   ullSubtype: string, enum: [OPERATOR, PARTICIPANT]
#   vpcSubtype: string, enum: [REGIONAL]
#
# [types.field_overrides]
# # ullSubtype = { enum_type = "NetworkProfileProfileTypeUllSubtype" }
# # vpcSubtype = { enum_type = "NetworkProfileProfileTypeVpcSubtype" }
# # networkType = { enum_type = "NetworkProfileProfileTypeNetworkType" }
# # rdmaSubtype = { enum_type = "NetworkProfileProfileTypeRdmaSubtype" }

# --- NetworkProfilesListResponse (8 fields) ---
# Contains a list of network profiles.
# [[types]]
# schema = "NetworkProfilesListResponse"
# include_fields = ["etag", "id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   etag: string
#   id: string
#   items: array<NetworkProfile>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- NetworkRoutingConfig (6 fields) ---
# A routing configuration attached to a network resource. The message includes the list of routers ass
# [[types]]
# schema = "NetworkRoutingConfig"
# include_fields = ["bgpAlwaysCompareMed", "bgpBestPathSelectionMode", "bgpInterRegionCost", "effectiveBgpAlwaysCompareMed", "effectiveBgpInterRegionCost", "routingMode"]
#
#   bgpAlwaysCompareMed: boolean
#   bgpBestPathSelectionMode: string, enum: [LEGACY, STANDARD]
#   bgpInterRegionCost: string, enum: [ADD_COST_TO_MED, DEFAULT]
#   effectiveBgpAlwaysCompareMed: boolean, readOnly
#   effectiveBgpInterRegionCost: string, enum: [ADD_COST_TO_MED, DEFAULT], readOnly
#   routingMode: string, enum: [GLOBAL, REGIONAL]
#
# [types.field_overrides]
# # effectiveBgpInterRegionCost = { enum_type = "NetworkRoutingConfigEffectiveBgpInterRegionCost" }
# # routingMode = { enum_type = "NetworkRoutingConfigRoutingMode" }
# # bgpInterRegionCost = { enum_type = "NetworkRoutingConfigBgpInterRegionCost" }
# # bgpBestPathSelectionMode = { enum_type = "NetworkRoutingConfigBgpBestPathSelectionMode" }

# --- NetworksAddPeeringRequest (4 fields) ---
# [[types]]
# schema = "NetworksAddPeeringRequest"
# include_fields = ["autoCreateRoutes", "name", "networkPeering", "peerNetwork"]
#
#   autoCreateRoutes: boolean
#   name: string
#   networkPeering: $ref: NetworkPeering
#   peerNetwork: string
#
# [types.field_overrides]
# name = { required = true }

# --- NetworksGetEffectiveFirewallsResponse (2 fields) ---
# [[types]]
# schema = "NetworksGetEffectiveFirewallsResponse"
# include_fields = ["firewallPolicys", "firewalls"]
#
#   firewallPolicys: array<NetworksGetEffectiveFirewallsResponseEffectiveFirewallPolicy>
#   firewalls: array<Firewall>

# --- NetworksGetEffectiveFirewallsResponseEffectiveFirewallPolicy (7 fields) ---
# WARNING: reserved words: type
# [[types]]
# schema = "NetworksGetEffectiveFirewallsResponseEffectiveFirewallPolicy"
# include_fields = ["displayName", "name", "packetMirroringRules", "priority", "rules", "shortName", "type"]
#
#   displayName: string, readOnly
#   name: string, readOnly
#   packetMirroringRules: array<FirewallPolicyRule>, readOnly
#   priority: integer, format: int32, readOnly
#   rules: array<FirewallPolicyRule>
#   shortName: string, readOnly
#   type: string, enum: [HIERARCHY, NETWORK, SYSTEM, UNSPECIFIED], readOnly, RESERVED_WORD
#
# [types.field_overrides]
# name = { required = true }
# type = { rust_name = "type_value", serde_rename = "type" }
# # type = { enum_type = "NetworksGetEffectiveFirewallsResponseEffectiveFirewallPolicyType" }

# --- NetworksRemovePeeringRequest (1 fields) ---
# [[types]]
# schema = "NetworksRemovePeeringRequest"
# include_fields = ["name"]
#
#   name: string
#
# [types.field_overrides]
# name = { required = true }

# --- NetworksRequestRemovePeeringRequest (1 fields) ---
# [[types]]
# schema = "NetworksRequestRemovePeeringRequest"
# include_fields = ["name"]
#
#   name: string
#
# [types.field_overrides]
# name = { required = true }

# --- NetworksUpdatePeeringRequest (1 fields) ---
# [[types]]
# schema = "NetworksUpdatePeeringRequest"
# include_fields = ["networkPeering"]
#
#   networkPeering: $ref: NetworkPeering

# --- NodeGroup (17 fields) ---
# Represents a sole-tenant Node Group resource. A sole-tenant node is a physical server that is dedica
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "NodeGroup"
# include_fields = ["autoscalingPolicy", "creationTimestamp", "description", "fingerprint", "id", "kind", "locationHint", "maintenanceInterval", "maintenancePolicy", "maintenanceWindow", "name", "nodeTemplate", "selfLink", "shareSettings", "size", "status", "zone"]
#
#   autoscalingPolicy: $ref: NodeGroupAutoscalingPolicy
#   creationTimestamp: string, readOnly
#   description: string
#   fingerprint: string, format: byte
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   locationHint: string
#   maintenanceInterval: string, enum: [AS_NEEDED, RECURRENT]
#   maintenancePolicy: string, enum: [DEFAULT, MAINTENANCE_POLICY_UNSPECIFIED, MIGRATE_WITHIN_NODE_GROUP, RESTART_IN_PLACE]
#   maintenanceWindow: $ref: NodeGroupMaintenanceWindow
#   name: string
#   nodeTemplate: string
#   selfLink: string, readOnly
#   shareSettings: $ref: ShareSettings
#   size: integer, format: int32, readOnly
#   status: string, enum: [CREATING, DELETING, INVALID, READY], readOnly
#   zone: string, readOnly
#
# [types.field_overrides]
# name = { required = true }
# fingerprint = { format = "bytes" }
# # maintenanceInterval = { enum_type = "NodeGroupMaintenanceInterval" }
# # maintenancePolicy = { enum_type = "NodeGroupMaintenancePolicy" }
# # status = { enum_type = "NodeGroupStatus" }

# --- NodeGroupAggregatedList (7 fields) ---
# [[types]]
# schema = "NodeGroupAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, NodeGroupsScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- NodeGroupAutoscalingPolicy (3 fields) ---
# [[types]]
# schema = "NodeGroupAutoscalingPolicy"
# include_fields = ["maxNodes", "minNodes", "mode"]
#
#   maxNodes: integer, format: int32
#   minNodes: integer, format: int32
#   mode: string, enum: [MODE_UNSPECIFIED, OFF, ON, ONLY_SCALE_OUT]
#
# [types.field_overrides]
# # mode = { enum_type = "NodeGroupAutoscalingPolicyMode" }

# --- NodeGroupList (6 fields) ---
# Contains a list of nodeGroups.
# [[types]]
# schema = "NodeGroupList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<NodeGroup>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- NodeGroupMaintenanceWindow (2 fields) ---
# Time window specified for daily maintenance operations. GCE's internal maintenance will be performed
# [[types]]
# schema = "NodeGroupMaintenanceWindow"
# include_fields = ["maintenanceDuration", "startTime"]
#
#   maintenanceDuration: $ref: Duration, readOnly
#   startTime: string

# --- NodeGroupNode (14 fields) ---
# [[types]]
# schema = "NodeGroupNode"
# include_fields = ["accelerators", "consumedResources", "cpuOvercommitType", "disks", "instanceConsumptionData", "instances", "name", "nodeType", "satisfiesPzs", "serverBinding", "serverId", "status", "totalResources", "upcomingMaintenance"]
#
#   accelerators: array<AcceleratorConfig>
#   consumedResources: $ref: InstanceConsumptionInfo, readOnly
#   cpuOvercommitType: string, enum: [CPU_OVERCOMMIT_TYPE_UNSPECIFIED, ENABLED, NONE]
#   disks: array<LocalDisk>
#   instanceConsumptionData: array<InstanceConsumptionData>, readOnly
#   instances: array<string>
#   name: string
#   nodeType: string
#   satisfiesPzs: boolean, readOnly
#   serverBinding: $ref: ServerBinding
#   serverId: string
#   status: string, enum: [CREATING, DELETING, INVALID, READY, REPAIRING]
#   totalResources: $ref: InstanceConsumptionInfo, readOnly
#   upcomingMaintenance: $ref: UpcomingMaintenance, readOnly
#
# [types.field_overrides]
# name = { required = true }
# # status = { enum_type = "NodeGroupNodeStatus" }
# # cpuOvercommitType = { enum_type = "NodeGroupNodeCpuOvercommitType" }

# --- NodeGroupsAddNodesRequest (1 fields) ---
# [[types]]
# schema = "NodeGroupsAddNodesRequest"
# include_fields = ["additionalNodeCount"]
#
#   additionalNodeCount: integer, format: int32

# --- NodeGroupsDeleteNodesRequest (1 fields) ---
# [[types]]
# schema = "NodeGroupsDeleteNodesRequest"
# include_fields = ["nodes"]
#
#   nodes: array<string>

# --- NodeGroupsListNodes (6 fields) ---
# [[types]]
# schema = "NodeGroupsListNodes"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string, readOnly
#   items: array<NodeGroupNode>
#   kind: string, readOnly
#   nextPageToken: string, readOnly
#   selfLink: string, readOnly
#   warning: object, readOnly

# --- NodeGroupsPerformMaintenanceRequest (2 fields) ---
# [[types]]
# schema = "NodeGroupsPerformMaintenanceRequest"
# include_fields = ["nodes", "startTime"]
#
#   nodes: array<string>
#   startTime: string

# --- NodeGroupsScopedList (2 fields) ---
# [[types]]
# schema = "NodeGroupsScopedList"
# include_fields = ["nodeGroups", "warning"]
#
#   nodeGroups: array<NodeGroup>
#   warning: object

# --- NodeGroupsSetNodeTemplateRequest (1 fields) ---
# [[types]]
# schema = "NodeGroupsSetNodeTemplateRequest"
# include_fields = ["nodeTemplate"]
#
#   nodeTemplate: string

# --- NodeGroupsSimulateMaintenanceEventRequest (1 fields) ---
# [[types]]
# schema = "NodeGroupsSimulateMaintenanceEventRequest"
# include_fields = ["nodes"]
#
#   nodes: array<string>

# --- NodeTemplate (16 fields) ---
# Represent a sole-tenant Node Template resource. You can use a template to define properties for node
# [[types]]
# schema = "NodeTemplate"
# include_fields = ["accelerators", "cpuOvercommitType", "creationTimestamp", "description", "disks", "id", "kind", "name", "nodeAffinityLabels", "nodeType", "nodeTypeFlexibility", "region", "selfLink", "serverBinding", "status", "statusMessage"]
#
#   accelerators: array<AcceleratorConfig>
#   cpuOvercommitType: string, enum: [CPU_OVERCOMMIT_TYPE_UNSPECIFIED, ENABLED, NONE]
#   creationTimestamp: string, readOnly
#   description: string
#   disks: array<LocalDisk>
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   name: string
#   nodeAffinityLabels: map<string, string>
#   nodeType: string
#   nodeTypeFlexibility: $ref: NodeTemplateNodeTypeFlexibility
#   region: string, readOnly
#   selfLink: string, readOnly
#   serverBinding: $ref: ServerBinding
#   status: string, enum: [CREATING, DELETING, INVALID, READY], readOnly
#   statusMessage: string, readOnly
#
# [types.field_overrides]
# name = { required = true }
# # cpuOvercommitType = { enum_type = "NodeTemplateCpuOvercommitType" }
# # status = { enum_type = "NodeTemplateStatus" }

# --- NodeTemplateAggregatedList (7 fields) ---
# [[types]]
# schema = "NodeTemplateAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, NodeTemplatesScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- NodeTemplateList (6 fields) ---
# Contains a list of node templates.
# [[types]]
# schema = "NodeTemplateList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<NodeTemplate>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- NodeTemplateNodeTypeFlexibility (3 fields) ---
# [[types]]
# schema = "NodeTemplateNodeTypeFlexibility"
# include_fields = ["cpus", "localSsd", "memory"]
#
#   cpus: string
#   localSsd: string
#   memory: string

# --- NodeTemplatesScopedList (2 fields) ---
# [[types]]
# schema = "NodeTemplatesScopedList"
# include_fields = ["nodeTemplates", "warning"]
#
#   nodeTemplates: array<NodeTemplate>
#   warning: object

# --- NodeType (13 fields) ---
# Represent a sole-tenant Node Type resource. Each node within a node group must have a node type. A n
# [[types]]
# schema = "NodeType"
# include_fields = ["cpuPlatform", "creationTimestamp", "deprecated", "description", "guestCpus", "id", "kind", "localSsdGb", "maxVms", "memoryMb", "name", "selfLink", "zone"]
#
#   cpuPlatform: string
#   creationTimestamp: string
#   deprecated: $ref: DeprecationStatus
#   description: string
#   guestCpus: integer, format: int32
#   id: string, format: uint64
#   kind: string, readOnly
#   localSsdGb: integer, format: int32
#   maxVms: integer, format: int32, readOnly
#   memoryMb: integer, format: int32
#   name: string
#   selfLink: string, readOnly
#   zone: string, readOnly
#
# [types.field_overrides]
# name = { required = true }

# --- NodeTypeAggregatedList (7 fields) ---
# [[types]]
# schema = "NodeTypeAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, NodeTypesScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- NodeTypeList (6 fields) ---
# Contains a list of node types.
# [[types]]
# schema = "NodeTypeList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<NodeType>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- NodeTypesScopedList (2 fields) ---
# [[types]]
# schema = "NodeTypesScopedList"
# include_fields = ["nodeTypes", "warning"]
#
#   nodeTypes: array<NodeType>
#   warning: object

# --- NotificationEndpoint (8 fields) ---
# Represents a notification endpoint. A notification endpoint resource defines an endpoint to receive 
# [[types]]
# schema = "NotificationEndpoint"
# include_fields = ["creationTimestamp", "description", "grpcSettings", "id", "kind", "name", "region", "selfLink"]
#
#   creationTimestamp: string, readOnly
#   description: string
#   grpcSettings: $ref: NotificationEndpointGrpcSettings
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   name: string
#   region: string, readOnly
#   selfLink: string, readOnly
#
# [types.field_overrides]
# name = { required = true }

# --- NotificationEndpointGrpcSettings (5 fields) ---
# Represents a gRPC setting that describes one gRPC notification endpoint and the retry duration attem
# [[types]]
# schema = "NotificationEndpointGrpcSettings"
# include_fields = ["authority", "endpoint", "payloadName", "resendInterval", "retryDurationSec"]
#
#   authority: string
#   endpoint: string
#   payloadName: string
#   resendInterval: $ref: Duration
#   retryDurationSec: integer, format: uint32

# --- NotificationEndpointList (6 fields) ---
# [[types]]
# schema = "NotificationEndpointList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<NotificationEndpoint>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string
#   warning: object

# --- Operation (26 fields) [IN MANIFEST] ---
# Represents an Operation resource. Google Compute Engine has three Operation resources: * [Global](/c
# [[types]]
# schema = "Operation"
# include_fields = ["clientOperationId", "creationTimestamp", "description", "endTime", "error", "httpErrorMessage", "httpErrorStatusCode", "id", "insertTime", "instancesBulkInsertOperationMetadata", "kind", "name", "operationGroupId", "operationType", "progress", "region", "selfLink", "setCommonInstanceMetadataOperationMetadata", "startTime", "status", "statusMessage", "targetId", "targetLink", "user", "warnings", "zone"]
#
#   clientOperationId: string
#   creationTimestamp: string
#   description: string
#   endTime: string
#   error: object
#   httpErrorMessage: string
#   httpErrorStatusCode: integer, format: int32
#   id: string, format: uint64
#   insertTime: string
#   instancesBulkInsertOperationMetadata: $ref: InstancesBulkInsertOperationMetadata
#   kind: string, readOnly
#   name: string
#   operationGroupId: string, readOnly
#   operationType: string
#   progress: integer, format: int32
#   region: string
#   selfLink: string
#   setCommonInstanceMetadataOperationMetadata: $ref: SetCommonInstanceMetadataOperationMetadata, readOnly
#   startTime: string
#   status: string, enum: [DONE, PENDING, RUNNING]
#   statusMessage: string
#   targetId: string, format: uint64
#   targetLink: string
#   user: string
#   warnings: array<object>
#   zone: string
#
# [types.field_overrides]
# name = { required = true }
# # status = { enum_type = "OperationStatus" }

# --- OperationAggregatedList (7 fields) ---
# [[types]]
# schema = "OperationAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, OperationsScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string
#   unreachables: array<string>, readOnly
#   warning: object

# --- OperationList (6 fields) ---
# Contains a list of Operation resources.
# [[types]]
# schema = "OperationList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<Operation>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string
#   warning: object

# --- OperationsScopedList (2 fields) ---
# [[types]]
# schema = "OperationsScopedList"
# include_fields = ["operations", "warning"]
#
#   operations: array<Operation>
#   warning: object

# --- OrganizationSecurityPoliciesListAssociationsResponse (2 fields) ---
# [[types]]
# schema = "OrganizationSecurityPoliciesListAssociationsResponse"
# include_fields = ["associations", "kind"]
#
#   associations: array<SecurityPolicyAssociation>
#   kind: string, readOnly

# --- OutlierDetection (11 fields) ---
# Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend se
# [[types]]
# schema = "OutlierDetection"
# include_fields = ["baseEjectionTime", "consecutiveErrors", "consecutiveGatewayFailure", "enforcingConsecutiveErrors", "enforcingConsecutiveGatewayFailure", "enforcingSuccessRate", "interval", "maxEjectionPercent", "successRateMinimumHosts", "successRateRequestVolume", "successRateStdevFactor"]
#
#   baseEjectionTime: $ref: Duration
#   consecutiveErrors: integer, format: int32
#   consecutiveGatewayFailure: integer, format: int32
#   enforcingConsecutiveErrors: integer, format: int32
#   enforcingConsecutiveGatewayFailure: integer, format: int32
#   enforcingSuccessRate: integer, format: int32
#   interval: $ref: Duration
#   maxEjectionPercent: integer, format: int32
#   successRateMinimumHosts: integer, format: int32
#   successRateRequestVolume: integer, format: int32
#   successRateStdevFactor: integer, format: int32

# --- PacketIntervals (6 fields) ---
# Next free: 7
# WARNING: reserved words: type
# [[types]]
# schema = "PacketIntervals"
# include_fields = ["avgMs", "duration", "maxMs", "minMs", "numIntervals", "type"]
#
#   avgMs: string, format: int64
#   duration: string, enum: [DURATION_UNSPECIFIED, HOUR, MAX, MINUTE]
#   maxMs: string, format: int64
#   minMs: string, format: int64
#   numIntervals: string, format: int64
#   type: string, enum: [LOOPBACK, RECEIVE, TRANSMIT, TYPE_UNSPECIFIED], RESERVED_WORD
#
# [types.field_overrides]
# type = { rust_name = "type_value", serde_rename = "type" }
# # duration = { enum_type = "PacketIntervalsDuration" }
# # type = { enum_type = "PacketIntervalsType" }

# --- PacketMirroring (13 fields) ---
# Represents a Packet Mirroring resource. Packet Mirroring clones the traffic of specified instances i
# [[types]]
# schema = "PacketMirroring"
# include_fields = ["collectorIlb", "creationTimestamp", "description", "enable", "filter", "id", "kind", "mirroredResources", "name", "network", "priority", "region", "selfLink"]
#
#   collectorIlb: $ref: PacketMirroringForwardingRuleInfo
#   creationTimestamp: string, readOnly
#   description: string
#   enable: string, enum: [FALSE, TRUE]
#   filter: $ref: PacketMirroringFilter
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   mirroredResources: $ref: PacketMirroringMirroredResourceInfo
#   name: string
#   network: $ref: PacketMirroringNetworkInfo
#   priority: integer, format: uint32
#   region: string
#   selfLink: string, readOnly
#
# [types.field_overrides]
# name = { required = true }
# # enable = { enum_type = "PacketMirroringEnable" }

# --- PacketMirroringAggregatedList (7 fields) ---
# Contains a list of packetMirrorings.
# [[types]]
# schema = "PacketMirroringAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, PacketMirroringsScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- PacketMirroringFilter (3 fields) ---
# [[types]]
# schema = "PacketMirroringFilter"
# include_fields = ["IPProtocols", "cidrRanges", "direction"]
#
#   IPProtocols: array<string>
#   cidrRanges: array<string>
#   direction: string, enum: [BOTH, EGRESS, INGRESS]
#
# [types.field_overrides]
# # direction = { enum_type = "PacketMirroringFilterDirection" }

# --- PacketMirroringForwardingRuleInfo (2 fields) ---
# [[types]]
# schema = "PacketMirroringForwardingRuleInfo"
# include_fields = ["canonicalUrl", "url"]
#
#   canonicalUrl: string, readOnly
#   url: string

# --- PacketMirroringList (6 fields) ---
# Contains a list of PacketMirroring resources.
# [[types]]
# schema = "PacketMirroringList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<PacketMirroring>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- PacketMirroringMirroredResourceInfo (3 fields) ---
# [[types]]
# schema = "PacketMirroringMirroredResourceInfo"
# include_fields = ["instances", "subnetworks", "tags"]
#
#   instances: array<PacketMirroringMirroredResourceInfoInstanceInfo>
#   subnetworks: array<PacketMirroringMirroredResourceInfoSubnetInfo>
#   tags: array<string>

# --- PacketMirroringMirroredResourceInfoInstanceInfo (2 fields) ---
# [[types]]
# schema = "PacketMirroringMirroredResourceInfoInstanceInfo"
# include_fields = ["canonicalUrl", "url"]
#
#   canonicalUrl: string, readOnly
#   url: string

# --- PacketMirroringMirroredResourceInfoSubnetInfo (2 fields) ---
# [[types]]
# schema = "PacketMirroringMirroredResourceInfoSubnetInfo"
# include_fields = ["canonicalUrl", "url"]
#
#   canonicalUrl: string, readOnly
#   url: string

# --- PacketMirroringNetworkInfo (2 fields) ---
# [[types]]
# schema = "PacketMirroringNetworkInfo"
# include_fields = ["canonicalUrl", "url"]
#
#   canonicalUrl: string, readOnly
#   url: string

# --- PacketMirroringsScopedList (2 fields) ---
# [[types]]
# schema = "PacketMirroringsScopedList"
# include_fields = ["packetMirrorings", "warning"]
#
#   packetMirrorings: array<PacketMirroring>
#   warning: object

# --- PathMatcher (9 fields) ---
# A matcher for the path portion of the URL. The BackendService from the longest-matched rule will ser
# [[types]]
# schema = "PathMatcher"
# include_fields = ["defaultCustomErrorResponsePolicy", "defaultRouteAction", "defaultService", "defaultUrlRedirect", "description", "headerAction", "name", "pathRules", "routeRules"]
#
#   defaultCustomErrorResponsePolicy: $ref: CustomErrorResponsePolicy
#   defaultRouteAction: $ref: HttpRouteAction
#   defaultService: string
#   defaultUrlRedirect: $ref: HttpRedirectAction
#   description: string
#   headerAction: $ref: HttpHeaderAction
#   name: string
#   pathRules: array<PathRule>
#   routeRules: array<HttpRouteRule>
#
# [types.field_overrides]
# name = { required = true }

# --- PathRule (5 fields) ---
# A path-matching rule for a URL. If matched, will use the specifiedBackendService to handle the traff
# [[types]]
# schema = "PathRule"
# include_fields = ["customErrorResponsePolicy", "paths", "routeAction", "service", "urlRedirect"]
#
#   customErrorResponsePolicy: $ref: CustomErrorResponsePolicy
#   paths: array<string>
#   routeAction: $ref: HttpRouteAction
#   service: string
#   urlRedirect: $ref: HttpRedirectAction

# --- PerInstanceConfig (4 fields) ---
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "PerInstanceConfig"
# include_fields = ["fingerprint", "name", "preservedState", "status"]
#
#   fingerprint: string, format: byte
#   name: string
#   preservedState: $ref: PreservedState
#   status: string, enum: [APPLYING, DELETING, EFFECTIVE, NONE, ... +2]
#
# [types.field_overrides]
# name = { required = true }
# fingerprint = { format = "bytes" }
# # status = { enum_type = "PerInstanceConfigStatus" }

# --- Policy (4 fields) ---
# An Identity and Access Management (IAM) policy, which specifies access controls for Google Cloud res
# WARNING: format:"byte" fields: etag
# [[types]]
# schema = "Policy"
# include_fields = ["auditConfigs", "bindings", "etag", "version"]
#
#   auditConfigs: array<AuditConfig>
#   bindings: array<Binding>
#   etag: string, format: byte
#   version: integer, format: int32
#
# [types.field_overrides]
# etag = { format = "bytes" }

# --- PreconfiguredWafSet (1 fields) ---
# [[types]]
# schema = "PreconfiguredWafSet"
# include_fields = ["expressionSets"]
#
#   expressionSets: array<WafExpressionSet>

# --- PreservedState (4 fields) ---
# Preserved state for a given instance.
# [[types]]
# schema = "PreservedState"
# include_fields = ["disks", "externalIPs", "internalIPs", "metadata"]
#
#   disks: map<string, PreservedStatePreservedDisk>
#   externalIPs: map<string, PreservedStatePreservedNetworkIp>
#   internalIPs: map<string, PreservedStatePreservedNetworkIp>
#   metadata: map<string, string>

# --- PreservedStatePreservedDisk (3 fields) ---
# [[types]]
# schema = "PreservedStatePreservedDisk"
# include_fields = ["autoDelete", "mode", "source"]
#
#   autoDelete: string, enum: [NEVER, ON_PERMANENT_INSTANCE_DELETION]
#   mode: string, enum: [READ_ONLY, READ_WRITE]
#   source: string
#
# [types.field_overrides]
# # autoDelete = { enum_type = "PreservedStatePreservedDiskAutoDelete" }
# # mode = { enum_type = "PreservedStatePreservedDiskMode" }

# --- PreservedStatePreservedNetworkIp (2 fields) ---
# [[types]]
# schema = "PreservedStatePreservedNetworkIp"
# include_fields = ["autoDelete", "ipAddress"]
#
#   autoDelete: string, enum: [NEVER, ON_PERMANENT_INSTANCE_DELETION]
#   ipAddress: $ref: PreservedStatePreservedNetworkIpIpAddress
#
# [types.field_overrides]
# # autoDelete = { enum_type = "PreservedStatePreservedNetworkIpAutoDelete" }

# --- PreservedStatePreservedNetworkIpIpAddress (2 fields) ---
# [[types]]
# schema = "PreservedStatePreservedNetworkIpIpAddress"
# include_fields = ["address", "literal"]
#
#   address: string
#   literal: string

# --- PreviewFeature (9 fields) ---
# Represents a single Google Compute Engine preview feature.
# [[types]]
# schema = "PreviewFeature"
# include_fields = ["activationStatus", "creationTimestamp", "description", "id", "kind", "name", "rolloutOperation", "selfLink", "status"]
#
#   activationStatus: string, enum: [ACTIVATION_STATE_UNSPECIFIED, DISABLED, ENABLED]
#   creationTimestamp: string, readOnly
#   description: string, readOnly
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   name: string
#   rolloutOperation: $ref: PreviewFeatureRolloutOperation
#   selfLink: string, readOnly
#   status: $ref: PreviewFeatureStatus, readOnly
#
# [types.field_overrides]
# name = { required = true }
# # activationStatus = { enum_type = "PreviewFeatureActivationStatus" }

# --- PreviewFeatureList (7 fields) ---
# [[types]]
# schema = "PreviewFeatureList"
# include_fields = ["etag", "id", "items", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   etag: string
#   id: string
#   items: array<PreviewFeature>
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- PreviewFeatureRolloutOperation (1 fields) ---
# Represents the rollout operation
# [[types]]
# schema = "PreviewFeatureRolloutOperation"
# include_fields = ["rolloutInput"]
#
#   rolloutInput: $ref: PreviewFeatureRolloutOperationRolloutInput

# --- PreviewFeatureRolloutOperationRolloutInput (2 fields) ---
# Represents the input for the rollout operation.
# [[types]]
# schema = "PreviewFeatureRolloutOperationRolloutInput"
# include_fields = ["name", "predefinedRolloutPlan"]
#
#   name: string
#   predefinedRolloutPlan: string, enum: [ROLLOUT_PLAN_FAST_ROLLOUT, ROLLOUT_PLAN_TWO_DAY_ROLLOUT, ROLLOUT_PLAN_UNSPECIFIED]
#
# [types.field_overrides]
# name = { required = true }
# # predefinedRolloutPlan = { enum_type = "PreviewFeatureRolloutOperationRolloutInputPredefinedRolloutPlan" }

# --- PreviewFeatureStatus (3 fields) ---
# [Output Only] The status of the feature.
# [[types]]
# schema = "PreviewFeatureStatus"
# include_fields = ["description", "helpLink", "releaseStatus"]
#
#   description: string, readOnly
#   helpLink: string, readOnly
#   releaseStatus: $ref: PreviewFeatureStatusReleaseStatus

# --- PreviewFeatureStatusReleaseStatus (2 fields) ---
# [Output Only] The release status of the feature.
# [[types]]
# schema = "PreviewFeatureStatusReleaseStatus"
# include_fields = ["stage", "updateDate"]
#
#   stage: string, enum: [DEPRECATED, GA, PREVIEW, STAGE_UNSPECIFIED], readOnly
#   updateDate: $ref: Date, readOnly
#
# [types.field_overrides]
# # stage = { enum_type = "PreviewFeatureStatusReleaseStatusStage" }

# --- Project (15 fields) ---
# Represents a Project resource. A project is used to organize resources in a Google Cloud Platform en
# [[types]]
# schema = "Project"
# include_fields = ["cloudArmorTier", "commonInstanceMetadata", "creationTimestamp", "defaultNetworkTier", "defaultServiceAccount", "description", "enabledFeatures", "id", "kind", "name", "quotas", "selfLink", "usageExportLocation", "vmDnsSetting", "xpnProjectStatus"]
#
#   cloudArmorTier: string, enum: [CA_ENTERPRISE_ANNUAL, CA_ENTERPRISE_PAYGO, CA_STANDARD], readOnly
#   commonInstanceMetadata: $ref: Metadata
#   creationTimestamp: string
#   defaultNetworkTier: string, enum: [FIXED_STANDARD, PREMIUM, STANDARD, STANDARD_OVERRIDES_FIXED_STANDARD]
#   defaultServiceAccount: string
#   description: string
#   enabledFeatures: array<string>
#   id: string, format: uint64
#   kind: string, readOnly
#   name: string
#   quotas: array<Quota>
#   selfLink: string
#   usageExportLocation: $ref: UsageExportLocation
#   vmDnsSetting: string, enum: [GLOBAL_DEFAULT, UNSPECIFIED_VM_DNS_SETTING, ZONAL_DEFAULT, ZONAL_ONLY], readOnly
#   xpnProjectStatus: string, enum: [HOST, UNSPECIFIED_XPN_PROJECT_STATUS]
#
# [types.field_overrides]
# name = { required = true }
# # xpnProjectStatus = { enum_type = "ProjectXpnProjectStatus" }
# # defaultNetworkTier = { enum_type = "ProjectDefaultNetworkTier" }
# # cloudArmorTier = { enum_type = "ProjectCloudArmorTier" }
# # vmDnsSetting = { enum_type = "ProjectVmDnsSetting" }

# --- ProjectsDisableXpnResourceRequest (1 fields) ---
# [[types]]
# schema = "ProjectsDisableXpnResourceRequest"
# include_fields = ["xpnResource"]
#
#   xpnResource: $ref: XpnResourceId

# --- ProjectsEnableXpnResourceRequest (1 fields) ---
# [[types]]
# schema = "ProjectsEnableXpnResourceRequest"
# include_fields = ["xpnResource"]
#
#   xpnResource: $ref: XpnResourceId

# --- ProjectsGetXpnResources (3 fields) ---
# [[types]]
# schema = "ProjectsGetXpnResources"
# include_fields = ["kind", "nextPageToken", "resources"]
#
#   kind: string, readOnly
#   nextPageToken: string, readOnly
#   resources: array<XpnResourceId>

# --- ProjectsListXpnHostsRequest (1 fields) ---
# [[types]]
# schema = "ProjectsListXpnHostsRequest"
# include_fields = ["organization"]
#
#   organization: string

# --- ProjectsSetCloudArmorTierRequest (1 fields) ---
# [[types]]
# schema = "ProjectsSetCloudArmorTierRequest"
# include_fields = ["cloudArmorTier"]
#
#   cloudArmorTier: string, enum: [CA_ENTERPRISE_ANNUAL, CA_ENTERPRISE_PAYGO, CA_STANDARD]
#
# [types.field_overrides]
# # cloudArmorTier = { enum_type = "ProjectsSetCloudArmorTierRequestCloudArmorTier" }

# --- ProjectsSetDefaultNetworkTierRequest (1 fields) ---
# [[types]]
# schema = "ProjectsSetDefaultNetworkTierRequest"
# include_fields = ["networkTier"]
#
#   networkTier: string, enum: [FIXED_STANDARD, PREMIUM, STANDARD, STANDARD_OVERRIDES_FIXED_STANDARD]
#
# [types.field_overrides]
# # networkTier = { enum_type = "ProjectsSetDefaultNetworkTierRequestNetworkTier" }

# --- PublicAdvertisedPrefix (15 fields) ---
# A public advertised prefix represents an aggregated IP prefix or netblock which customers bring to c
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "PublicAdvertisedPrefix"
# include_fields = ["byoipApiVersion", "creationTimestamp", "description", "dnsVerificationIp", "fingerprint", "id", "ipCidrRange", "ipv6AccessType", "kind", "name", "pdpScope", "publicDelegatedPrefixs", "selfLink", "sharedSecret", "status"]
#
#   byoipApiVersion: string, enum: [V1, V2], readOnly
#   creationTimestamp: string, readOnly
#   description: string
#   dnsVerificationIp: string
#   fingerprint: string, format: byte
#   id: string, format: uint64, readOnly
#   ipCidrRange: string
#   ipv6AccessType: string, enum: [EXTERNAL, INTERNAL]
#   kind: string, readOnly
#   name: string
#   pdpScope: string, enum: [GLOBAL, GLOBAL_AND_REGIONAL, REGIONAL]
#   publicDelegatedPrefixs: array<PublicAdvertisedPrefixPublicDelegatedPrefix>, readOnly
#   selfLink: string, readOnly
#   sharedSecret: string
#   status: string, enum: [ANNOUNCED_TO_INTERNET, INITIAL, PREFIX_CONFIGURATION_COMPLETE, PREFIX_CONFIGURATION_IN_PROGRESS, ... +5]
#
# [types.field_overrides]
# name = { required = true }
# fingerprint = { format = "bytes" }
# # ipv6AccessType = { enum_type = "PublicAdvertisedPrefixIpv6AccessType" }
# # byoipApiVersion = { enum_type = "PublicAdvertisedPrefixByoipApiVersion" }
# # status = { enum_type = "PublicAdvertisedPrefixStatus" }
# # pdpScope = { enum_type = "PublicAdvertisedPrefixPdpScope" }

# --- PublicAdvertisedPrefixList (6 fields) ---
# [[types]]
# schema = "PublicAdvertisedPrefixList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<PublicAdvertisedPrefix>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string
#   warning: object

# --- PublicAdvertisedPrefixPublicDelegatedPrefix (5 fields) ---
# Represents a CIDR range which can be used to assign addresses.
# [[types]]
# schema = "PublicAdvertisedPrefixPublicDelegatedPrefix"
# include_fields = ["ipRange", "name", "project", "region", "status"]
#
#   ipRange: string
#   name: string
#   project: string
#   region: string
#   status: string
#
# [types.field_overrides]
# name = { required = true }

# --- PublicDelegatedPrefix (18 fields) ---
# A PublicDelegatedPrefix resource represents an IP block within a PublicAdvertisedPrefix that is conf
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "PublicDelegatedPrefix"
# include_fields = ["allocatablePrefixLength", "byoipApiVersion", "creationTimestamp", "description", "enableEnhancedIpv4Allocation", "fingerprint", "id", "ipCidrRange", "ipv6AccessType", "isLiveMigration", "kind", "mode", "name", "parentPrefix", "publicDelegatedSubPrefixs", "region", "selfLink", "status"]
#
#   allocatablePrefixLength: integer, format: int32
#   byoipApiVersion: string, enum: [V1, V2], readOnly
#   creationTimestamp: string, readOnly
#   description: string
#   enableEnhancedIpv4Allocation: boolean, readOnly
#   fingerprint: string, format: byte
#   id: string, format: uint64, readOnly
#   ipCidrRange: string
#   ipv6AccessType: string, enum: [EXTERNAL, INTERNAL], readOnly
#   isLiveMigration: boolean
#   kind: string, readOnly
#   mode: string, enum: [DELEGATION, EXTERNAL_IPV6_FORWARDING_RULE_CREATION, EXTERNAL_IPV6_SUBNETWORK_CREATION, INTERNAL_IPV6_SUBNETWORK_CREATION]
#   name: string
#   parentPrefix: string
#   publicDelegatedSubPrefixs: array<PublicDelegatedPrefixPublicDelegatedSubPrefix>
#   region: string, readOnly
#   selfLink: string, readOnly
#   status: string, enum: [ACTIVE, ANNOUNCED, ANNOUNCED_TO_GOOGLE, ANNOUNCED_TO_INTERNET, ... +3]
#
# [types.field_overrides]
# name = { required = true }
# fingerprint = { format = "bytes" }
# # ipv6AccessType = { enum_type = "PublicDelegatedPrefixIpv6AccessType" }
# # byoipApiVersion = { enum_type = "PublicDelegatedPrefixByoipApiVersion" }
# # status = { enum_type = "PublicDelegatedPrefixStatus" }
# # mode = { enum_type = "PublicDelegatedPrefixMode" }

# --- PublicDelegatedPrefixAggregatedList (7 fields) ---
# [[types]]
# schema = "PublicDelegatedPrefixAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, PublicDelegatedPrefixesScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string
#   unreachables: array<string>, readOnly
#   warning: object

# --- PublicDelegatedPrefixList (6 fields) ---
# [[types]]
# schema = "PublicDelegatedPrefixList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<PublicDelegatedPrefix>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string
#   warning: object

# --- PublicDelegatedPrefixPublicDelegatedSubPrefix (11 fields) ---
# Represents a sub PublicDelegatedPrefix.
# [[types]]
# schema = "PublicDelegatedPrefixPublicDelegatedSubPrefix"
# include_fields = ["allocatablePrefixLength", "delegateeProject", "description", "enableEnhancedIpv4Allocation", "ipCidrRange", "ipv6AccessType", "isAddress", "mode", "name", "region", "status"]
#
#   allocatablePrefixLength: integer, format: int32
#   delegateeProject: string
#   description: string
#   enableEnhancedIpv4Allocation: boolean, readOnly
#   ipCidrRange: string
#   ipv6AccessType: string, enum: [EXTERNAL, INTERNAL], readOnly
#   isAddress: boolean
#   mode: string, enum: [DELEGATION, EXTERNAL_IPV6_FORWARDING_RULE_CREATION, EXTERNAL_IPV6_SUBNETWORK_CREATION, INTERNAL_IPV6_SUBNETWORK_CREATION]
#   name: string
#   region: string, readOnly
#   status: string, enum: [ACTIVE, INACTIVE], readOnly
#
# [types.field_overrides]
# name = { required = true }
# # status = { enum_type = "PublicDelegatedPrefixPublicDelegatedSubPrefixStatus" }
# # ipv6AccessType = { enum_type = "PublicDelegatedPrefixPublicDelegatedSubPrefixIpv6AccessType" }
# # mode = { enum_type = "PublicDelegatedPrefixPublicDelegatedSubPrefixMode" }

# --- PublicDelegatedPrefixesScopedList (2 fields) ---
# [[types]]
# schema = "PublicDelegatedPrefixesScopedList"
# include_fields = ["publicDelegatedPrefixes", "warning"]
#
#   publicDelegatedPrefixes: array<PublicDelegatedPrefix>
#   warning: object

# --- Quota (4 fields) ---
# A quotas entry.
# [[types]]
# schema = "Quota"
# include_fields = ["limit", "metric", "owner", "usage"]
#
#   limit: number, format: double
#   metric: string, enum: [A2_CPUS, AFFINITY_GROUPS, AUTOSCALERS, BACKEND_BUCKETS, ... +160]
#   owner: string
#   usage: number, format: double
#
# [types.field_overrides]
# # metric = { enum_type = "QuotaMetric" }

# --- QuotaExceededInfo (6 fields) ---
# Additional details for quota exceeded error for resource quota.
# [[types]]
# schema = "QuotaExceededInfo"
# include_fields = ["dimensions", "futureLimit", "limit", "limitName", "metricName", "rolloutStatus"]
#
#   dimensions: map<string, string>
#   futureLimit: number, format: double
#   limit: number, format: double
#   limitName: string
#   metricName: string
#   rolloutStatus: string, enum: [IN_PROGRESS, ROLLOUT_STATUS_UNSPECIFIED]
#
# [types.field_overrides]
# # rolloutStatus = { enum_type = "QuotaExceededInfoRolloutStatus" }

# --- Reference (4 fields) ---
# Represents a reference to a resource.
# [[types]]
# schema = "Reference"
# include_fields = ["kind", "referenceType", "referrer", "target"]
#
#   kind: string, readOnly
#   referenceType: string
#   referrer: string
#   target: string

# --- Region (12 fields) ---
# Represents a Region resource. A region is a geographical area where a resource is located. For more 
# [[types]]
# schema = "Region"
# include_fields = ["creationTimestamp", "deprecated", "description", "id", "kind", "name", "quotaStatusWarning", "quotas", "selfLink", "status", "supportsPzs", "zones"]
#
#   creationTimestamp: string
#   deprecated: $ref: DeprecationStatus
#   description: string
#   id: string, format: uint64
#   kind: string, readOnly
#   name: string
#   quotaStatusWarning: object, readOnly
#   quotas: array<Quota>
#   selfLink: string
#   status: string, enum: [DOWN, UP]
#   supportsPzs: boolean, readOnly
#   zones: array<string>
#
# [types.field_overrides]
# name = { required = true }
# # status = { enum_type = "RegionStatus" }

# --- RegionAddressesMoveRequest (2 fields) ---
# [[types]]
# schema = "RegionAddressesMoveRequest"
# include_fields = ["description", "destinationAddress"]
#
#   description: string
#   destinationAddress: string

# --- RegionAutoscalerList (6 fields) ---
# Contains a list of autoscalers.
# [[types]]
# schema = "RegionAutoscalerList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<Autoscaler>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- RegionDiskTypeList (6 fields) ---
# [[types]]
# schema = "RegionDiskTypeList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<DiskType>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- RegionDisksAddResourcePoliciesRequest (1 fields) ---
# [[types]]
# schema = "RegionDisksAddResourcePoliciesRequest"
# include_fields = ["resourcePolicies"]
#
#   resourcePolicies: array<string>

# --- RegionDisksRemoveResourcePoliciesRequest (1 fields) ---
# [[types]]
# schema = "RegionDisksRemoveResourcePoliciesRequest"
# include_fields = ["resourcePolicies"]
#
#   resourcePolicies: array<string>

# --- RegionDisksResizeRequest (1 fields) ---
# [[types]]
# schema = "RegionDisksResizeRequest"
# include_fields = ["sizeGb"]
#
#   sizeGb: string, format: int64

# --- RegionDisksStartAsyncReplicationRequest (1 fields) ---
# [[types]]
# schema = "RegionDisksStartAsyncReplicationRequest"
# include_fields = ["asyncSecondaryDisk"]
#
#   asyncSecondaryDisk: string

# --- RegionInstanceGroupList (6 fields) ---
# Contains a list of InstanceGroup resources.
# [[types]]
# schema = "RegionInstanceGroupList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string, readOnly
#   items: array<InstanceGroup>
#   kind: string, readOnly
#   nextPageToken: string, readOnly
#   selfLink: string, readOnly
#   warning: object, readOnly

# --- RegionInstanceGroupManagerDeleteInstanceConfigReq (1 fields) ---
# RegionInstanceGroupManagers.deletePerInstanceConfigs
# [[types]]
# schema = "RegionInstanceGroupManagerDeleteInstanceConfigReq"
# include_fields = ["names"]
#
#   names: array<string>

# --- RegionInstanceGroupManagerList (6 fields) ---
# Contains a list of managed instance groups.
# [[types]]
# schema = "RegionInstanceGroupManagerList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string, readOnly
#   items: array<InstanceGroupManager>
#   kind: string, readOnly
#   nextPageToken: string, readOnly
#   selfLink: string, readOnly
#   warning: object, readOnly

# --- RegionInstanceGroupManagerPatchInstanceConfigReq (1 fields) ---
# RegionInstanceGroupManagers.patchPerInstanceConfigs
# [[types]]
# schema = "RegionInstanceGroupManagerPatchInstanceConfigReq"
# include_fields = ["perInstanceConfigs"]
#
#   perInstanceConfigs: array<PerInstanceConfig>

# --- RegionInstanceGroupManagerUpdateInstanceConfigReq (1 fields) ---
# RegionInstanceGroupManagers.updatePerInstanceConfigs
# [[types]]
# schema = "RegionInstanceGroupManagerUpdateInstanceConfigReq"
# include_fields = ["perInstanceConfigs"]
#
#   perInstanceConfigs: array<PerInstanceConfig>

# --- RegionInstanceGroupManagersAbandonInstancesRequest (1 fields) ---
# [[types]]
# schema = "RegionInstanceGroupManagersAbandonInstancesRequest"
# include_fields = ["instances"]
#
#   instances: array<string>

# --- RegionInstanceGroupManagersApplyUpdatesRequest (4 fields) ---
# RegionInstanceGroupManagers.applyUpdatesToInstances
# [[types]]
# schema = "RegionInstanceGroupManagersApplyUpdatesRequest"
# include_fields = ["allInstances", "instances", "minimalAction", "mostDisruptiveAllowedAction"]
#
#   allInstances: boolean
#   instances: array<string>
#   minimalAction: string, enum: [NONE, REFRESH, REPLACE, RESTART]
#   mostDisruptiveAllowedAction: string, enum: [NONE, REFRESH, REPLACE, RESTART]
#
# [types.field_overrides]
# # minimalAction = { enum_type = "RegionInstanceGroupManagersApplyUpdatesRequestMinimalAction" }
# # mostDisruptiveAllowedAction = { enum_type = "RegionInstanceGroupManagersApplyUpdatesRequestMostDisruptiveAllowedAction" }

# --- RegionInstanceGroupManagersCreateInstancesRequest (1 fields) ---
# RegionInstanceGroupManagers.createInstances
# [[types]]
# schema = "RegionInstanceGroupManagersCreateInstancesRequest"
# include_fields = ["instances"]
#
#   instances: array<PerInstanceConfig>

# --- RegionInstanceGroupManagersDeleteInstancesRequest (2 fields) ---
# [[types]]
# schema = "RegionInstanceGroupManagersDeleteInstancesRequest"
# include_fields = ["instances", "skipInstancesOnValidationError"]
#
#   instances: array<string>
#   skipInstancesOnValidationError: boolean

# --- RegionInstanceGroupManagersListErrorsResponse (2 fields) ---
# [[types]]
# schema = "RegionInstanceGroupManagersListErrorsResponse"
# include_fields = ["items", "nextPageToken"]
#
#   items: array<InstanceManagedByIgmError>
#   nextPageToken: string, readOnly

# --- RegionInstanceGroupManagersListInstanceConfigsResp (3 fields) ---
# [[types]]
# schema = "RegionInstanceGroupManagersListInstanceConfigsResp"
# include_fields = ["items", "nextPageToken", "warning"]
#
#   items: array<PerInstanceConfig>, readOnly
#   nextPageToken: string, readOnly
#   warning: object, readOnly

# --- RegionInstanceGroupManagersListInstancesResponse (2 fields) ---
# [[types]]
# schema = "RegionInstanceGroupManagersListInstancesResponse"
# include_fields = ["managedInstances", "nextPageToken"]
#
#   managedInstances: array<ManagedInstance>
#   nextPageToken: string, readOnly

# --- RegionInstanceGroupManagersRecreateRequest (1 fields) ---
# [[types]]
# schema = "RegionInstanceGroupManagersRecreateRequest"
# include_fields = ["instances"]
#
#   instances: array<string>

# --- RegionInstanceGroupManagersResumeInstancesRequest (1 fields) ---
# [[types]]
# schema = "RegionInstanceGroupManagersResumeInstancesRequest"
# include_fields = ["instances"]
#
#   instances: array<string>

# --- RegionInstanceGroupManagersSetTargetPoolsRequest (2 fields) ---
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "RegionInstanceGroupManagersSetTargetPoolsRequest"
# include_fields = ["fingerprint", "targetPools"]
#
#   fingerprint: string, format: byte
#   targetPools: array<string>
#
# [types.field_overrides]
# fingerprint = { format = "bytes" }

# --- RegionInstanceGroupManagersSetTemplateRequest (1 fields) ---
# [[types]]
# schema = "RegionInstanceGroupManagersSetTemplateRequest"
# include_fields = ["instanceTemplate"]
#
#   instanceTemplate: string

# --- RegionInstanceGroupManagersStartInstancesRequest (1 fields) ---
# [[types]]
# schema = "RegionInstanceGroupManagersStartInstancesRequest"
# include_fields = ["instances"]
#
#   instances: array<string>

# --- RegionInstanceGroupManagersStopInstancesRequest (2 fields) ---
# [[types]]
# schema = "RegionInstanceGroupManagersStopInstancesRequest"
# include_fields = ["forceStop", "instances"]
#
#   forceStop: boolean
#   instances: array<string>

# --- RegionInstanceGroupManagersSuspendInstancesRequest (2 fields) ---
# [[types]]
# schema = "RegionInstanceGroupManagersSuspendInstancesRequest"
# include_fields = ["forceSuspend", "instances"]
#
#   forceSuspend: boolean
#   instances: array<string>

# --- RegionInstanceGroupsListInstances (6 fields) ---
# [[types]]
# schema = "RegionInstanceGroupsListInstances"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string, readOnly
#   items: array<InstanceWithNamedPorts>
#   kind: string, readOnly
#   nextPageToken: string, readOnly
#   selfLink: string, readOnly
#   warning: object, readOnly

# --- RegionInstanceGroupsListInstancesRequest (2 fields) ---
# [[types]]
# schema = "RegionInstanceGroupsListInstancesRequest"
# include_fields = ["instanceState", "portName"]
#
#   instanceState: string, enum: [ALL, RUNNING]
#   portName: string
#
# [types.field_overrides]
# # instanceState = { enum_type = "RegionInstanceGroupsListInstancesRequestInstanceState" }

# --- RegionInstanceGroupsSetNamedPortsRequest (2 fields) ---
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "RegionInstanceGroupsSetNamedPortsRequest"
# include_fields = ["fingerprint", "namedPorts"]
#
#   fingerprint: string, format: byte
#   namedPorts: array<NamedPort>
#
# [types.field_overrides]
# fingerprint = { format = "bytes" }

# --- RegionList (6 fields) ---
# Contains a list of region resources.
# [[types]]
# schema = "RegionList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<Region>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- RegionNetworkEndpointGroupsAttachEndpointsRequest (1 fields) ---
# [[types]]
# schema = "RegionNetworkEndpointGroupsAttachEndpointsRequest"
# include_fields = ["networkEndpoints"]
#
#   networkEndpoints: array<NetworkEndpoint>

# --- RegionNetworkEndpointGroupsDetachEndpointsRequest (1 fields) ---
# [[types]]
# schema = "RegionNetworkEndpointGroupsDetachEndpointsRequest"
# include_fields = ["networkEndpoints"]
#
#   networkEndpoints: array<NetworkEndpoint>

# --- RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponse (2 fields) ---
# [[types]]
# schema = "RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponse"
# include_fields = ["firewallPolicys", "firewalls"]
#
#   firewallPolicys: array<RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponseEffectiveFirewallPolicy>, readOnly
#   firewalls: array<Firewall>

# --- RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponseEffectiveFirewallPolicy (6 fields) ---
# WARNING: reserved words: type
# [[types]]
# schema = "RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponseEffectiveFirewallPolicy"
# include_fields = ["displayName", "name", "packetMirroringRules", "priority", "rules", "type"]
#
#   displayName: string, readOnly
#   name: string, readOnly
#   packetMirroringRules: array<FirewallPolicyRule>, readOnly
#   priority: integer, format: int32, readOnly
#   rules: array<FirewallPolicyRule>, readOnly
#   type: string, enum: [HIERARCHY, NETWORK, NETWORK_REGIONAL, SYSTEM_GLOBAL, ... +2], readOnly, RESERVED_WORD
#
# [types.field_overrides]
# name = { required = true }
# type = { rust_name = "type_value", serde_rename = "type" }
# # type = { enum_type = "RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponseEffectiveFirewallPolicyType" }

# --- RegionSetLabelsRequest (2 fields) ---
# WARNING: format:"byte" fields: labelFingerprint
# [[types]]
# schema = "RegionSetLabelsRequest"
# include_fields = ["labelFingerprint", "labels"]
#
#   labelFingerprint: string, format: byte
#   labels: map<string, string>
#
# [types.field_overrides]
# labelFingerprint = { format = "bytes" }

# --- RegionSetPolicyRequest (3 fields) ---
# WARNING: format:"byte" fields: etag
# [[types]]
# schema = "RegionSetPolicyRequest"
# include_fields = ["bindings", "etag", "policy"]
#
#   bindings: array<Binding>
#   etag: string, format: byte
#   policy: $ref: Policy
#
# [types.field_overrides]
# etag = { format = "bytes" }

# --- RegionTargetHttpsProxiesSetSslCertificatesRequest (1 fields) ---
# [[types]]
# schema = "RegionTargetHttpsProxiesSetSslCertificatesRequest"
# include_fields = ["sslCertificates"]
#
#   sslCertificates: array<string>

# --- RegionUrlMapsValidateRequest (1 fields) ---
# [[types]]
# schema = "RegionUrlMapsValidateRequest"
# include_fields = ["resource"]
#
#   resource: $ref: UrlMap

# --- RequestMirrorPolicy (2 fields) ---
# A policy that specifies how requests intended for the route's backends are shadowed to a separate mi
# [[types]]
# schema = "RequestMirrorPolicy"
# include_fields = ["backendService", "mirrorPercent"]
#
#   backendService: string
#   mirrorPercent: number, format: double

# --- Reservation (25 fields) ---
# Represents a reservation resource. A reservation ensures that capacity is held in a specific zone ev
# [[types]]
# schema = "Reservation"
# include_fields = ["advancedDeploymentControl", "aggregateReservation", "commitment", "creationTimestamp", "deleteAfterDuration", "deleteAtTime", "deploymentType", "description", "enableEmergentMaintenance", "id", "kind", "linkedCommitments", "name", "protectionTier", "reservationSharingPolicy", "resourcePolicies", "resourceStatus", "satisfiesPzs", "schedulingType", "selfLink", "shareSettings", "specificReservation", "specificReservationRequired", "status", "zone"]
#
#   advancedDeploymentControl: $ref: ReservationAdvancedDeploymentControl
#   aggregateReservation: $ref: AllocationAggregateReservation
#   commitment: string, readOnly
#   creationTimestamp: string, readOnly
#   deleteAfterDuration: $ref: Duration
#   deleteAtTime: string
#   deploymentType: string, enum: [DENSE, DEPLOYMENT_TYPE_UNSPECIFIED]
#   description: string
#   enableEmergentMaintenance: boolean
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   linkedCommitments: array<string>, readOnly
#   name: string
#   protectionTier: string, enum: [CAPACITY_OPTIMIZED, PROTECTION_TIER_UNSPECIFIED, STANDARD]
#   reservationSharingPolicy: $ref: AllocationReservationSharingPolicy
#   resourcePolicies: map<string, string>
#   resourceStatus: $ref: AllocationResourceStatus, readOnly
#   satisfiesPzs: boolean, readOnly
#   schedulingType: string, enum: [GROUPED, GROUP_MAINTENANCE_TYPE_UNSPECIFIED, INDEPENDENT]
#   selfLink: string, readOnly
#   shareSettings: $ref: ShareSettings
#   specificReservation: $ref: AllocationSpecificSKUReservation
#   specificReservationRequired: boolean
#   status: string, enum: [CREATING, DELETING, INVALID, READY, UPDATING], readOnly
#   zone: string
#
# [types.field_overrides]
# name = { required = true }
# # protectionTier = { enum_type = "ReservationProtectionTier" }
# # deploymentType = { enum_type = "ReservationDeploymentType" }
# # status = { enum_type = "ReservationStatus" }
# # schedulingType = { enum_type = "ReservationSchedulingType" }

# --- ReservationAdvancedDeploymentControl (1 fields) ---
# Advance control for cluster management, applicable only to DENSE deployment type reservations.
# [[types]]
# schema = "ReservationAdvancedDeploymentControl"
# include_fields = ["reservationOperationalMode"]
#
#   reservationOperationalMode: string, enum: [ALL_CAPACITY, HIGHLY_AVAILABLE_CAPACITY, RESERVATION_OPERATIONAL_MODE_UNSPECIFIED]
#
# [types.field_overrides]
# # reservationOperationalMode = { enum_type = "ReservationAdvancedDeploymentControlReservationOperationalMode" }

# --- ReservationAffinity (3 fields) ---
# Specifies the reservations that this instance can consume from.
# [[types]]
# schema = "ReservationAffinity"
# include_fields = ["consumeReservationType", "key", "values"]
#
#   consumeReservationType: string, enum: [ANY_RESERVATION, NO_RESERVATION, SPECIFIC_RESERVATION, UNSPECIFIED]
#   key: string
#   values: array<string>
#
# [types.field_overrides]
# # consumeReservationType = { enum_type = "ReservationAffinityConsumeReservationType" }

# --- ReservationAggregatedList (7 fields) ---
# Contains a list of reservations.
# [[types]]
# schema = "ReservationAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, ReservationsScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- ReservationBlock (16 fields) ---
# Represents a reservation block resource.
# [[types]]
# schema = "ReservationBlock"
# include_fields = ["count", "creationTimestamp", "healthInfo", "id", "inUseCount", "inUseHostCount", "kind", "name", "physicalTopology", "reservationMaintenance", "reservationSubBlockCount", "reservationSubBlockInUseCount", "selfLink", "selfLinkWithId", "status", "zone"]
#
#   count: integer, format: int32, readOnly
#   creationTimestamp: string, readOnly
#   healthInfo: $ref: ReservationBlockHealthInfo, readOnly
#   id: string, format: uint64, readOnly
#   inUseCount: integer, format: int32, readOnly
#   inUseHostCount: integer, format: int32, readOnly
#   kind: string, readOnly
#   name: string, readOnly
#   physicalTopology: $ref: ReservationBlockPhysicalTopology, readOnly
#   reservationMaintenance: $ref: GroupMaintenanceInfo, readOnly
#   reservationSubBlockCount: integer, format: int32, readOnly
#   reservationSubBlockInUseCount: integer, format: int32, readOnly
#   selfLink: string, readOnly
#   selfLinkWithId: string, readOnly
#   status: string, enum: [CREATING, DELETING, INVALID, READY], readOnly
#   zone: string, readOnly
#
# [types.field_overrides]
# name = { required = true }
# # status = { enum_type = "ReservationBlockStatus" }

# --- ReservationBlockHealthInfo (3 fields) ---
# Health information for the reservation block.
# [[types]]
# schema = "ReservationBlockHealthInfo"
# include_fields = ["degradedSubBlockCount", "healthStatus", "healthySubBlockCount"]
#
#   degradedSubBlockCount: integer, format: int32
#   healthStatus: string, enum: [DEGRADED, HEALTHY, HEALTH_STATUS_UNSPECIFIED]
#   healthySubBlockCount: integer, format: int32
#
# [types.field_overrides]
# # healthStatus = { enum_type = "ReservationBlockHealthInfoHealthStatus" }

# --- ReservationBlockPhysicalTopology (3 fields) ---
# [[types]]
# schema = "ReservationBlockPhysicalTopology"
# include_fields = ["block", "cluster", "instances"]
#
#   block: string
#   cluster: string
#   instances: array<ReservationBlockPhysicalTopologyInstance>, readOnly

# --- ReservationBlockPhysicalTopologyInstance (3 fields) ---
# The instances information for a given Block
# [[types]]
# schema = "ReservationBlockPhysicalTopologyInstance"
# include_fields = ["instanceId", "physicalHostTopology", "projectId"]
#
#   instanceId: string, format: uint64
#   physicalHostTopology: $ref: ReservationBlockPhysicalTopologyInstancePhysicalHostTopology, readOnly
#   projectId: string, format: uint64

# --- ReservationBlockPhysicalTopologyInstancePhysicalHostTopology (2 fields) ---
# The PhysicalHostTopology of the instance within a Block resource.
# [[types]]
# schema = "ReservationBlockPhysicalTopologyInstancePhysicalHostTopology"
# include_fields = ["host", "subBlock"]
#
#   host: string
#   subBlock: string

# --- ReservationBlocksGetResponse (1 fields) ---
# [[types]]
# schema = "ReservationBlocksGetResponse"
# include_fields = ["resource"]
#
#   resource: $ref: ReservationBlock

# --- ReservationBlocksListResponse (6 fields) ---
# A list of reservation blocks under a single reservation.
# [[types]]
# schema = "ReservationBlocksListResponse"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<ReservationBlock>
#   kind: string
#   nextPageToken: string
#   selfLink: string
#   warning: object

# --- ReservationList (6 fields) ---
# [[types]]
# schema = "ReservationList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<Reservation>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- ReservationSlot (11 fields) ---
# Represents a reservation slot resource.
# [[types]]
# schema = "ReservationSlot"
# include_fields = ["creationTimestamp", "id", "kind", "name", "physicalTopology", "selfLink", "selfLinkWithId", "shareSettings", "state", "status", "zone"]
#
#   creationTimestamp: string, readOnly
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   name: string, readOnly
#   physicalTopology: $ref: ReservationSlotPhysicalTopology, readOnly
#   selfLink: string, readOnly
#   selfLinkWithId: string, readOnly
#   shareSettings: $ref: ShareSettings
#   state: string, enum: [ACTIVE, CREATING, DELETING, STATE_UNSPECIFIED], readOnly
#   status: $ref: ReservationSlotStatus, readOnly
#   zone: string, readOnly
#
# [types.field_overrides]
# name = { required = true }
# # state = { enum_type = "ReservationSlotState" }

# --- ReservationSlotPhysicalTopology (4 fields) ---
# [[types]]
# schema = "ReservationSlotPhysicalTopology"
# include_fields = ["block", "cluster", "host", "subBlock"]
#
#   block: string
#   cluster: string
#   host: string
#   subBlock: string

# --- ReservationSlotStatus (3 fields) ---
# [[types]]
# schema = "ReservationSlotStatus"
# include_fields = ["physicalTopology", "rdmaIpAddresses", "runningInstances"]
#
#   physicalTopology: $ref: ReservationSlotPhysicalTopology, readOnly
#   rdmaIpAddresses: array<string>, readOnly
#   runningInstances: array<string>, readOnly

# --- ReservationSlotsGetResponse (1 fields) ---
# [[types]]
# schema = "ReservationSlotsGetResponse"
# include_fields = ["resource"]
#
#   resource: $ref: ReservationSlot

# --- ReservationSlotsListResponse (6 fields) ---
# A list of reservation slots within a single reservation.
# [[types]]
# schema = "ReservationSlotsListResponse"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<ReservationSlot>
#   kind: string
#   nextPageToken: string
#   selfLink: string
#   warning: object

# --- ReservationSubBlock (15 fields) ---
# Represents a reservation subBlock resource.
# [[types]]
# schema = "ReservationSubBlock"
# include_fields = ["acceleratorTopologiesInfo", "count", "creationTimestamp", "healthInfo", "id", "inUseCount", "inUseHostCount", "kind", "name", "physicalTopology", "reservationSubBlockMaintenance", "selfLink", "selfLinkWithId", "status", "zone"]
#
#   acceleratorTopologiesInfo: $ref: AcceleratorTopologiesInfo, readOnly
#   count: integer, format: int32, readOnly
#   creationTimestamp: string, readOnly
#   healthInfo: $ref: ReservationSubBlockHealthInfo, readOnly
#   id: string, format: uint64, readOnly
#   inUseCount: integer, format: int32, readOnly
#   inUseHostCount: integer, format: int32, readOnly
#   kind: string, readOnly
#   name: string, readOnly
#   physicalTopology: $ref: ReservationSubBlockPhysicalTopology, readOnly
#   reservationSubBlockMaintenance: $ref: GroupMaintenanceInfo, readOnly
#   selfLink: string, readOnly
#   selfLinkWithId: string, readOnly
#   status: string, enum: [CREATING, DELETING, INVALID, READY], readOnly
#   zone: string, readOnly
#
# [types.field_overrides]
# name = { required = true }
# # status = { enum_type = "ReservationSubBlockStatus" }

# --- ReservationSubBlockHealthInfo (5 fields) ---
# Health information for the reservation subBlock.
# [[types]]
# schema = "ReservationSubBlockHealthInfo"
# include_fields = ["degradedHostCount", "degradedInfraCount", "healthStatus", "healthyHostCount", "healthyInfraCount"]
#
#   degradedHostCount: integer, format: int32
#   degradedInfraCount: integer, format: int32
#   healthStatus: string, enum: [DEGRADED, HEALTHY, HEALTH_STATUS_UNSPECIFIED]
#   healthyHostCount: integer, format: int32
#   healthyInfraCount: integer, format: int32
#
# [types.field_overrides]
# # healthStatus = { enum_type = "ReservationSubBlockHealthInfoHealthStatus" }

# --- ReservationSubBlockPhysicalTopology (3 fields) ---
# [[types]]
# schema = "ReservationSubBlockPhysicalTopology"
# include_fields = ["block", "cluster", "subBlock"]
#
#   block: string
#   cluster: string
#   subBlock: string

# --- ReservationSubBlocksGetResponse (1 fields) ---
# [[types]]
# schema = "ReservationSubBlocksGetResponse"
# include_fields = ["resource"]
#
#   resource: $ref: ReservationSubBlock

# --- ReservationSubBlocksListResponse (6 fields) ---
# A list of reservation subBlocks under a single reservation.
# [[types]]
# schema = "ReservationSubBlocksListResponse"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<ReservationSubBlock>
#   kind: string
#   nextPageToken: string
#   selfLink: string
#   warning: object

# --- ReservationSubBlocksReportFaultyRequest (3 fields) ---
# [[types]]
# schema = "ReservationSubBlocksReportFaultyRequest"
# include_fields = ["disruptionSchedule", "failureComponent", "faultReasons"]
#
#   disruptionSchedule: string, enum: [DISRUPTION_SCHEDULE_UNSPECIFIED, IMMEDIATE]
#   failureComponent: string, enum: [FAILURE_COMPONENT_UNSPECIFIED, MULTIPLE_FAULTY_HOSTS, NVLINK_SWITCH]
#   faultReasons: array<ReservationSubBlocksReportFaultyRequestFaultReason>
#
# [types.field_overrides]
# # disruptionSchedule = { enum_type = "ReservationSubBlocksReportFaultyRequestDisruptionSchedule" }
# # failureComponent = { enum_type = "ReservationSubBlocksReportFaultyRequestFailureComponent" }

# --- ReservationSubBlocksReportFaultyRequestFaultReason (2 fields) ---
# The reason for the fault experienced with the subBlock.
# [[types]]
# schema = "ReservationSubBlocksReportFaultyRequestFaultReason"
# include_fields = ["behavior", "description"]
#
#   behavior: string, enum: [FAULT_BEHAVIOR_UNSPECIFIED, GPU_ERROR, PERFORMANCE, SILENT_DATA_CORRUPTION, SWITCH_FAILURE]
#   description: string
#
# [types.field_overrides]
# # behavior = { enum_type = "ReservationSubBlocksReportFaultyRequestFaultReasonBehavior" }

# --- ReservationsBlocksPerformMaintenanceRequest (1 fields) ---
# [[types]]
# schema = "ReservationsBlocksPerformMaintenanceRequest"
# include_fields = ["maintenanceScope"]
#
#   maintenanceScope: string, enum: [ALL, MAINTENANCE_SCOPE_UNSPECIFIED, RUNNING_VMS, UNUSED_CAPACITY]
#
# [types.field_overrides]
# # maintenanceScope = { enum_type = "ReservationsBlocksPerformMaintenanceRequestMaintenanceScope" }

# --- ReservationsPerformMaintenanceRequest (1 fields) ---
# [[types]]
# schema = "ReservationsPerformMaintenanceRequest"
# include_fields = ["maintenanceScope"]
#
#   maintenanceScope: string, enum: [ALL, MAINTENANCE_SCOPE_UNSPECIFIED, RUNNING_VMS, UNUSED_CAPACITY]
#
# [types.field_overrides]
# # maintenanceScope = { enum_type = "ReservationsPerformMaintenanceRequestMaintenanceScope" }

# --- ReservationsResizeRequest (1 fields) ---
# [[types]]
# schema = "ReservationsResizeRequest"
# include_fields = ["specificSkuCount"]
#
#   specificSkuCount: string, format: int64

# --- ReservationsScopedList (2 fields) ---
# [[types]]
# schema = "ReservationsScopedList"
# include_fields = ["reservations", "warning"]
#
#   reservations: array<Reservation>
#   warning: object

# --- ResourceCommitment (3 fields) ---
# Commitment for a particular hardware resource (a commitment is composed of one or more of these).
# WARNING: reserved words: type
# [[types]]
# schema = "ResourceCommitment"
# include_fields = ["acceleratorType", "amount", "type"]
#
#   acceleratorType: string
#   amount: string, format: int64
#   type: string, enum: [ACCELERATOR, LOCAL_SSD, MEMORY, UNSPECIFIED, VCPU], RESERVED_WORD
#
# [types.field_overrides]
# type = { rust_name = "type_value", serde_rename = "type" }
# # type = { enum_type = "ResourceCommitmentType" }

# --- ResourceGroupReference (1 fields) ---
# [[types]]
# schema = "ResourceGroupReference"
# include_fields = ["group"]
#
#   group: string

# --- ResourcePoliciesScopedList (2 fields) ---
# [[types]]
# schema = "ResourcePoliciesScopedList"
# include_fields = ["resourcePolicies", "warning"]
#
#   resourcePolicies: array<ResourcePolicy>
#   warning: object

# --- ResourcePolicy (14 fields) ---
# Represents a Resource Policy resource. You can use resource policies to schedule actions for some Co
# [[types]]
# schema = "ResourcePolicy"
# include_fields = ["creationTimestamp", "description", "diskConsistencyGroupPolicy", "groupPlacementPolicy", "id", "instanceSchedulePolicy", "kind", "name", "region", "resourceStatus", "selfLink", "snapshotSchedulePolicy", "status", "workloadPolicy"]
#
#   creationTimestamp: string, readOnly
#   description: string
#   diskConsistencyGroupPolicy: $ref: ResourcePolicyDiskConsistencyGroupPolicy
#   groupPlacementPolicy: $ref: ResourcePolicyGroupPlacementPolicy
#   id: string, format: uint64, readOnly
#   instanceSchedulePolicy: $ref: ResourcePolicyInstanceSchedulePolicy
#   kind: string, readOnly
#   name: string
#   region: string, readOnly
#   resourceStatus: $ref: ResourcePolicyResourceStatus, readOnly
#   selfLink: string, readOnly
#   snapshotSchedulePolicy: $ref: ResourcePolicySnapshotSchedulePolicy
#   status: string, enum: [CREATING, DELETING, EXPIRED, INVALID, READY], readOnly
#   workloadPolicy: $ref: ResourcePolicyWorkloadPolicy
#
# [types.field_overrides]
# name = { required = true }
# # status = { enum_type = "ResourcePolicyStatus" }

# --- ResourcePolicyAggregatedList (8 fields) ---
# Contains a list of resourcePolicies.
# [[types]]
# schema = "ResourcePolicyAggregatedList"
# include_fields = ["etag", "id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   etag: string
#   id: string
#   items: map<string, ResourcePoliciesScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- ResourcePolicyDailyCycle (3 fields) ---
# Time window specified for daily operations.
# [[types]]
# schema = "ResourcePolicyDailyCycle"
# include_fields = ["daysInCycle", "duration", "startTime"]
#
#   daysInCycle: integer, format: int32
#   duration: string, readOnly
#   startTime: string

# --- ResourcePolicyDiskConsistencyGroupPolicy (0 fields) ---
# Resource policy for disk consistency groups.
# [[types]]
# schema = "ResourcePolicyDiskConsistencyGroupPolicy"

# --- ResourcePolicyGroupPlacementPolicy (5 fields) ---
# A GroupPlacementPolicy specifies resource placement configuration. It specifies the failure bucket s
# [[types]]
# schema = "ResourcePolicyGroupPlacementPolicy"
# include_fields = ["acceleratorTopologyMode", "availabilityDomainCount", "collocation", "gpuTopology", "vmCount"]
#
#   acceleratorTopologyMode: string, enum: [AUTO_CONNECT, PROVISION_ONLY]
#   availabilityDomainCount: integer, format: int32
#   collocation: string, enum: [COLLOCATED, UNSPECIFIED_COLLOCATION]
#   gpuTopology: string
#   vmCount: integer, format: int32
#
# [types.field_overrides]
# # collocation = { enum_type = "ResourcePolicyGroupPlacementPolicyCollocation" }
# # acceleratorTopologyMode = { enum_type = "ResourcePolicyGroupPlacementPolicyAcceleratorTopologyMode" }

# --- ResourcePolicyHourlyCycle (3 fields) ---
# Time window specified for hourly operations.
# [[types]]
# schema = "ResourcePolicyHourlyCycle"
# include_fields = ["duration", "hoursInCycle", "startTime"]
#
#   duration: string, readOnly
#   hoursInCycle: integer, format: int32
#   startTime: string

# --- ResourcePolicyInstanceSchedulePolicy (5 fields) ---
# An InstanceSchedulePolicy specifies when and how frequent certain operations are performed on the in
# [[types]]
# schema = "ResourcePolicyInstanceSchedulePolicy"
# include_fields = ["expirationTime", "startTime", "timeZone", "vmStartSchedule", "vmStopSchedule"]
#
#   expirationTime: string
#   startTime: string
#   timeZone: string
#   vmStartSchedule: $ref: ResourcePolicyInstanceSchedulePolicySchedule
#   vmStopSchedule: $ref: ResourcePolicyInstanceSchedulePolicySchedule

# --- ResourcePolicyInstanceSchedulePolicySchedule (1 fields) ---
# Schedule for an instance operation.
# [[types]]
# schema = "ResourcePolicyInstanceSchedulePolicySchedule"
# include_fields = ["schedule"]
#
#   schedule: string

# --- ResourcePolicyList (7 fields) ---
# [[types]]
# schema = "ResourcePolicyList"
# include_fields = ["etag", "id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   etag: string
#   id: string
#   items: array<ResourcePolicy>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- ResourcePolicyResourceStatus (1 fields) ---
# Contains output only fields. Use this sub-message for all output fields set on ResourcePolicy. The i
# [[types]]
# schema = "ResourcePolicyResourceStatus"
# include_fields = ["instanceSchedulePolicy"]
#
#   instanceSchedulePolicy: $ref: ResourcePolicyResourceStatusInstanceSchedulePolicyStatus, readOnly

# --- ResourcePolicyResourceStatusInstanceSchedulePolicyStatus (2 fields) ---
# [[types]]
# schema = "ResourcePolicyResourceStatusInstanceSchedulePolicyStatus"
# include_fields = ["lastRunStartTime", "nextRunStartTime"]
#
#   lastRunStartTime: string, readOnly
#   nextRunStartTime: string, readOnly

# --- ResourcePolicySnapshotSchedulePolicy (3 fields) ---
# A snapshot schedule policy specifies when and how frequently snapshots are to be created for the tar
# [[types]]
# schema = "ResourcePolicySnapshotSchedulePolicy"
# include_fields = ["retentionPolicy", "schedule", "snapshotProperties"]
#
#   retentionPolicy: $ref: ResourcePolicySnapshotSchedulePolicyRetentionPolicy
#   schedule: $ref: ResourcePolicySnapshotSchedulePolicySchedule
#   snapshotProperties: $ref: ResourcePolicySnapshotSchedulePolicySnapshotProperties

# --- ResourcePolicySnapshotSchedulePolicyRetentionPolicy (2 fields) ---
# Policy for retention of scheduled snapshots.
# [[types]]
# schema = "ResourcePolicySnapshotSchedulePolicyRetentionPolicy"
# include_fields = ["maxRetentionDays", "onSourceDiskDelete"]
#
#   maxRetentionDays: integer, format: int32
#   onSourceDiskDelete: string, enum: [APPLY_RETENTION_POLICY, KEEP_AUTO_SNAPSHOTS, UNSPECIFIED_ON_SOURCE_DISK_DELETE]
#
# [types.field_overrides]
# # onSourceDiskDelete = { enum_type = "ResourcePolicySnapshotSchedulePolicyRetentionPolicyOnSourceDiskDelete" }

# --- ResourcePolicySnapshotSchedulePolicySchedule (3 fields) ---
# A schedule for disks where the schedueled operations are performed.
# [[types]]
# schema = "ResourcePolicySnapshotSchedulePolicySchedule"
# include_fields = ["dailySchedule", "hourlySchedule", "weeklySchedule"]
#
#   dailySchedule: $ref: ResourcePolicyDailyCycle
#   hourlySchedule: $ref: ResourcePolicyHourlyCycle
#   weeklySchedule: $ref: ResourcePolicyWeeklyCycle

# --- ResourcePolicySnapshotSchedulePolicySnapshotProperties (4 fields) ---
# Specified snapshot properties for scheduled snapshots created by this policy.
# [[types]]
# schema = "ResourcePolicySnapshotSchedulePolicySnapshotProperties"
# include_fields = ["chainName", "guestFlush", "labels", "storageLocations"]
#
#   chainName: string
#   guestFlush: boolean
#   labels: map<string, string>
#   storageLocations: array<string>

# --- ResourcePolicyWeeklyCycle (1 fields) ---
# Time window specified for weekly operations.
# [[types]]
# schema = "ResourcePolicyWeeklyCycle"
# include_fields = ["dayOfWeeks"]
#
#   dayOfWeeks: array<ResourcePolicyWeeklyCycleDayOfWeek>

# --- ResourcePolicyWeeklyCycleDayOfWeek (3 fields) ---
# [[types]]
# schema = "ResourcePolicyWeeklyCycleDayOfWeek"
# include_fields = ["day", "duration", "startTime"]
#
#   day: string, enum: [FRIDAY, INVALID, MONDAY, SATURDAY, ... +4]
#   duration: string, readOnly
#   startTime: string
#
# [types.field_overrides]
# # day = { enum_type = "ResourcePolicyWeeklyCycleDayOfWeekDay" }

# --- ResourcePolicyWorkloadPolicy (3 fields) ---
# Represents the workload policy.
# WARNING: reserved words: type
# [[types]]
# schema = "ResourcePolicyWorkloadPolicy"
# include_fields = ["acceleratorTopology", "maxTopologyDistance", "type"]
#
#   acceleratorTopology: string
#   maxTopologyDistance: string, enum: [BLOCK, CLUSTER, SUBBLOCK]
#   type: string, enum: [HIGH_AVAILABILITY, HIGH_THROUGHPUT], RESERVED_WORD
#
# [types.field_overrides]
# type = { rust_name = "type_value", serde_rename = "type" }
# # maxTopologyDistance = { enum_type = "ResourcePolicyWorkloadPolicyMaxTopologyDistance" }
# # type = { enum_type = "ResourcePolicyWorkloadPolicyType" }

# --- ResourceStatus (6 fields) ---
# Contains output only fields. Use this sub-message for actual values set on Instance attributes as co
# [[types]]
# schema = "ResourceStatus"
# include_fields = ["effectiveInstanceMetadata", "physicalHost", "physicalHostTopology", "reservationConsumptionInfo", "scheduling", "upcomingMaintenance"]
#
#   effectiveInstanceMetadata: $ref: ResourceStatusEffectiveInstanceMetadata, readOnly
#   physicalHost: string, readOnly
#   physicalHostTopology: $ref: ResourceStatusPhysicalHostTopology, readOnly
#   reservationConsumptionInfo: $ref: ResourceStatusReservationConsumptionInfo, readOnly
#   scheduling: $ref: ResourceStatusScheduling
#   upcomingMaintenance: $ref: UpcomingMaintenance, readOnly

# --- ResourceStatusEffectiveInstanceMetadata (8 fields) ---
# Effective values of predefined metadata keys for an instance.
# [[types]]
# schema = "ResourceStatusEffectiveInstanceMetadata"
# include_fields = ["blockProjectSshKeysMetadataValue", "enableGuestAttributesMetadataValue", "enableOsInventoryMetadataValue", "enableOsconfigMetadataValue", "enableOsloginMetadataValue", "serialPortEnableMetadataValue", "serialPortLoggingEnableMetadataValue", "vmDnsSettingMetadataValue"]
#
#   blockProjectSshKeysMetadataValue: boolean
#   enableGuestAttributesMetadataValue: boolean
#   enableOsInventoryMetadataValue: boolean
#   enableOsconfigMetadataValue: boolean
#   enableOsloginMetadataValue: boolean
#   serialPortEnableMetadataValue: boolean
#   serialPortLoggingEnableMetadataValue: boolean
#   vmDnsSettingMetadataValue: string

# --- ResourceStatusPhysicalHostTopology (4 fields) ---
# Represents the physical host topology of the host on which the VM is running.
# [[types]]
# schema = "ResourceStatusPhysicalHostTopology"
# include_fields = ["block", "cluster", "host", "subblock"]
#
#   block: string
#   cluster: string
#   host: string
#   subblock: string

# --- ResourceStatusReservationConsumptionInfo (1 fields) ---
# Reservation consumption information that the instance is consuming from.
# [[types]]
# schema = "ResourceStatusReservationConsumptionInfo"
# include_fields = ["consumedReservation"]
#
#   consumedReservation: string, readOnly

# --- ResourceStatusScheduling (1 fields) ---
# [[types]]
# schema = "ResourceStatusScheduling"
# include_fields = ["availabilityDomain"]
#
#   availabilityDomain: integer, format: int32

# --- Route (27 fields) ---
# Represents a Route resource. A route defines a path from VM instances in the VPC network to a specif
# [[types]]
# schema = "Route"
# include_fields = ["asPaths", "creationTimestamp", "description", "destRange", "id", "kind", "name", "network", "nextHopGateway", "nextHopHub", "nextHopIlb", "nextHopInstance", "nextHopInterRegionCost", "nextHopInterconnectAttachment", "nextHopIp", "nextHopMed", "nextHopNetwork", "nextHopOrigin", "nextHopPeering", "nextHopVpnTunnel", "params", "priority", "routeStatus", "routeType", "selfLink", "tags", "warnings"]
#
#   asPaths: array<RouteAsPath>, readOnly
#   creationTimestamp: string, readOnly
#   description: string
#   destRange: string
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   name: string
#   network: string
#   nextHopGateway: string
#   nextHopHub: string, readOnly
#   nextHopIlb: string
#   nextHopInstance: string
#   nextHopInterRegionCost: integer, format: uint32, readOnly
#   nextHopInterconnectAttachment: string, readOnly
#   nextHopIp: string
#   nextHopMed: integer, format: uint32, readOnly
#   nextHopNetwork: string
#   nextHopOrigin: string, enum: [EGP, IGP, INCOMPLETE], readOnly
#   nextHopPeering: string, readOnly
#   nextHopVpnTunnel: string
#   params: $ref: RouteParams
#   priority: integer, format: uint32
#   routeStatus: string, enum: [ACTIVE, DROPPED, INACTIVE, PENDING]
#   routeType: string, enum: [BGP, STATIC, SUBNET, TRANSIT], readOnly
#   selfLink: string
#   tags: array<string>
#   warnings: array<object>, readOnly
#
# [types.field_overrides]
# name = { required = true }
# # nextHopOrigin = { enum_type = "RouteNextHopOrigin" }
# # routeType = { enum_type = "RouteRouteType" }
# # routeStatus = { enum_type = "RouteRouteStatus" }

# --- RouteAsPath (2 fields) ---
# [[types]]
# schema = "RouteAsPath"
# include_fields = ["asLists", "pathSegmentType"]
#
#   asLists: array<integer>
#   pathSegmentType: string, enum: [AS_CONFED_SEQUENCE, AS_CONFED_SET, AS_SEQUENCE, AS_SET]
#
# [types.field_overrides]
# # pathSegmentType = { enum_type = "RouteAsPathPathSegmentType" }

# --- RouteList (6 fields) ---
# Contains a list of Route resources.
# [[types]]
# schema = "RouteList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<Route>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- RouteParams (1 fields) ---
# Additional route parameters.
# [[types]]
# schema = "RouteParams"
# include_fields = ["resourceManagerTags"]
#
#   resourceManagerTags: map<string, string>

# --- RoutePolicy (5 fields) ---
# WARNING: format:"byte" fields: fingerprint
# WARNING: reserved words: type
# [[types]]
# schema = "RoutePolicy"
# include_fields = ["description", "fingerprint", "name", "terms", "type"]
#
#   description: string
#   fingerprint: string, format: byte
#   name: string
#   terms: array<RoutePolicyPolicyTerm>
#   type: string, enum: [ROUTE_POLICY_TYPE_EXPORT, ROUTE_POLICY_TYPE_IMPORT], RESERVED_WORD
#
# [types.field_overrides]
# name = { required = true }
# type = { rust_name = "type_value", serde_rename = "type" }
# fingerprint = { format = "bytes" }
# # type = { enum_type = "RoutePolicyType" }

# --- RoutePolicyPolicyTerm (3 fields) ---
# WARNING: reserved words: match
# [[types]]
# schema = "RoutePolicyPolicyTerm"
# include_fields = ["actions", "match", "priority"]
#
#   actions: array<Expr>
#   match: $ref: Expr, RESERVED_WORD
#   priority: integer, format: int32
#
# [types.field_overrides]
# match = { rust_name = "match_value", serde_rename = "match" }

# --- Router (15 fields) [IN MANIFEST] ---
# Represents a Cloud Router resource. For more information about Cloud Router, read theCloud Router ov
# [[types]]
# schema = "Router"
# include_fields = ["bgp", "bgpPeers", "creationTimestamp", "description", "encryptedInterconnectRouter", "id", "interfaces", "kind", "md5AuthenticationKeys", "name", "nats", "network", "params", "region", "selfLink"]
#
#   bgp: $ref: RouterBgp
#   bgpPeers: array<RouterBgpPeer>
#   creationTimestamp: string, readOnly
#   description: string
#   encryptedInterconnectRouter: boolean
#   id: string, format: uint64
#   interfaces: array<RouterInterface>
#   kind: string, readOnly
#   md5AuthenticationKeys: array<RouterMd5AuthenticationKey>
#   name: string
#   nats: array<RouterNat>
#   network: string
#   params: $ref: RouterParams
#   region: string
#   selfLink: string
#
# [types.field_overrides]
# name = { required = true }

# --- RouterAdvertisedIpRange (2 fields) ---
# Description-tagged IP ranges for the router to advertise.
# [[types]]
# schema = "RouterAdvertisedIpRange"
# include_fields = ["description", "range"]
#
#   description: string
#   range: string

# --- RouterAggregatedList (7 fields) ---
# Contains a list of routers.
# [[types]]
# schema = "RouterAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, RoutersScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- RouterBgp (6 fields) ---
# [[types]]
# schema = "RouterBgp"
# include_fields = ["advertiseMode", "advertisedGroups", "advertisedIpRanges", "asn", "identifierRange", "keepaliveInterval"]
#
#   advertiseMode: string, enum: [CUSTOM, DEFAULT]
#   advertisedGroups: array<string>
#   advertisedIpRanges: array<RouterAdvertisedIpRange>
#   asn: integer, format: uint32
#   identifierRange: string
#   keepaliveInterval: integer, format: uint32
#
# [types.field_overrides]
# # advertiseMode = { enum_type = "RouterBgpAdvertiseMode" }

# --- RouterBgpPeer (24 fields) ---
# [[types]]
# schema = "RouterBgpPeer"
# include_fields = ["advertiseMode", "advertisedGroups", "advertisedIpRanges", "advertisedRoutePriority", "bfd", "customLearnedIpRanges", "customLearnedRoutePriority", "enable", "enableIpv4", "enableIpv6", "exportPolicies", "importPolicies", "interfaceName", "ipAddress", "ipv4NexthopAddress", "ipv6NexthopAddress", "managementType", "md5AuthenticationKeyName", "name", "peerAsn", "peerIpAddress", "peerIpv4NexthopAddress", "peerIpv6NexthopAddress", "routerApplianceInstance"]
#
#   advertiseMode: string, enum: [CUSTOM, DEFAULT]
#   advertisedGroups: array<string>
#   advertisedIpRanges: array<RouterAdvertisedIpRange>
#   advertisedRoutePriority: integer, format: uint32
#   bfd: $ref: RouterBgpPeerBfd
#   customLearnedIpRanges: array<RouterBgpPeerCustomLearnedIpRange>
#   customLearnedRoutePriority: integer, format: int32
#   enable: string, enum: [FALSE, TRUE]
#   enableIpv4: boolean
#   enableIpv6: boolean
#   exportPolicies: array<string>
#   importPolicies: array<string>
#   interfaceName: string
#   ipAddress: string
#   ipv4NexthopAddress: string
#   ipv6NexthopAddress: string
#   managementType: string, enum: [MANAGED_BY_ATTACHMENT, MANAGED_BY_USER], readOnly
#   md5AuthenticationKeyName: string
#   name: string
#   peerAsn: integer, format: uint32
#   peerIpAddress: string
#   peerIpv4NexthopAddress: string
#   peerIpv6NexthopAddress: string
#   routerApplianceInstance: string
#
# [types.field_overrides]
# name = { required = true }
# # enable = { enum_type = "RouterBgpPeerEnable" }
# # advertiseMode = { enum_type = "RouterBgpPeerAdvertiseMode" }
# # managementType = { enum_type = "RouterBgpPeerManagementType" }

# --- RouterBgpPeerBfd (4 fields) ---
# [[types]]
# schema = "RouterBgpPeerBfd"
# include_fields = ["minReceiveInterval", "minTransmitInterval", "multiplier", "sessionInitializationMode"]
#
#   minReceiveInterval: integer, format: uint32
#   minTransmitInterval: integer, format: uint32
#   multiplier: integer, format: uint32
#   sessionInitializationMode: string, enum: [ACTIVE, DISABLED, PASSIVE]
#
# [types.field_overrides]
# # sessionInitializationMode = { enum_type = "RouterBgpPeerBfdSessionInitializationMode" }

# --- RouterBgpPeerCustomLearnedIpRange (1 fields) ---
# [[types]]
# schema = "RouterBgpPeerCustomLearnedIpRange"
# include_fields = ["range"]
#
#   range: string

# --- RouterInterface (9 fields) ---
# [[types]]
# schema = "RouterInterface"
# include_fields = ["ipRange", "ipVersion", "linkedInterconnectAttachment", "linkedVpnTunnel", "managementType", "name", "privateIpAddress", "redundantInterface", "subnetwork"]
#
#   ipRange: string
#   ipVersion: string, enum: [IPV4, IPV6]
#   linkedInterconnectAttachment: string
#   linkedVpnTunnel: string
#   managementType: string, enum: [MANAGED_BY_ATTACHMENT, MANAGED_BY_USER], readOnly
#   name: string
#   privateIpAddress: string
#   redundantInterface: string
#   subnetwork: string
#
# [types.field_overrides]
# name = { required = true }
# # ipVersion = { enum_type = "RouterInterfaceIpVersion" }
# # managementType = { enum_type = "RouterInterfaceManagementType" }

# --- RouterList (6 fields) ---
# Contains a list of Router resources.
# [[types]]
# schema = "RouterList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<Router>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- RouterMd5AuthenticationKey (2 fields) ---
# [[types]]
# schema = "RouterMd5AuthenticationKey"
# include_fields = ["key", "name"]
#
#   key: string
#   name: string
#
# [types.field_overrides]
# name = { required = true }

# --- RouterNat (22 fields) [IN MANIFEST] ---
# Represents a Nat resource. It enables the VMs within the specified subnetworks to access Internet wi
# WARNING: reserved words: type
# [[types]]
# schema = "RouterNat"
# include_fields = ["autoNetworkTier", "drainNatIps", "enableDynamicPortAllocation", "enableEndpointIndependentMapping", "endpointTypes", "icmpIdleTimeoutSec", "logConfig", "maxPortsPerVm", "minPortsPerVm", "name", "nat64Subnetworks", "natIpAllocateOption", "natIps", "rules", "sourceSubnetworkIpRangesToNat", "sourceSubnetworkIpRangesToNat64", "subnetworks", "tcpEstablishedIdleTimeoutSec", "tcpTimeWaitTimeoutSec", "tcpTransitoryIdleTimeoutSec", "type", "udpIdleTimeoutSec"]
#
#   autoNetworkTier: string, enum: [FIXED_STANDARD, PREMIUM, STANDARD, STANDARD_OVERRIDES_FIXED_STANDARD]
#   drainNatIps: array<string>
#   enableDynamicPortAllocation: boolean
#   enableEndpointIndependentMapping: boolean
#   endpointTypes: array<string>
#   icmpIdleTimeoutSec: integer, format: int32
#   logConfig: $ref: RouterNatLogConfig
#   maxPortsPerVm: integer, format: int32
#   minPortsPerVm: integer, format: int32
#   name: string
#   nat64Subnetworks: array<RouterNatSubnetworkToNat64>
#   natIpAllocateOption: string, enum: [AUTO_ONLY, MANUAL_ONLY]
#   natIps: array<string>
#   rules: array<RouterNatRule>
#   sourceSubnetworkIpRangesToNat: string, enum: [ALL_SUBNETWORKS_ALL_IP_RANGES, ALL_SUBNETWORKS_ALL_PRIMARY_IP_RANGES, LIST_OF_SUBNETWORKS]
#   sourceSubnetworkIpRangesToNat64: string, enum: [ALL_IPV6_SUBNETWORKS, LIST_OF_IPV6_SUBNETWORKS]
#   subnetworks: array<RouterNatSubnetworkToNat>
#   tcpEstablishedIdleTimeoutSec: integer, format: int32
#   tcpTimeWaitTimeoutSec: integer, format: int32
#   tcpTransitoryIdleTimeoutSec: integer, format: int32
#   type: string, enum: [PRIVATE, PUBLIC], RESERVED_WORD
#   udpIdleTimeoutSec: integer, format: int32
#
# [types.field_overrides]
# name = { required = true }
# type = { rust_name = "type_value", serde_rename = "type" }
# # sourceSubnetworkIpRangesToNat = { enum_type = "RouterNatSourceSubnetworkIpRangesToNat" }
# # autoNetworkTier = { enum_type = "RouterNatAutoNetworkTier" }
# # type = { enum_type = "RouterNatType" }
# # sourceSubnetworkIpRangesToNat64 = { enum_type = "RouterNatSourceSubnetworkIpRangesToNat64" }
# # natIpAllocateOption = { enum_type = "RouterNatNatIpAllocateOption" }

# --- RouterNatLogConfig (2 fields) [IN MANIFEST] ---
# Configuration of logging on a NAT.
# [[types]]
# schema = "RouterNatLogConfig"
# include_fields = ["enable", "filter"]
#
#   enable: boolean
#   filter: string, enum: [ALL, ERRORS_ONLY, TRANSLATIONS_ONLY]
#
# [types.field_overrides]
# # filter = { enum_type = "RouterNatLogConfigFilter" }

# --- RouterNatRule (4 fields) ---
# WARNING: reserved words: match
# [[types]]
# schema = "RouterNatRule"
# include_fields = ["action", "description", "match", "ruleNumber"]
#
#   action: $ref: RouterNatRuleAction
#   description: string
#   match: string, RESERVED_WORD
#   ruleNumber: integer, format: uint32
#
# [types.field_overrides]
# match = { rust_name = "match_value", serde_rename = "match" }

# --- RouterNatRuleAction (4 fields) ---
# [[types]]
# schema = "RouterNatRuleAction"
# include_fields = ["sourceNatActiveIps", "sourceNatActiveRanges", "sourceNatDrainIps", "sourceNatDrainRanges"]
#
#   sourceNatActiveIps: array<string>
#   sourceNatActiveRanges: array<string>
#   sourceNatDrainIps: array<string>
#   sourceNatDrainRanges: array<string>

# --- RouterNatSubnetworkToNat (3 fields) [IN MANIFEST] ---
# Defines the IP ranges that want to use NAT for a subnetwork.
# [[types]]
# schema = "RouterNatSubnetworkToNat"
# include_fields = ["name", "secondaryIpRangeNames", "sourceIpRangesToNat"]
#
#   name: string
#   secondaryIpRangeNames: array<string>
#   sourceIpRangesToNat: array<string>
#
# [types.field_overrides]
# name = { required = true }

# --- RouterNatSubnetworkToNat64 (1 fields) ---
# Specifies a subnetwork to enable NAT64.
# [[types]]
# schema = "RouterNatSubnetworkToNat64"
# include_fields = ["name"]
#
#   name: string
#
# [types.field_overrides]
# name = { required = true }

# --- RouterParams (1 fields) ---
# Additional router parameters.
# [[types]]
# schema = "RouterParams"
# include_fields = ["resourceManagerTags"]
#
#   resourceManagerTags: map<string, string>

# --- RouterStatus (5 fields) ---
# [[types]]
# schema = "RouterStatus"
# include_fields = ["bestRoutes", "bestRoutesForRouter", "bgpPeerStatus", "natStatus", "network"]
#
#   bestRoutes: array<Route>
#   bestRoutesForRouter: array<Route>
#   bgpPeerStatus: array<RouterStatusBgpPeerStatus>
#   natStatus: array<RouterStatusNatStatus>
#   network: string

# --- RouterStatusBgpPeerStatus (20 fields) ---
# [[types]]
# schema = "RouterStatusBgpPeerStatus"
# include_fields = ["advertisedRoutes", "bfdStatus", "enableIpv4", "enableIpv6", "ipAddress", "ipv4NexthopAddress", "ipv6NexthopAddress", "linkedVpnTunnel", "md5AuthEnabled", "name", "numLearnedRoutes", "peerIpAddress", "peerIpv4NexthopAddress", "peerIpv6NexthopAddress", "routerApplianceInstance", "state", "status", "statusReason", "uptime", "uptimeSeconds"]
#
#   advertisedRoutes: array<Route>
#   bfdStatus: $ref: BfdStatus
#   enableIpv4: boolean, readOnly
#   enableIpv6: boolean, readOnly
#   ipAddress: string, readOnly
#   ipv4NexthopAddress: string, readOnly
#   ipv6NexthopAddress: string, readOnly
#   linkedVpnTunnel: string, readOnly
#   md5AuthEnabled: boolean
#   name: string, readOnly
#   numLearnedRoutes: integer, format: uint32, readOnly
#   peerIpAddress: string, readOnly
#   peerIpv4NexthopAddress: string, readOnly
#   peerIpv6NexthopAddress: string, readOnly
#   routerApplianceInstance: string, readOnly
#   state: string, readOnly
#   status: string, enum: [DOWN, UNKNOWN, UP], readOnly
#   statusReason: string, enum: [IPV4_PEER_ON_IPV6_ONLY_CONNECTION, IPV6_PEER_ON_IPV4_ONLY_CONNECTION, MD5_AUTH_INTERNAL_PROBLEM, STATUS_REASON_UNSPECIFIED]
#   uptime: string, readOnly
#   uptimeSeconds: string, readOnly
#
# [types.field_overrides]
# name = { required = true }
# # statusReason = { enum_type = "RouterStatusBgpPeerStatusStatusReason" }
# # status = { enum_type = "RouterStatusBgpPeerStatusStatus" }

# --- RouterStatusNatStatus (9 fields) ---
# Status of a NAT contained in this router.
# [[types]]
# schema = "RouterStatusNatStatus"
# include_fields = ["autoAllocatedNatIps", "drainAutoAllocatedNatIps", "drainUserAllocatedNatIps", "minExtraNatIpsNeeded", "name", "numVmEndpointsWithNatMappings", "ruleStatus", "userAllocatedNatIpResources", "userAllocatedNatIps"]
#
#   autoAllocatedNatIps: array<string>, readOnly
#   drainAutoAllocatedNatIps: array<string>, readOnly
#   drainUserAllocatedNatIps: array<string>, readOnly
#   minExtraNatIpsNeeded: integer, format: int32, readOnly
#   name: string, readOnly
#   numVmEndpointsWithNatMappings: integer, format: int32, readOnly
#   ruleStatus: array<RouterStatusNatStatusNatRuleStatus>
#   userAllocatedNatIpResources: array<string>, readOnly
#   userAllocatedNatIps: array<string>, readOnly
#
# [types.field_overrides]
# name = { required = true }

# --- RouterStatusNatStatusNatRuleStatus (5 fields) ---
# Status of a NAT Rule contained in this NAT.
# [[types]]
# schema = "RouterStatusNatStatusNatRuleStatus"
# include_fields = ["activeNatIps", "drainNatIps", "minExtraIpsNeeded", "numVmEndpointsWithNatMappings", "ruleNumber"]
#
#   activeNatIps: array<string>, readOnly
#   drainNatIps: array<string>, readOnly
#   minExtraIpsNeeded: integer, format: int32, readOnly
#   numVmEndpointsWithNatMappings: integer, format: int32, readOnly
#   ruleNumber: integer, format: int32, readOnly

# --- RouterStatusResponse (2 fields) ---
# [[types]]
# schema = "RouterStatusResponse"
# include_fields = ["kind", "result"]
#
#   kind: string, readOnly
#   result: $ref: RouterStatus

# --- RoutersGetRoutePolicyResponse (1 fields) ---
# [[types]]
# schema = "RoutersGetRoutePolicyResponse"
# include_fields = ["resource"]
#
#   resource: $ref: RoutePolicy

# --- RoutersListBgpRoutes (8 fields) ---
# [[types]]
# schema = "RoutersListBgpRoutes"
# include_fields = ["etag", "id", "kind", "nextPageToken", "result", "selfLink", "unreachables", "warning"]
#
#   etag: string
#   id: string
#   kind: string, readOnly
#   nextPageToken: string
#   result: array<BgpRoute>
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- RoutersListRoutePolicies (8 fields) ---
# [[types]]
# schema = "RoutersListRoutePolicies"
# include_fields = ["etag", "id", "kind", "nextPageToken", "result", "selfLink", "unreachables", "warning"]
#
#   etag: string
#   id: string
#   kind: string, readOnly
#   nextPageToken: string
#   result: array<RoutePolicy>
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- RoutersPreviewResponse (1 fields) ---
# [[types]]
# schema = "RoutersPreviewResponse"
# include_fields = ["resource"]
#
#   resource: $ref: Router

# --- RoutersScopedList (2 fields) ---
# [[types]]
# schema = "RoutersScopedList"
# include_fields = ["routers", "warning"]
#
#   routers: array<Router>
#   warning: object

# --- SSLHealthCheck (6 fields) ---
# [[types]]
# schema = "SSLHealthCheck"
# include_fields = ["port", "portName", "portSpecification", "proxyHeader", "request", "response"]
#
#   port: integer, format: int32
#   portName: string
#   portSpecification: string, enum: [USE_FIXED_PORT, USE_NAMED_PORT, USE_SERVING_PORT]
#   proxyHeader: string, enum: [NONE, PROXY_V1]
#   request: string
#   response: string
#
# [types.field_overrides]
# # portSpecification = { enum_type = "SSLHealthCheckPortSpecification" }
# # proxyHeader = { enum_type = "SSLHealthCheckProxyHeader" }

# --- SavedAttachedDisk (16 fields) ---
# DEPRECATED: Please use compute#savedDisk instead. An instance-attached disk resource.
# WARNING: reserved words: type
# [[types]]
# schema = "SavedAttachedDisk"
# include_fields = ["autoDelete", "boot", "deviceName", "diskEncryptionKey", "diskSizeGb", "diskType", "guestOsFeatures", "index", "interface", "kind", "licenses", "mode", "source", "storageBytes", "storageBytesStatus", "type"]
#
#   autoDelete: boolean
#   boot: boolean
#   deviceName: string
#   diskEncryptionKey: $ref: CustomerEncryptionKey
#   diskSizeGb: string, format: int64
#   diskType: string, readOnly
#   guestOsFeatures: array<GuestOsFeature>
#   index: integer, format: int32, readOnly
#   interface: string, enum: [NVME, SCSI]
#   kind: string, readOnly
#   licenses: array<string>, readOnly
#   mode: string, enum: [READ_ONLY, READ_WRITE]
#   source: string
#   storageBytes: string, format: int64, readOnly
#   storageBytesStatus: string, enum: [UPDATING, UP_TO_DATE], readOnly
#   type: string, enum: [PERSISTENT, SCRATCH], RESERVED_WORD
#
# [types.field_overrides]
# type = { rust_name = "type_value", serde_rename = "type" }
# # mode = { enum_type = "SavedAttachedDiskMode" }
# # storageBytesStatus = { enum_type = "SavedAttachedDiskStorageBytesStatus" }
# # interface = { enum_type = "SavedAttachedDiskInterface" }
# # type = { enum_type = "SavedAttachedDiskType" }

# --- SavedDisk (5 fields) ---
# An instance-attached disk resource.
# [[types]]
# schema = "SavedDisk"
# include_fields = ["architecture", "kind", "sourceDisk", "storageBytes", "storageBytesStatus"]
#
#   architecture: string, enum: [ARCHITECTURE_UNSPECIFIED, ARM64, X86_64], readOnly
#   kind: string, readOnly
#   sourceDisk: string, readOnly
#   storageBytes: string, format: int64, readOnly
#   storageBytesStatus: string, enum: [UPDATING, UP_TO_DATE], readOnly
#
# [types.field_overrides]
# # architecture = { enum_type = "SavedDiskArchitecture" }
# # storageBytesStatus = { enum_type = "SavedDiskStorageBytesStatus" }

# --- ScalingScheduleStatus (3 fields) ---
# [[types]]
# schema = "ScalingScheduleStatus"
# include_fields = ["lastStartTime", "nextStartTime", "state"]
#
#   lastStartTime: string
#   nextStartTime: string
#   state: string, enum: [ACTIVE, DISABLED, OBSOLETE, READY]
#
# [types.field_overrides]
# # state = { enum_type = "ScalingScheduleStatusState" }

# --- Scheduling (15 fields) [IN MANIFEST] ---
# Sets the scheduling options for an Instance.
# [[types]]
# schema = "Scheduling"
# include_fields = ["automaticRestart", "availabilityDomain", "hostErrorTimeoutSeconds", "instanceTerminationAction", "localSsdRecoveryTimeout", "locationHint", "maxRunDuration", "minNodeCpus", "nodeAffinities", "onHostMaintenance", "onInstanceStopAction", "preemptible", "provisioningModel", "skipGuestOsShutdown", "terminationTime"]
#
#   automaticRestart: boolean
#   availabilityDomain: integer, format: int32
#   hostErrorTimeoutSeconds: integer, format: int32
#   instanceTerminationAction: string, enum: [DELETE, INSTANCE_TERMINATION_ACTION_UNSPECIFIED, STOP]
#   localSsdRecoveryTimeout: $ref: Duration
#   locationHint: string
#   maxRunDuration: $ref: Duration
#   minNodeCpus: integer, format: int32
#   nodeAffinities: array<SchedulingNodeAffinity>
#   onHostMaintenance: string, enum: [MIGRATE, TERMINATE]
#   onInstanceStopAction: $ref: SchedulingOnInstanceStopAction
#   preemptible: boolean
#   provisioningModel: string, enum: [FLEX_START, RESERVATION_BOUND, SPOT, STANDARD]
#   skipGuestOsShutdown: boolean
#   terminationTime: string
#
# [types.field_overrides]
# # onHostMaintenance = { enum_type = "SchedulingOnHostMaintenance" }
# # provisioningModel = { enum_type = "SchedulingProvisioningModel" }
# # instanceTerminationAction = { enum_type = "SchedulingInstanceTerminationAction" }

# --- SchedulingNodeAffinity (3 fields) ---
# Node Affinity: the configuration of desired nodes onto which this Instance could be scheduled.
# [[types]]
# schema = "SchedulingNodeAffinity"
# include_fields = ["key", "operator", "values"]
#
#   key: string
#   operator: string, enum: [IN, NOT_IN, OPERATOR_UNSPECIFIED]
#   values: array<string>
#
# [types.field_overrides]
# # operator = { enum_type = "SchedulingNodeAffinityOperator" }

# --- SchedulingOnInstanceStopAction (1 fields) ---
# Defines the behaviour for instances with the instance_termination_actionSTOP.
# [[types]]
# schema = "SchedulingOnInstanceStopAction"
# include_fields = ["discardLocalSsd"]
#
#   discardLocalSsd: boolean

# --- Screenshot (2 fields) ---
# An instance's screenshot.
# [[types]]
# schema = "Screenshot"
# include_fields = ["contents", "kind"]
#
#   contents: string
#   kind: string, readOnly

# --- SecurityPoliciesAggregatedList (8 fields) ---
# [[types]]
# schema = "SecurityPoliciesAggregatedList"
# include_fields = ["etag", "id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   etag: string
#   id: string
#   items: map<string, SecurityPoliciesScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- SecurityPoliciesListPreconfiguredExpressionSetsResponse (1 fields) ---
# [[types]]
# schema = "SecurityPoliciesListPreconfiguredExpressionSetsResponse"
# include_fields = ["preconfiguredExpressionSets"]
#
#   preconfiguredExpressionSets: $ref: SecurityPoliciesWafConfig

# --- SecurityPoliciesScopedList (2 fields) ---
# [[types]]
# schema = "SecurityPoliciesScopedList"
# include_fields = ["securityPolicies", "warning"]
#
#   securityPolicies: array<SecurityPolicy>
#   warning: object

# --- SecurityPoliciesWafConfig (1 fields) ---
# [[types]]
# schema = "SecurityPoliciesWafConfig"
# include_fields = ["wafRules"]
#
#   wafRules: $ref: PreconfiguredWafSet

# --- SecurityPolicy (20 fields) ---
# Represents a Google Cloud Armor security policy resource. Only external backend services that use lo
# WARNING: format:"byte" fields: labelFingerprint, fingerprint
# WARNING: reserved words: type
# [[types]]
# schema = "SecurityPolicy"
# include_fields = ["adaptiveProtectionConfig", "advancedOptionsConfig", "associations", "creationTimestamp", "ddosProtectionConfig", "description", "fingerprint", "id", "kind", "labelFingerprint", "labels", "name", "parent", "recaptchaOptionsConfig", "region", "rules", "selfLink", "shortName", "type", "userDefinedFields"]
#
#   adaptiveProtectionConfig: $ref: SecurityPolicyAdaptiveProtectionConfig
#   advancedOptionsConfig: $ref: SecurityPolicyAdvancedOptionsConfig
#   associations: array<SecurityPolicyAssociation>
#   creationTimestamp: string, readOnly
#   ddosProtectionConfig: $ref: SecurityPolicyDdosProtectionConfig
#   description: string
#   fingerprint: string, format: byte
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   labelFingerprint: string, format: byte
#   labels: map<string, string>
#   name: string
#   parent: string, readOnly
#   recaptchaOptionsConfig: $ref: SecurityPolicyRecaptchaOptionsConfig
#   region: string, readOnly
#   rules: array<SecurityPolicyRule>
#   selfLink: string, readOnly
#   shortName: string
#   type: string, enum: [CLOUD_ARMOR, CLOUD_ARMOR_EDGE, CLOUD_ARMOR_NETWORK], RESERVED_WORD
#   userDefinedFields: array<SecurityPolicyUserDefinedField>
#
# [types.field_overrides]
# name = { required = true }
# type = { rust_name = "type_value", serde_rename = "type" }
# labelFingerprint = { format = "bytes" }
# fingerprint = { format = "bytes" }
# # type = { enum_type = "SecurityPolicyType" }

# --- SecurityPolicyAdaptiveProtectionConfig (1 fields) ---
# Configuration options for Cloud Armor Adaptive Protection (CAAP).
# [[types]]
# schema = "SecurityPolicyAdaptiveProtectionConfig"
# include_fields = ["layer7DdosDefenseConfig"]
#
#   layer7DdosDefenseConfig: $ref: SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig

# --- SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig (3 fields) ---
# Configuration options for L7 DDoS detection. This field is only supported in Global Security Policie
# [[types]]
# schema = "SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig"
# include_fields = ["enable", "ruleVisibility", "thresholdConfigs"]
#
#   enable: boolean
#   ruleVisibility: string, enum: [PREMIUM, STANDARD]
#   thresholdConfigs: array<SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfig>
#
# [types.field_overrides]
# # ruleVisibility = { enum_type = "SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigRuleVisibility" }

# --- SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfig (9 fields) ---
# [[types]]
# schema = "SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfig"
# include_fields = ["autoDeployConfidenceThreshold", "autoDeployExpirationSec", "autoDeployImpactedBaselineThreshold", "autoDeployLoadThreshold", "detectionAbsoluteQps", "detectionLoadThreshold", "detectionRelativeToBaselineQps", "name", "trafficGranularityConfigs"]
#
#   autoDeployConfidenceThreshold: number, format: float
#   autoDeployExpirationSec: integer, format: int32
#   autoDeployImpactedBaselineThreshold: number, format: float
#   autoDeployLoadThreshold: number, format: float
#   detectionAbsoluteQps: number, format: float
#   detectionLoadThreshold: number, format: float
#   detectionRelativeToBaselineQps: number, format: float
#   name: string
#   trafficGranularityConfigs: array<SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfigTrafficGranularityConfig>
#
# [types.field_overrides]
# name = { required = true }

# --- SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfigTrafficGranularityConfig (3 fields) ---
# Configurations to specifc granular traffic units processed by Adaptive Protection.
# WARNING: reserved words: type
# [[types]]
# schema = "SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfigTrafficGranularityConfig"
# include_fields = ["enableEachUniqueValue", "type", "value"]
#
#   enableEachUniqueValue: boolean
#   type: string, enum: [HTTP_HEADER_HOST, HTTP_PATH, UNSPECIFIED_TYPE], RESERVED_WORD
#   value: string
#
# [types.field_overrides]
# type = { rust_name = "type_value", serde_rename = "type" }
# # type = { enum_type = "SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfigTrafficGranularityConfigType" }

# --- SecurityPolicyAdvancedOptionsConfig (5 fields) ---
# [[types]]
# schema = "SecurityPolicyAdvancedOptionsConfig"
# include_fields = ["jsonCustomConfig", "jsonParsing", "logLevel", "requestBodyInspectionSize", "userIpRequestHeaders"]
#
#   jsonCustomConfig: $ref: SecurityPolicyAdvancedOptionsConfigJsonCustomConfig
#   jsonParsing: string, enum: [DISABLED, STANDARD, STANDARD_WITH_GRAPHQL]
#   logLevel: string, enum: [NORMAL, VERBOSE]
#   requestBodyInspectionSize: string
#   userIpRequestHeaders: array<string>
#
# [types.field_overrides]
# # logLevel = { enum_type = "SecurityPolicyAdvancedOptionsConfigLogLevel" }
# # jsonParsing = { enum_type = "SecurityPolicyAdvancedOptionsConfigJsonParsing" }

# --- SecurityPolicyAdvancedOptionsConfigJsonCustomConfig (1 fields) ---
# [[types]]
# schema = "SecurityPolicyAdvancedOptionsConfigJsonCustomConfig"
# include_fields = ["contentTypes"]
#
#   contentTypes: array<string>

# --- SecurityPolicyAssociation (7 fields) ---
# [[types]]
# schema = "SecurityPolicyAssociation"
# include_fields = ["attachmentId", "displayName", "excludedFolders", "excludedProjects", "name", "securityPolicyId", "shortName"]
#
#   attachmentId: string
#   displayName: string, readOnly
#   excludedFolders: array<string>
#   excludedProjects: array<string>
#   name: string
#   securityPolicyId: string, readOnly
#   shortName: string, readOnly
#
# [types.field_overrides]
# name = { required = true }

# --- SecurityPolicyDdosProtectionConfig (1 fields) ---
# [[types]]
# schema = "SecurityPolicyDdosProtectionConfig"
# include_fields = ["ddosProtection"]
#
#   ddosProtection: string, enum: [ADVANCED, ADVANCED_PREVIEW, STANDARD]
#
# [types.field_overrides]
# # ddosProtection = { enum_type = "SecurityPolicyDdosProtectionConfigDdosProtection" }

# --- SecurityPolicyList (5 fields) ---
# [[types]]
# schema = "SecurityPolicyList"
# include_fields = ["id", "items", "kind", "nextPageToken", "warning"]
#
#   id: string
#   items: array<SecurityPolicy>
#   kind: string, readOnly
#   nextPageToken: string
#   warning: object

# --- SecurityPolicyRecaptchaOptionsConfig (1 fields) ---
# [[types]]
# schema = "SecurityPolicyRecaptchaOptionsConfig"
# include_fields = ["redirectSiteKey"]
#
#   redirectSiteKey: string

# --- SecurityPolicyReference (1 fields) ---
# [[types]]
# schema = "SecurityPolicyReference"
# include_fields = ["securityPolicy"]
#
#   securityPolicy: string

# --- SecurityPolicyRule (11 fields) ---
# Represents a rule that describes one or more match conditions along with the action to be taken when
# WARNING: reserved words: match
# [[types]]
# schema = "SecurityPolicyRule"
# include_fields = ["action", "description", "headerAction", "kind", "match", "networkMatch", "preconfiguredWafConfig", "preview", "priority", "rateLimitOptions", "redirectOptions"]
#
#   action: string
#   description: string
#   headerAction: $ref: SecurityPolicyRuleHttpHeaderAction
#   kind: string, readOnly
#   match: $ref: SecurityPolicyRuleMatcher, RESERVED_WORD
#   networkMatch: $ref: SecurityPolicyRuleNetworkMatcher
#   preconfiguredWafConfig: $ref: SecurityPolicyRulePreconfiguredWafConfig
#   preview: boolean
#   priority: integer, format: int32
#   rateLimitOptions: $ref: SecurityPolicyRuleRateLimitOptions
#   redirectOptions: $ref: SecurityPolicyRuleRedirectOptions
#
# [types.field_overrides]
# match = { rust_name = "match_value", serde_rename = "match" }

# --- SecurityPolicyRuleHttpHeaderAction (1 fields) ---
# [[types]]
# schema = "SecurityPolicyRuleHttpHeaderAction"
# include_fields = ["requestHeadersToAdds"]
#
#   requestHeadersToAdds: array<SecurityPolicyRuleHttpHeaderActionHttpHeaderOption>

# --- SecurityPolicyRuleHttpHeaderActionHttpHeaderOption (2 fields) ---
# [[types]]
# schema = "SecurityPolicyRuleHttpHeaderActionHttpHeaderOption"
# include_fields = ["headerName", "headerValue"]
#
#   headerName: string
#   headerValue: string

# --- SecurityPolicyRuleMatcher (4 fields) ---
# Represents a match condition that incoming traffic is evaluated against. Exactly one field must be s
# [[types]]
# schema = "SecurityPolicyRuleMatcher"
# include_fields = ["config", "expr", "exprOptions", "versionedExpr"]
#
#   config: $ref: SecurityPolicyRuleMatcherConfig
#   expr: $ref: Expr
#   exprOptions: $ref: SecurityPolicyRuleMatcherExprOptions
#   versionedExpr: string, enum: [SRC_IPS_V1]
#
# [types.field_overrides]
# # versionedExpr = { enum_type = "SecurityPolicyRuleMatcherVersionedExpr" }

# --- SecurityPolicyRuleMatcherConfig (1 fields) ---
# [[types]]
# schema = "SecurityPolicyRuleMatcherConfig"
# include_fields = ["srcIpRanges"]
#
#   srcIpRanges: array<string>

# --- SecurityPolicyRuleMatcherExprOptions (1 fields) ---
# [[types]]
# schema = "SecurityPolicyRuleMatcherExprOptions"
# include_fields = ["recaptchaOptions"]
#
#   recaptchaOptions: $ref: SecurityPolicyRuleMatcherExprOptionsRecaptchaOptions

# --- SecurityPolicyRuleMatcherExprOptionsRecaptchaOptions (2 fields) ---
# [[types]]
# schema = "SecurityPolicyRuleMatcherExprOptionsRecaptchaOptions"
# include_fields = ["actionTokenSiteKeys", "sessionTokenSiteKeys"]
#
#   actionTokenSiteKeys: array<string>
#   sessionTokenSiteKeys: array<string>

# --- SecurityPolicyRuleNetworkMatcher (8 fields) ---
# Represents a match condition that incoming network traffic is evaluated against.
# [[types]]
# schema = "SecurityPolicyRuleNetworkMatcher"
# include_fields = ["destIpRanges", "destPorts", "ipProtocols", "srcAsns", "srcIpRanges", "srcPorts", "srcRegionCodes", "userDefinedFields"]
#
#   destIpRanges: array<string>
#   destPorts: array<string>
#   ipProtocols: array<string>
#   srcAsns: array<integer>
#   srcIpRanges: array<string>
#   srcPorts: array<string>
#   srcRegionCodes: array<string>
#   userDefinedFields: array<SecurityPolicyRuleNetworkMatcherUserDefinedFieldMatch>

# --- SecurityPolicyRuleNetworkMatcherUserDefinedFieldMatch (2 fields) ---
# [[types]]
# schema = "SecurityPolicyRuleNetworkMatcherUserDefinedFieldMatch"
# include_fields = ["name", "values"]
#
#   name: string
#   values: array<string>
#
# [types.field_overrides]
# name = { required = true }

# --- SecurityPolicyRulePreconfiguredWafConfig (1 fields) ---
# [[types]]
# schema = "SecurityPolicyRulePreconfiguredWafConfig"
# include_fields = ["exclusions"]
#
#   exclusions: array<SecurityPolicyRulePreconfiguredWafConfigExclusion>

# --- SecurityPolicyRulePreconfiguredWafConfigExclusion (6 fields) ---
# [[types]]
# schema = "SecurityPolicyRulePreconfiguredWafConfigExclusion"
# include_fields = ["requestCookiesToExclude", "requestHeadersToExclude", "requestQueryParamsToExclude", "requestUrisToExclude", "targetRuleIds", "targetRuleSet"]
#
#   requestCookiesToExclude: array<SecurityPolicyRulePreconfiguredWafConfigExclusionFieldParams>
#   requestHeadersToExclude: array<SecurityPolicyRulePreconfiguredWafConfigExclusionFieldParams>
#   requestQueryParamsToExclude: array<SecurityPolicyRulePreconfiguredWafConfigExclusionFieldParams>
#   requestUrisToExclude: array<SecurityPolicyRulePreconfiguredWafConfigExclusionFieldParams>
#   targetRuleIds: array<string>
#   targetRuleSet: string

# --- SecurityPolicyRulePreconfiguredWafConfigExclusionFieldParams (2 fields) ---
# [[types]]
# schema = "SecurityPolicyRulePreconfiguredWafConfigExclusionFieldParams"
# include_fields = ["op", "val"]
#
#   op: string, enum: [CONTAINS, ENDS_WITH, EQUALS, EQUALS_ANY, STARTS_WITH]
#   val: string
#
# [types.field_overrides]
# # op = { enum_type = "SecurityPolicyRulePreconfiguredWafConfigExclusionFieldParamsOp" }

# --- SecurityPolicyRuleRateLimitOptions (9 fields) ---
# [[types]]
# schema = "SecurityPolicyRuleRateLimitOptions"
# include_fields = ["banDurationSec", "banThreshold", "conformAction", "enforceOnKey", "enforceOnKeyConfigs", "enforceOnKeyName", "exceedAction", "exceedRedirectOptions", "rateLimitThreshold"]
#
#   banDurationSec: integer, format: int32
#   banThreshold: $ref: SecurityPolicyRuleRateLimitOptionsThreshold
#   conformAction: string
#   enforceOnKey: string, enum: [ALL, HTTP_COOKIE, HTTP_HEADER, HTTP_PATH, ... +7]
#   enforceOnKeyConfigs: array<SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig>
#   enforceOnKeyName: string
#   exceedAction: string
#   exceedRedirectOptions: $ref: SecurityPolicyRuleRedirectOptions
#   rateLimitThreshold: $ref: SecurityPolicyRuleRateLimitOptionsThreshold
#
# [types.field_overrides]
# # enforceOnKey = { enum_type = "SecurityPolicyRuleRateLimitOptionsEnforceOnKey" }

# --- SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig (2 fields) ---
# [[types]]
# schema = "SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig"
# include_fields = ["enforceOnKeyName", "enforceOnKeyType"]
#
#   enforceOnKeyName: string
#   enforceOnKeyType: string, enum: [ALL, HTTP_COOKIE, HTTP_HEADER, HTTP_PATH, ... +7]
#
# [types.field_overrides]
# # enforceOnKeyType = { enum_type = "SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfigEnforceOnKeyType" }

# --- SecurityPolicyRuleRateLimitOptionsThreshold (2 fields) ---
# [[types]]
# schema = "SecurityPolicyRuleRateLimitOptionsThreshold"
# include_fields = ["count", "intervalSec"]
#
#   count: integer, format: int32
#   intervalSec: integer, format: int32

# --- SecurityPolicyRuleRedirectOptions (2 fields) ---
# WARNING: reserved words: type
# [[types]]
# schema = "SecurityPolicyRuleRedirectOptions"
# include_fields = ["target", "type"]
#
#   target: string
#   type: string, enum: [EXTERNAL_302, GOOGLE_RECAPTCHA], RESERVED_WORD
#
# [types.field_overrides]
# type = { rust_name = "type_value", serde_rename = "type" }
# # type = { enum_type = "SecurityPolicyRuleRedirectOptionsType" }

# --- SecurityPolicyUserDefinedField (5 fields) ---
# [[types]]
# schema = "SecurityPolicyUserDefinedField"
# include_fields = ["base", "mask", "name", "offset", "size"]
#
#   base: string, enum: [IPV4, IPV6, TCP, UDP]
#   mask: string
#   name: string
#   offset: integer, format: int32
#   size: integer, format: int32
#
# [types.field_overrides]
# name = { required = true }
# # base = { enum_type = "SecurityPolicyUserDefinedFieldBase" }

# --- SecuritySettings (3 fields) ---
# The authentication and authorization settings for a BackendService.
# [[types]]
# schema = "SecuritySettings"
# include_fields = ["awsV4Authentication", "clientTlsPolicy", "subjectAltNames"]
#
#   awsV4Authentication: $ref: AWSV4Signature
#   clientTlsPolicy: string
#   subjectAltNames: array<string>

# --- SerialPortOutput (5 fields) ---
# An instance serial console output.
# [[types]]
# schema = "SerialPortOutput"
# include_fields = ["contents", "kind", "next", "selfLink", "start"]
#
#   contents: string
#   kind: string, readOnly
#   next: string, format: int64
#   selfLink: string, readOnly
#   start: string, format: int64

# --- ServerBinding (1 fields) ---
# WARNING: reserved words: type
# [[types]]
# schema = "ServerBinding"
# include_fields = ["type"]
#
#   type: string, enum: [RESTART_NODE_ON_ANY_SERVER, RESTART_NODE_ON_MINIMAL_SERVERS, SERVER_BINDING_TYPE_UNSPECIFIED], RESERVED_WORD
#
# [types.field_overrides]
# type = { rust_name = "type_value", serde_rename = "type" }
# # type = { enum_type = "ServerBindingType" }

# --- ServiceAccount (2 fields) [IN MANIFEST] ---
# A service account.
# [[types]]
# schema = "ServiceAccount"
# include_fields = ["email", "scopes"]
#
#   email: string
#   scopes: array<string>

# --- ServiceAttachment (21 fields) ---
# Represents a ServiceAttachment resource. A service attachment represents a service that a producer h
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "ServiceAttachment"
# include_fields = ["connectedEndpoints", "connectionPreference", "consumerAcceptLists", "consumerRejectLists", "creationTimestamp", "description", "domainNames", "enableProxyProtocol", "fingerprint", "id", "kind", "metadata", "name", "natSubnets", "producerForwardingRule", "propagatedConnectionLimit", "pscServiceAttachmentId", "reconcileConnections", "region", "selfLink", "targetService"]
#
#   connectedEndpoints: array<ServiceAttachmentConnectedEndpoint>, readOnly
#   connectionPreference: string, enum: [ACCEPT_AUTOMATIC, ACCEPT_MANUAL, CONNECTION_PREFERENCE_UNSPECIFIED]
#   consumerAcceptLists: array<ServiceAttachmentConsumerProjectLimit>
#   consumerRejectLists: array<string>
#   creationTimestamp: string, readOnly
#   description: string
#   domainNames: array<string>
#   enableProxyProtocol: boolean
#   fingerprint: string, format: byte
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   metadata: map<string, string>
#   name: string
#   natSubnets: array<string>
#   producerForwardingRule: string
#   propagatedConnectionLimit: integer, format: uint32
#   pscServiceAttachmentId: $ref: Uint128, readOnly
#   reconcileConnections: boolean
#   region: string, readOnly
#   selfLink: string, readOnly
#   targetService: string
#
# [types.field_overrides]
# name = { required = true }
# fingerprint = { format = "bytes" }
# # connectionPreference = { enum_type = "ServiceAttachmentConnectionPreference" }

# --- ServiceAttachmentAggregatedList (7 fields) ---
# Contains a list of ServiceAttachmentsScopedList.
# [[types]]
# schema = "ServiceAttachmentAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, ServiceAttachmentsScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- ServiceAttachmentConnectedEndpoint (6 fields) ---
# [Output Only] A connection connected to this service attachment.
# [[types]]
# schema = "ServiceAttachmentConnectedEndpoint"
# include_fields = ["consumerNetwork", "endpoint", "natIps", "propagatedConnectionCount", "pscConnectionId", "status"]
#
#   consumerNetwork: string
#   endpoint: string
#   natIps: array<string>
#   propagatedConnectionCount: integer, format: uint32
#   pscConnectionId: string, format: uint64
#   status: string, enum: [ACCEPTED, CLOSED, NEEDS_ATTENTION, PENDING, ... +2]
#
# [types.field_overrides]
# # status = { enum_type = "ServiceAttachmentConnectedEndpointStatus" }

# --- ServiceAttachmentConsumerProjectLimit (3 fields) ---
# [[types]]
# schema = "ServiceAttachmentConsumerProjectLimit"
# include_fields = ["connectionLimit", "networkUrl", "projectIdOrNum"]
#
#   connectionLimit: integer, format: uint32
#   networkUrl: string
#   projectIdOrNum: string

# --- ServiceAttachmentList (6 fields) ---
# [[types]]
# schema = "ServiceAttachmentList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<ServiceAttachment>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string
#   warning: object

# --- ServiceAttachmentsScopedList (2 fields) ---
# [[types]]
# schema = "ServiceAttachmentsScopedList"
# include_fields = ["serviceAttachments", "warning"]
#
#   serviceAttachments: array<ServiceAttachment>
#   warning: object

# --- SetCommonInstanceMetadataOperationMetadata (2 fields) ---
# [[types]]
# schema = "SetCommonInstanceMetadataOperationMetadata"
# include_fields = ["clientOperationId", "perLocationOperations"]
#
#   clientOperationId: string
#   perLocationOperations: map<string, SetCommonInstanceMetadataOperationMetadataPerLocationOperationInfo>

# --- SetCommonInstanceMetadataOperationMetadataPerLocationOperationInfo (2 fields) ---
# [[types]]
# schema = "SetCommonInstanceMetadataOperationMetadataPerLocationOperationInfo"
# include_fields = ["error", "state"]
#
#   error: $ref: Status
#   state: string, enum: [ABANDONED, DONE, FAILED, PROPAGATED, ... +2]
#
# [types.field_overrides]
# # state = { enum_type = "SetCommonInstanceMetadataOperationMetadataPerLocationOperationInfoState" }

# --- ShareSettings (2 fields) ---
# The share setting for reservations and sole tenancy node groups.
# [[types]]
# schema = "ShareSettings"
# include_fields = ["projectMap", "shareType"]
#
#   projectMap: map<string, ShareSettingsProjectConfig>
#   shareType: string, enum: [LOCAL, ORGANIZATION, SHARE_TYPE_UNSPECIFIED, SPECIFIC_PROJECTS]
#
# [types.field_overrides]
# # shareType = { enum_type = "ShareSettingsShareType" }

# --- ShareSettingsProjectConfig (1 fields) ---
# Config for each project in the share settings.
# [[types]]
# schema = "ShareSettingsProjectConfig"
# include_fields = ["projectId"]
#
#   projectId: string

# --- ShieldedInstanceConfig (3 fields) ---
# A set of Shielded Instance options.
# [[types]]
# schema = "ShieldedInstanceConfig"
# include_fields = ["enableIntegrityMonitoring", "enableSecureBoot", "enableVtpm"]
#
#   enableIntegrityMonitoring: boolean
#   enableSecureBoot: boolean
#   enableVtpm: boolean

# --- ShieldedInstanceIdentity (5 fields) ---
# A Shielded Instance Identity.
# [[types]]
# schema = "ShieldedInstanceIdentity"
# include_fields = ["eccP256EncryptionKey", "eccP256SigningKey", "encryptionKey", "kind", "signingKey"]
#
#   eccP256EncryptionKey: $ref: ShieldedInstanceIdentityEntry
#   eccP256SigningKey: $ref: ShieldedInstanceIdentityEntry
#   encryptionKey: $ref: ShieldedInstanceIdentityEntry
#   kind: string, readOnly
#   signingKey: $ref: ShieldedInstanceIdentityEntry

# --- ShieldedInstanceIdentityEntry (2 fields) ---
# A Shielded Instance Identity Entry.
# [[types]]
# schema = "ShieldedInstanceIdentityEntry"
# include_fields = ["ekCert", "ekPub"]
#
#   ekCert: string
#   ekPub: string

# --- ShieldedInstanceIntegrityPolicy (1 fields) ---
# The policy describes the baseline against which Instance boot integrity is measured.
# [[types]]
# schema = "ShieldedInstanceIntegrityPolicy"
# include_fields = ["updateAutoLearnPolicy"]
#
#   updateAutoLearnPolicy: boolean

# --- SignedUrlKey (2 fields) ---
# Represents a customer-supplied Signing Key used by Cloud CDN Signed URLs
# [[types]]
# schema = "SignedUrlKey"
# include_fields = ["keyName", "keyValue"]
#
#   keyName: string
#   keyValue: string

# --- Snapshot (38 fields) [IN MANIFEST] ---
# Represents a Persistent Disk Snapshot resource. You can use snapshots to back up data on a regular i
# WARNING: format:"byte" fields: labelFingerprint
# [[types]]
# schema = "Snapshot"
# include_fields = ["architecture", "autoCreated", "chainName", "creationSizeBytes", "creationTimestamp", "description", "diskSizeGb", "downloadBytes", "enableConfidentialCompute", "guestFlush", "guestOsFeatures", "id", "kind", "labelFingerprint", "labels", "licenseCodes", "licenses", "locationHint", "name", "params", "satisfiesPzi", "satisfiesPzs", "selfLink", "snapshotEncryptionKey", "snapshotType", "sourceDisk", "sourceDiskEncryptionKey", "sourceDiskForRecoveryCheckpoint", "sourceDiskId", "sourceInstantSnapshot", "sourceInstantSnapshotEncryptionKey", "sourceInstantSnapshotId", "sourceSnapshotSchedulePolicy", "sourceSnapshotSchedulePolicyId", "status", "storageBytes", "storageBytesStatus", "storageLocations"]
#
#   architecture: string, enum: [ARCHITECTURE_UNSPECIFIED, ARM64, X86_64], readOnly
#   autoCreated: boolean, readOnly
#   chainName: string
#   creationSizeBytes: string, format: int64, readOnly
#   creationTimestamp: string, readOnly
#   description: string
#   diskSizeGb: string, format: int64, readOnly
#   downloadBytes: string, format: int64, readOnly
#   enableConfidentialCompute: boolean, readOnly
#   guestFlush: boolean
#   guestOsFeatures: array<GuestOsFeature>, readOnly
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   labelFingerprint: string, format: byte
#   labels: map<string, string>
#   licenseCodes: array<string>, readOnly
#   licenses: array<string>, readOnly
#   locationHint: string
#   name: string
#   params: $ref: SnapshotParams
#   satisfiesPzi: boolean, readOnly
#   satisfiesPzs: boolean, readOnly
#   selfLink: string, readOnly
#   snapshotEncryptionKey: $ref: CustomerEncryptionKey
#   snapshotType: string, enum: [ARCHIVE, STANDARD]
#   sourceDisk: string
#   sourceDiskEncryptionKey: $ref: CustomerEncryptionKey
#   sourceDiskForRecoveryCheckpoint: string
#   sourceDiskId: string, readOnly
#   sourceInstantSnapshot: string
#   sourceInstantSnapshotEncryptionKey: $ref: CustomerEncryptionKey
#   sourceInstantSnapshotId: string, readOnly
#   sourceSnapshotSchedulePolicy: string, readOnly
#   sourceSnapshotSchedulePolicyId: string, readOnly
#   status: string, enum: [CREATING, DELETING, FAILED, READY, UPLOADING], readOnly
#   storageBytes: string, format: int64, readOnly
#   storageBytesStatus: string, enum: [UPDATING, UP_TO_DATE], readOnly
#   storageLocations: array<string>
#
# [types.field_overrides]
# name = { required = true }
# labelFingerprint = { format = "bytes" }
# # status = { enum_type = "SnapshotStatus" }
# # storageBytesStatus = { enum_type = "SnapshotStorageBytesStatus" }
# # snapshotType = { enum_type = "SnapshotSnapshotType" }
# # architecture = { enum_type = "SnapshotArchitecture" }

# --- SnapshotList (6 fields) ---
# Contains a list of Snapshot resources.
# [[types]]
# schema = "SnapshotList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<Snapshot>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- SnapshotParams (1 fields) ---
# Additional snapshot params.
# [[types]]
# schema = "SnapshotParams"
# include_fields = ["resourceManagerTags"]
#
#   resourceManagerTags: map<string, string>

# --- SnapshotSettings (1 fields) ---
# [[types]]
# schema = "SnapshotSettings"
# include_fields = ["storageLocation"]
#
#   storageLocation: $ref: SnapshotSettingsStorageLocationSettings

# --- SnapshotSettingsStorageLocationSettings (2 fields) ---
# [[types]]
# schema = "SnapshotSettingsStorageLocationSettings"
# include_fields = ["locations", "policy"]
#
#   locations: map<string, SnapshotSettingsStorageLocationSettingsStorageLocationPreference>
#   policy: string, enum: [LOCAL_REGION, NEAREST_MULTI_REGION, SPECIFIC_LOCATIONS, STORAGE_LOCATION_POLICY_UNSPECIFIED]
#
# [types.field_overrides]
# # policy = { enum_type = "SnapshotSettingsStorageLocationSettingsPolicy" }

# --- SnapshotSettingsStorageLocationSettingsStorageLocationPreference (1 fields) ---
# A structure for specifying storage locations.
# [[types]]
# schema = "SnapshotSettingsStorageLocationSettingsStorageLocationPreference"
# include_fields = ["name"]
#
#   name: string
#
# [types.field_overrides]
# name = { required = true }

# --- SourceDiskEncryptionKey (2 fields) ---
# [[types]]
# schema = "SourceDiskEncryptionKey"
# include_fields = ["diskEncryptionKey", "sourceDisk"]
#
#   diskEncryptionKey: $ref: CustomerEncryptionKey
#   sourceDisk: string

# --- SourceInstanceParams (1 fields) ---
# A specification of the parameters to use when creating the instance template from a source instance.
# [[types]]
# schema = "SourceInstanceParams"
# include_fields = ["diskConfigs"]
#
#   diskConfigs: array<DiskInstantiationConfig>

# --- SourceInstanceProperties (15 fields) ---
# DEPRECATED: Please use compute#instanceProperties instead. New properties will not be added to this 
# [[types]]
# schema = "SourceInstanceProperties"
# include_fields = ["canIpForward", "deletionProtection", "description", "disks", "guestAccelerators", "keyRevocationActionType", "labels", "machineType", "metadata", "minCpuPlatform", "networkInterfaces", "postKeyRevocationActionType", "scheduling", "serviceAccounts", "tags"]
#
#   canIpForward: boolean
#   deletionProtection: boolean
#   description: string
#   disks: array<SavedAttachedDisk>
#   guestAccelerators: array<AcceleratorConfig>
#   keyRevocationActionType: string, enum: [KEY_REVOCATION_ACTION_TYPE_UNSPECIFIED, NONE, STOP]
#   labels: map<string, string>
#   machineType: string
#   metadata: $ref: Metadata
#   minCpuPlatform: string
#   networkInterfaces: array<NetworkInterface>
#   postKeyRevocationActionType: string, enum: [NOOP, POST_KEY_REVOCATION_ACTION_TYPE_UNSPECIFIED, SHUTDOWN]
#   scheduling: $ref: Scheduling
#   serviceAccounts: array<ServiceAccount>
#   tags: $ref: Tags
#
# [types.field_overrides]
# # keyRevocationActionType = { enum_type = "SourceInstancePropertiesKeyRevocationActionType" }
# # postKeyRevocationActionType = { enum_type = "SourceInstancePropertiesPostKeyRevocationActionType" }

# --- SslCertificate (14 fields) ---
# Represents an SSL certificate resource. Google Compute Engine has two SSL certificate resources: * [
# WARNING: reserved words: type
# [[types]]
# schema = "SslCertificate"
# include_fields = ["certificate", "creationTimestamp", "description", "expireTime", "id", "kind", "managed", "name", "privateKey", "region", "selfLink", "selfManaged", "subjectAlternativeNames", "type"]
#
#   certificate: string
#   creationTimestamp: string
#   description: string
#   expireTime: string, readOnly
#   id: string, format: uint64
#   kind: string, readOnly
#   managed: $ref: SslCertificateManagedSslCertificate
#   name: string
#   privateKey: string
#   region: string, readOnly
#   selfLink: string
#   selfManaged: $ref: SslCertificateSelfManagedSslCertificate
#   subjectAlternativeNames: array<string>, readOnly
#   type: string, enum: [MANAGED, SELF_MANAGED, TYPE_UNSPECIFIED], RESERVED_WORD
#
# [types.field_overrides]
# name = { required = true }
# type = { rust_name = "type_value", serde_rename = "type" }
# # type = { enum_type = "SslCertificateType" }

# --- SslCertificateAggregatedList (7 fields) ---
# [[types]]
# schema = "SslCertificateAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, SslCertificatesScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- SslCertificateList (6 fields) ---
# Contains a list of SslCertificate resources.
# [[types]]
# schema = "SslCertificateList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<SslCertificate>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- SslCertificateManagedSslCertificate (3 fields) ---
# Configuration and status of a managed SSL certificate.
# [[types]]
# schema = "SslCertificateManagedSslCertificate"
# include_fields = ["domainStatus", "domains", "status"]
#
#   domainStatus: map<string, string>, readOnly
#   domains: array<string>
#   status: string, enum: [ACTIVE, MANAGED_CERTIFICATE_STATUS_UNSPECIFIED, PROVISIONING, PROVISIONING_FAILED, ... +2], readOnly
#
# [types.field_overrides]
# # status = { enum_type = "SslCertificateManagedSslCertificateStatus" }

# --- SslCertificateSelfManagedSslCertificate (2 fields) ---
# Configuration and status of a self-managed SSL certificate.
# [[types]]
# schema = "SslCertificateSelfManagedSslCertificate"
# include_fields = ["certificate", "privateKey"]
#
#   certificate: string
#   privateKey: string

# --- SslCertificatesScopedList (2 fields) ---
# [[types]]
# schema = "SslCertificatesScopedList"
# include_fields = ["sslCertificates", "warning"]
#
#   sslCertificates: array<SslCertificate>
#   warning: object

# --- SslPoliciesAggregatedList (8 fields) ---
# [[types]]
# schema = "SslPoliciesAggregatedList"
# include_fields = ["etag", "id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   etag: string
#   id: string
#   items: map<string, SslPoliciesScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- SslPoliciesList (6 fields) ---
# [[types]]
# schema = "SslPoliciesList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string, readOnly
#   items: array<SslPolicy>, readOnly
#   kind: string, readOnly
#   nextPageToken: string, readOnly
#   selfLink: string, readOnly
#   warning: object

# --- SslPoliciesListAvailableFeaturesResponse (1 fields) ---
# [[types]]
# schema = "SslPoliciesListAvailableFeaturesResponse"
# include_fields = ["features"]
#
#   features: array<string>

# --- SslPoliciesScopedList (2 fields) ---
# [[types]]
# schema = "SslPoliciesScopedList"
# include_fields = ["sslPolicies", "warning"]
#
#   sslPolicies: array<SslPolicy>
#   warning: object

# --- SslPolicy (13 fields) ---
# Represents an SSL Policy resource. Use SSL policies to control SSL features, such as versions and ci
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "SslPolicy"
# include_fields = ["creationTimestamp", "customFeatures", "description", "enabledFeatures", "fingerprint", "id", "kind", "minTlsVersion", "name", "profile", "region", "selfLink", "warnings"]
#
#   creationTimestamp: string, readOnly
#   customFeatures: array<string>
#   description: string
#   enabledFeatures: array<string>, readOnly
#   fingerprint: string, format: byte
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   minTlsVersion: string, enum: [TLS_1_0, TLS_1_1, TLS_1_2, TLS_1_3]
#   name: string
#   profile: string, enum: [COMPATIBLE, CUSTOM, FIPS_202205, MODERN, RESTRICTED]
#   region: string, readOnly
#   selfLink: string, readOnly
#   warnings: array<object>, readOnly
#
# [types.field_overrides]
# name = { required = true }
# fingerprint = { format = "bytes" }
# # profile = { enum_type = "SslPolicyProfile" }
# # minTlsVersion = { enum_type = "SslPolicyMinTlsVersion" }

# --- SslPolicyReference (1 fields) ---
# [[types]]
# schema = "SslPolicyReference"
# include_fields = ["sslPolicy"]
#
#   sslPolicy: string

# --- StatefulPolicy (1 fields) ---
# [[types]]
# schema = "StatefulPolicy"
# include_fields = ["preservedState"]
#
#   preservedState: $ref: StatefulPolicyPreservedState

# --- StatefulPolicyPreservedState (3 fields) ---
# Configuration of preserved resources.
# [[types]]
# schema = "StatefulPolicyPreservedState"
# include_fields = ["disks", "externalIPs", "internalIPs"]
#
#   disks: map<string, StatefulPolicyPreservedStateDiskDevice>
#   externalIPs: map<string, StatefulPolicyPreservedStateNetworkIp>
#   internalIPs: map<string, StatefulPolicyPreservedStateNetworkIp>

# --- StatefulPolicyPreservedStateDiskDevice (1 fields) ---
# [[types]]
# schema = "StatefulPolicyPreservedStateDiskDevice"
# include_fields = ["autoDelete"]
#
#   autoDelete: string, enum: [NEVER, ON_PERMANENT_INSTANCE_DELETION]
#
# [types.field_overrides]
# # autoDelete = { enum_type = "StatefulPolicyPreservedStateDiskDeviceAutoDelete" }

# --- StatefulPolicyPreservedStateNetworkIp (1 fields) ---
# [[types]]
# schema = "StatefulPolicyPreservedStateNetworkIp"
# include_fields = ["autoDelete"]
#
#   autoDelete: string, enum: [NEVER, ON_PERMANENT_INSTANCE_DELETION]
#
# [types.field_overrides]
# # autoDelete = { enum_type = "StatefulPolicyPreservedStateNetworkIpAutoDelete" }

# --- Status (3 fields) ---
# The `Status` type defines a logical error model that is suitable for different programming environme
# [[types]]
# schema = "Status"
# include_fields = ["code", "details", "message"]
#
#   code: integer, format: int32
#   details: array<object>
#   message: string

# --- StoragePool (21 fields) ---
# Represents a zonal storage pool resource.
# WARNING: format:"byte" fields: labelFingerprint
# [[types]]
# schema = "StoragePool"
# include_fields = ["capacityProvisioningType", "creationTimestamp", "description", "exapoolProvisionedCapacityGb", "id", "kind", "labelFingerprint", "labels", "name", "params", "performanceProvisioningType", "poolProvisionedCapacityGb", "poolProvisionedIops", "poolProvisionedThroughput", "resourceStatus", "selfLink", "selfLinkWithId", "state", "status", "storagePoolType", "zone"]
#
#   capacityProvisioningType: string, enum: [ADVANCED, STANDARD, UNSPECIFIED]
#   creationTimestamp: string, readOnly
#   description: string
#   exapoolProvisionedCapacityGb: $ref: StoragePoolExapoolProvisionedCapacityGb, readOnly
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   labelFingerprint: string, format: byte
#   labels: map<string, string>
#   name: string
#   params: $ref: StoragePoolParams
#   performanceProvisioningType: string, enum: [ADVANCED, STANDARD, UNSPECIFIED]
#   poolProvisionedCapacityGb: string, format: int64
#   poolProvisionedIops: string, format: int64
#   poolProvisionedThroughput: string, format: int64
#   resourceStatus: $ref: StoragePoolResourceStatus, readOnly
#   selfLink: string, readOnly
#   selfLinkWithId: string, readOnly
#   state: string, enum: [CREATING, DELETING, FAILED, READY], readOnly
#   status: $ref: StoragePoolResourceStatus, readOnly
#   storagePoolType: string
#   zone: string, readOnly
#
# [types.field_overrides]
# name = { required = true }
# labelFingerprint = { format = "bytes" }
# # performanceProvisioningType = { enum_type = "StoragePoolPerformanceProvisioningType" }
# # capacityProvisioningType = { enum_type = "StoragePoolCapacityProvisioningType" }
# # state = { enum_type = "StoragePoolState" }

# --- StoragePoolAggregatedList (8 fields) ---
# [[types]]
# schema = "StoragePoolAggregatedList"
# include_fields = ["etag", "id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   etag: string
#   id: string
#   items: map<string, StoragePoolsScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- StoragePoolDisk (11 fields) ---
# WARNING: reserved words: type
# [[types]]
# schema = "StoragePoolDisk"
# include_fields = ["attachedInstances", "creationTimestamp", "disk", "name", "provisionedIops", "provisionedThroughput", "resourcePolicies", "sizeGb", "status", "type", "usedBytes"]
#
#   attachedInstances: array<string>, readOnly
#   creationTimestamp: string, readOnly
#   disk: string, readOnly
#   name: string, readOnly
#   provisionedIops: string, format: int64, readOnly
#   provisionedThroughput: string, format: int64, readOnly
#   resourcePolicies: array<string>, readOnly
#   sizeGb: string, format: int64, readOnly
#   status: string, enum: [CREATING, DELETING, FAILED, READY, ... +2], readOnly
#   type: string, readOnly, RESERVED_WORD
#   usedBytes: string, format: int64, readOnly
#
# [types.field_overrides]
# name = { required = true }
# type = { rust_name = "type_value", serde_rename = "type" }
# # status = { enum_type = "StoragePoolDiskStatus" }

# --- StoragePoolExapoolProvisionedCapacityGb (3 fields) ---
# Exapool provisioned capacities for each SKU type
# [[types]]
# schema = "StoragePoolExapoolProvisionedCapacityGb"
# include_fields = ["capacityOptimized", "readOptimized", "writeOptimized"]
#
#   capacityOptimized: string, format: int64
#   readOptimized: string, format: int64
#   writeOptimized: string, format: int64

# --- StoragePoolList (8 fields) ---
# A list of StoragePool resources.
# [[types]]
# schema = "StoragePoolList"
# include_fields = ["etag", "id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   etag: string
#   id: string
#   items: array<StoragePool>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- StoragePoolListDisks (8 fields) ---
# [[types]]
# schema = "StoragePoolListDisks"
# include_fields = ["etag", "id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   etag: string
#   id: string, readOnly
#   items: array<StoragePoolDisk>
#   kind: string, readOnly
#   nextPageToken: string, readOnly
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object, readOnly

# --- StoragePoolParams (1 fields) ---
# Additional storage pool params.
# [[types]]
# schema = "StoragePoolParams"
# include_fields = ["resourceManagerTags"]
#
#   resourceManagerTags: map<string, string>

# --- StoragePoolResourceStatus (14 fields) ---
# [Output Only] Contains output only fields.
# [[types]]
# schema = "StoragePoolResourceStatus"
# include_fields = ["diskCount", "exapoolMaxReadIops", "exapoolMaxReadThroughput", "exapoolMaxWriteIops", "exapoolMaxWriteThroughput", "lastResizeTimestamp", "maxTotalProvisionedDiskCapacityGb", "poolUsedCapacityBytes", "poolUsedIops", "poolUsedThroughput", "poolUserWrittenBytes", "totalProvisionedDiskCapacityGb", "totalProvisionedDiskIops", "totalProvisionedDiskThroughput"]
#
#   diskCount: string, format: int64
#   exapoolMaxReadIops: string, format: int64, readOnly
#   exapoolMaxReadThroughput: string, format: int64, readOnly
#   exapoolMaxWriteIops: string, format: int64, readOnly
#   exapoolMaxWriteThroughput: string, format: int64, readOnly
#   lastResizeTimestamp: string, readOnly
#   maxTotalProvisionedDiskCapacityGb: string, format: int64
#   poolUsedCapacityBytes: string, format: int64
#   poolUsedIops: string, format: int64
#   poolUsedThroughput: string, format: int64
#   poolUserWrittenBytes: string, format: int64
#   totalProvisionedDiskCapacityGb: string, format: int64
#   totalProvisionedDiskIops: string, format: int64
#   totalProvisionedDiskThroughput: string, format: int64

# --- StoragePoolType (17 fields) ---
# [[types]]
# schema = "StoragePoolType"
# include_fields = ["creationTimestamp", "deprecated", "description", "id", "kind", "maxPoolProvisionedCapacityGb", "maxPoolProvisionedIops", "maxPoolProvisionedThroughput", "minPoolProvisionedCapacityGb", "minPoolProvisionedIops", "minPoolProvisionedThroughput", "minSizeGb", "name", "selfLink", "selfLinkWithId", "supportedDiskTypes", "zone"]
#
#   creationTimestamp: string
#   deprecated: $ref: DeprecationStatus
#   description: string
#   id: string, format: uint64
#   kind: string, readOnly
#   maxPoolProvisionedCapacityGb: string, format: int64
#   maxPoolProvisionedIops: string, format: int64
#   maxPoolProvisionedThroughput: string, format: int64
#   minPoolProvisionedCapacityGb: string, format: int64
#   minPoolProvisionedIops: string, format: int64
#   minPoolProvisionedThroughput: string, format: int64
#   minSizeGb: string, format: int64
#   name: string
#   selfLink: string
#   selfLinkWithId: string, readOnly
#   supportedDiskTypes: array<string>
#   zone: string
#
# [types.field_overrides]
# name = { required = true }

# --- StoragePoolTypeAggregatedList (6 fields) ---
# [[types]]
# schema = "StoragePoolTypeAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: map<string, StoragePoolTypesScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- StoragePoolTypeList (6 fields) ---
# Contains a list of storage pool types.
# [[types]]
# schema = "StoragePoolTypeList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<StoragePoolType>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- StoragePoolTypesScopedList (2 fields) ---
# [[types]]
# schema = "StoragePoolTypesScopedList"
# include_fields = ["storagePoolTypes", "warning"]
#
#   storagePoolTypes: array<StoragePoolType>
#   warning: object

# --- StoragePoolsScopedList (2 fields) ---
# [[types]]
# schema = "StoragePoolsScopedList"
# include_fields = ["storagePools", "warning"]
#
#   storagePools: array<StoragePool>
#   warning: object

# --- Subnetwork (33 fields) ---
# Represents a Subnetwork resource. A subnetwork (also known as a subnet) is a logical partition of a 
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "Subnetwork"
# include_fields = ["allowSubnetCidrRoutesOverlap", "creationTimestamp", "description", "enableFlowLogs", "externalIpv6Prefix", "fingerprint", "gatewayAddress", "id", "internalIpv6Prefix", "ipCidrRange", "ipCollection", "ipv6AccessType", "ipv6CidrRange", "ipv6GceEndpoint", "kind", "logConfig", "name", "network", "params", "privateIpGoogleAccess", "privateIpv6GoogleAccess", "purpose", "region", "reservedInternalRange", "resolveSubnetMask", "role", "secondaryIpRanges", "selfLink", "stackType", "state", "systemReservedExternalIpv6Ranges", "systemReservedInternalIpv6Ranges", "utilizationDetails"]
#
#   allowSubnetCidrRoutesOverlap: boolean
#   creationTimestamp: string, readOnly
#   description: string
#   enableFlowLogs: boolean
#   externalIpv6Prefix: string
#   fingerprint: string, format: byte
#   gatewayAddress: string, readOnly
#   id: string, format: uint64, readOnly
#   internalIpv6Prefix: string
#   ipCidrRange: string
#   ipCollection: string
#   ipv6AccessType: string, enum: [EXTERNAL, INTERNAL]
#   ipv6CidrRange: string, readOnly
#   ipv6GceEndpoint: string, enum: [VM_AND_FR, VM_ONLY], readOnly
#   kind: string, readOnly
#   logConfig: $ref: SubnetworkLogConfig
#   name: string
#   network: string
#   params: $ref: SubnetworkParams
#   privateIpGoogleAccess: boolean
#   privateIpv6GoogleAccess: string, enum: [DISABLE_GOOGLE_ACCESS, ENABLE_BIDIRECTIONAL_ACCESS_TO_GOOGLE, ENABLE_OUTBOUND_VM_ACCESS_TO_GOOGLE]
#   purpose: string, enum: [GLOBAL_MANAGED_PROXY, INTERNAL_HTTPS_LOAD_BALANCER, PEER_MIGRATION, PRIVATE, ... +4]
#   region: string
#   reservedInternalRange: string
#   resolveSubnetMask: string, enum: [ARP_ALL_RANGES, ARP_PRIMARY_RANGE]
#   role: string, enum: [ACTIVE, BACKUP]
#   secondaryIpRanges: array<SubnetworkSecondaryRange>
#   selfLink: string
#   stackType: string, enum: [IPV4_IPV6, IPV4_ONLY, IPV6_ONLY]
#   state: string, enum: [DRAINING, READY], readOnly
#   systemReservedExternalIpv6Ranges: array<string>, readOnly
#   systemReservedInternalIpv6Ranges: array<string>, readOnly
#   utilizationDetails: $ref: SubnetworkUtilizationDetails, readOnly
#
# [types.field_overrides]
# name = { required = true }
# fingerprint = { format = "bytes" }
# # purpose = { enum_type = "SubnetworkPurpose" }
# # stackType = { enum_type = "SubnetworkStackType" }
# # state = { enum_type = "SubnetworkState" }
# # role = { enum_type = "SubnetworkRole" }
# # ipv6AccessType = { enum_type = "SubnetworkIpv6AccessType" }
# # ipv6GceEndpoint = { enum_type = "SubnetworkIpv6GceEndpoint" }
# # resolveSubnetMask = { enum_type = "SubnetworkResolveSubnetMask" }
# # privateIpv6GoogleAccess = { enum_type = "SubnetworkPrivateIpv6GoogleAccess" }

# --- SubnetworkAggregatedList (7 fields) ---
# [[types]]
# schema = "SubnetworkAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, SubnetworksScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- SubnetworkList (6 fields) ---
# Contains a list of Subnetwork resources.
# [[types]]
# schema = "SubnetworkList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<Subnetwork>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- SubnetworkLogConfig (6 fields) ---
# The available logging options for this subnetwork.
# [[types]]
# schema = "SubnetworkLogConfig"
# include_fields = ["aggregationInterval", "enable", "filterExpr", "flowSampling", "metadata", "metadataFields"]
#
#   aggregationInterval: string, enum: [INTERVAL_10_MIN, INTERVAL_15_MIN, INTERVAL_1_MIN, INTERVAL_30_SEC, ... +2]
#   enable: boolean
#   filterExpr: string
#   flowSampling: number, format: float
#   metadata: string, enum: [CUSTOM_METADATA, EXCLUDE_ALL_METADATA, INCLUDE_ALL_METADATA]
#   metadataFields: array<string>
#
# [types.field_overrides]
# # metadata = { enum_type = "SubnetworkLogConfigMetadata" }
# # aggregationInterval = { enum_type = "SubnetworkLogConfigAggregationInterval" }

# --- SubnetworkParams (1 fields) ---
# Additional subnetwork parameters.
# [[types]]
# schema = "SubnetworkParams"
# include_fields = ["resourceManagerTags"]
#
#   resourceManagerTags: map<string, string>

# --- SubnetworkSecondaryRange (3 fields) ---
# Represents a secondary IP range of a subnetwork.
# [[types]]
# schema = "SubnetworkSecondaryRange"
# include_fields = ["ipCidrRange", "rangeName", "reservedInternalRange"]
#
#   ipCidrRange: string
#   rangeName: string
#   reservedInternalRange: string

# --- SubnetworkUtilizationDetails (4 fields) ---
# The current IP utilization of all subnetwork ranges. Contains the total number of allocated and free
# [[types]]
# schema = "SubnetworkUtilizationDetails"
# include_fields = ["externalIpv6InstanceUtilization", "externalIpv6LbUtilization", "internalIpv6Utilization", "ipv4Utilizations"]
#
#   externalIpv6InstanceUtilization: $ref: SubnetworkUtilizationDetailsIPV6Utilization
#   externalIpv6LbUtilization: $ref: SubnetworkUtilizationDetailsIPV6Utilization
#   internalIpv6Utilization: $ref: SubnetworkUtilizationDetailsIPV6Utilization
#   ipv4Utilizations: array<SubnetworkUtilizationDetailsIPV4Utilization>

# --- SubnetworkUtilizationDetailsIPV4Utilization (3 fields) ---
# The IPV4 utilization of a single IP range.
# [[types]]
# schema = "SubnetworkUtilizationDetailsIPV4Utilization"
# include_fields = ["rangeName", "totalAllocatedIp", "totalFreeIp"]
#
#   rangeName: string
#   totalAllocatedIp: string, format: int64
#   totalFreeIp: string, format: int64

# --- SubnetworkUtilizationDetailsIPV6Utilization (2 fields) ---
# The IPV6 utilization of a single IP range.
# [[types]]
# schema = "SubnetworkUtilizationDetailsIPV6Utilization"
# include_fields = ["totalAllocatedIp", "totalFreeIp"]
#
#   totalAllocatedIp: $ref: Uint128
#   totalFreeIp: $ref: Uint128

# --- SubnetworksExpandIpCidrRangeRequest (1 fields) ---
# [[types]]
# schema = "SubnetworksExpandIpCidrRangeRequest"
# include_fields = ["ipCidrRange"]
#
#   ipCidrRange: string

# --- SubnetworksScopedList (2 fields) ---
# [[types]]
# schema = "SubnetworksScopedList"
# include_fields = ["subnetworks", "warning"]
#
#   subnetworks: array<Subnetwork>
#   warning: object

# --- SubnetworksScopedWarning (2 fields) ---
# [[types]]
# schema = "SubnetworksScopedWarning"
# include_fields = ["scopeName", "warning"]
#
#   scopeName: string
#   warning: object

# --- SubnetworksSetPrivateIpGoogleAccessRequest (1 fields) ---
# [[types]]
# schema = "SubnetworksSetPrivateIpGoogleAccessRequest"
# include_fields = ["privateIpGoogleAccess"]
#
#   privateIpGoogleAccess: boolean

# --- Subsetting (1 fields) ---
# Subsetting configuration for this BackendService. Currently this is applicable only for Internal TCP
# [[types]]
# schema = "Subsetting"
# include_fields = ["policy"]
#
#   policy: string, enum: [CONSISTENT_HASH_SUBSETTING, NONE]
#
# [types.field_overrides]
# # policy = { enum_type = "SubsettingPolicy" }

# --- TCPHealthCheck (6 fields) ---
# [[types]]
# schema = "TCPHealthCheck"
# include_fields = ["port", "portName", "portSpecification", "proxyHeader", "request", "response"]
#
#   port: integer, format: int32
#   portName: string
#   portSpecification: string, enum: [USE_FIXED_PORT, USE_NAMED_PORT, USE_SERVING_PORT]
#   proxyHeader: string, enum: [NONE, PROXY_V1]
#   request: string
#   response: string
#
# [types.field_overrides]
# # proxyHeader = { enum_type = "TCPHealthCheckProxyHeader" }
# # portSpecification = { enum_type = "TCPHealthCheckPortSpecification" }

# --- Tags (2 fields) [IN MANIFEST] ---
# A set of instance tags.
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "Tags"
# include_fields = ["fingerprint", "items"]
#
#   fingerprint: string, format: byte
#   items: array<string>
#
# [types.field_overrides]
# fingerprint = { format = "bytes" }

# --- TargetGrpcProxy (10 fields) ---
# Represents a Target gRPC Proxy resource. A target gRPC proxy is a component of load balancers intend
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "TargetGrpcProxy"
# include_fields = ["creationTimestamp", "description", "fingerprint", "id", "kind", "name", "selfLink", "selfLinkWithId", "urlMap", "validateForProxyless"]
#
#   creationTimestamp: string, readOnly
#   description: string
#   fingerprint: string, format: byte
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   name: string
#   selfLink: string, readOnly
#   selfLinkWithId: string, readOnly
#   urlMap: string
#   validateForProxyless: boolean
#
# [types.field_overrides]
# name = { required = true }
# fingerprint = { format = "bytes" }

# --- TargetGrpcProxyList (6 fields) ---
# [[types]]
# schema = "TargetGrpcProxyList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<TargetGrpcProxy>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string
#   warning: object

# --- TargetHttpProxiesScopedList (2 fields) ---
# [[types]]
# schema = "TargetHttpProxiesScopedList"
# include_fields = ["targetHttpProxies", "warning"]
#
#   targetHttpProxies: array<TargetHttpProxy>
#   warning: object

# --- TargetHttpProxy (11 fields) ---
# Represents a Target HTTP Proxy resource. Google Compute Engine has two Target HTTP Proxy resources: 
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "TargetHttpProxy"
# include_fields = ["creationTimestamp", "description", "fingerprint", "httpKeepAliveTimeoutSec", "id", "kind", "name", "proxyBind", "region", "selfLink", "urlMap"]
#
#   creationTimestamp: string, readOnly
#   description: string
#   fingerprint: string, format: byte
#   httpKeepAliveTimeoutSec: integer, format: int32
#   id: string, format: uint64
#   kind: string, readOnly
#   name: string
#   proxyBind: boolean
#   region: string, readOnly
#   selfLink: string
#   urlMap: string
#
# [types.field_overrides]
# name = { required = true }
# fingerprint = { format = "bytes" }

# --- TargetHttpProxyAggregatedList (6 fields) ---
# [[types]]
# schema = "TargetHttpProxyAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables"]
#
#   id: string
#   items: map<string, TargetHttpProxiesScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly

# --- TargetHttpProxyList (6 fields) ---
# A list of TargetHttpProxy resources.
# [[types]]
# schema = "TargetHttpProxyList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<TargetHttpProxy>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- TargetHttpsProxiesScopedList (2 fields) ---
# [[types]]
# schema = "TargetHttpsProxiesScopedList"
# include_fields = ["targetHttpsProxies", "warning"]
#
#   targetHttpsProxies: array<TargetHttpsProxy>
#   warning: object

# --- TargetHttpsProxiesSetCertificateMapRequest (1 fields) ---
# [[types]]
# schema = "TargetHttpsProxiesSetCertificateMapRequest"
# include_fields = ["certificateMap"]
#
#   certificateMap: string

# --- TargetHttpsProxiesSetQuicOverrideRequest (1 fields) ---
# [[types]]
# schema = "TargetHttpsProxiesSetQuicOverrideRequest"
# include_fields = ["quicOverride"]
#
#   quicOverride: string, enum: [DISABLE, ENABLE, NONE]
#
# [types.field_overrides]
# # quicOverride = { enum_type = "TargetHttpsProxiesSetQuicOverrideRequestQuicOverride" }

# --- TargetHttpsProxiesSetSslCertificatesRequest (1 fields) ---
# [[types]]
# schema = "TargetHttpsProxiesSetSslCertificatesRequest"
# include_fields = ["sslCertificates"]
#
#   sslCertificates: array<string>

# --- TargetHttpsProxy (18 fields) ---
# Represents a Target HTTPS Proxy resource. Google Compute Engine has two Target HTTPS Proxy resources
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "TargetHttpsProxy"
# include_fields = ["authorizationPolicy", "certificateMap", "creationTimestamp", "description", "fingerprint", "httpKeepAliveTimeoutSec", "id", "kind", "name", "proxyBind", "quicOverride", "region", "selfLink", "serverTlsPolicy", "sslCertificates", "sslPolicy", "tlsEarlyData", "urlMap"]
#
#   authorizationPolicy: string
#   certificateMap: string
#   creationTimestamp: string, readOnly
#   description: string
#   fingerprint: string, format: byte
#   httpKeepAliveTimeoutSec: integer, format: int32
#   id: string, format: uint64
#   kind: string, readOnly
#   name: string
#   proxyBind: boolean
#   quicOverride: string, enum: [DISABLE, ENABLE, NONE]
#   region: string, readOnly
#   selfLink: string
#   serverTlsPolicy: string
#   sslCertificates: array<string>
#   sslPolicy: string
#   tlsEarlyData: string, enum: [DISABLED, PERMISSIVE, STRICT, UNRESTRICTED]
#   urlMap: string
#
# [types.field_overrides]
# name = { required = true }
# fingerprint = { format = "bytes" }
# # quicOverride = { enum_type = "TargetHttpsProxyQuicOverride" }
# # tlsEarlyData = { enum_type = "TargetHttpsProxyTlsEarlyData" }

# --- TargetHttpsProxyAggregatedList (7 fields) ---
# [[types]]
# schema = "TargetHttpsProxyAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, TargetHttpsProxiesScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- TargetHttpsProxyList (6 fields) ---
# Contains a list of TargetHttpsProxy resources.
# [[types]]
# schema = "TargetHttpsProxyList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<TargetHttpsProxy>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- TargetInstance (11 fields) ---
# Represents a Target Instance resource. You can use a target instance to handle traffic for one or mo
# [[types]]
# schema = "TargetInstance"
# include_fields = ["creationTimestamp", "description", "id", "instance", "kind", "name", "natPolicy", "network", "securityPolicy", "selfLink", "zone"]
#
#   creationTimestamp: string, readOnly
#   description: string
#   id: string, format: uint64
#   instance: string
#   kind: string, readOnly
#   name: string
#   natPolicy: string, enum: [NO_NAT]
#   network: string
#   securityPolicy: string
#   selfLink: string
#   zone: string, readOnly
#
# [types.field_overrides]
# name = { required = true }
# # natPolicy = { enum_type = "TargetInstanceNatPolicy" }

# --- TargetInstanceAggregatedList (7 fields) ---
# [[types]]
# schema = "TargetInstanceAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, TargetInstancesScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- TargetInstanceList (6 fields) ---
# Contains a list of TargetInstance resources.
# [[types]]
# schema = "TargetInstanceList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<TargetInstance>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- TargetInstancesScopedList (2 fields) ---
# [[types]]
# schema = "TargetInstancesScopedList"
# include_fields = ["targetInstances", "warning"]
#
#   targetInstances: array<TargetInstance>
#   warning: object

# --- TargetPool (13 fields) ---
# Represents a Target Pool resource. Target pools are used with external passthrough Network Load Bala
# [[types]]
# schema = "TargetPool"
# include_fields = ["backupPool", "creationTimestamp", "description", "failoverRatio", "healthChecks", "id", "instances", "kind", "name", "region", "securityPolicy", "selfLink", "sessionAffinity"]
#
#   backupPool: string
#   creationTimestamp: string, readOnly
#   description: string
#   failoverRatio: number, format: float
#   healthChecks: array<string>
#   id: string, format: uint64
#   instances: array<string>
#   kind: string, readOnly
#   name: string
#   region: string, readOnly
#   securityPolicy: string
#   selfLink: string
#   sessionAffinity: string, enum: [CLIENT_IP, CLIENT_IP_NO_DESTINATION, CLIENT_IP_PORT_PROTO, CLIENT_IP_PROTO, ... +5]
#
# [types.field_overrides]
# name = { required = true }
# # sessionAffinity = { enum_type = "TargetPoolSessionAffinity" }

# --- TargetPoolAggregatedList (7 fields) ---
# [[types]]
# schema = "TargetPoolAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, TargetPoolsScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- TargetPoolInstanceHealth (2 fields) ---
# [[types]]
# schema = "TargetPoolInstanceHealth"
# include_fields = ["healthStatus", "kind"]
#
#   healthStatus: array<HealthStatus>
#   kind: string, readOnly

# --- TargetPoolList (6 fields) ---
# Contains a list of TargetPool resources.
# [[types]]
# schema = "TargetPoolList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<TargetPool>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- TargetPoolsAddHealthCheckRequest (1 fields) ---
# [[types]]
# schema = "TargetPoolsAddHealthCheckRequest"
# include_fields = ["healthChecks"]
#
#   healthChecks: array<HealthCheckReference>

# --- TargetPoolsAddInstanceRequest (1 fields) ---
# [[types]]
# schema = "TargetPoolsAddInstanceRequest"
# include_fields = ["instances"]
#
#   instances: array<InstanceReference>

# --- TargetPoolsRemoveHealthCheckRequest (1 fields) ---
# [[types]]
# schema = "TargetPoolsRemoveHealthCheckRequest"
# include_fields = ["healthChecks"]
#
#   healthChecks: array<HealthCheckReference>

# --- TargetPoolsRemoveInstanceRequest (1 fields) ---
# [[types]]
# schema = "TargetPoolsRemoveInstanceRequest"
# include_fields = ["instances"]
#
#   instances: array<InstanceReference>

# --- TargetPoolsScopedList (2 fields) ---
# [[types]]
# schema = "TargetPoolsScopedList"
# include_fields = ["targetPools", "warning"]
#
#   targetPools: array<TargetPool>
#   warning: object

# --- TargetReference (1 fields) ---
# [[types]]
# schema = "TargetReference"
# include_fields = ["target"]
#
#   target: string

# --- TargetSslProxiesSetBackendServiceRequest (1 fields) ---
# [[types]]
# schema = "TargetSslProxiesSetBackendServiceRequest"
# include_fields = ["service"]
#
#   service: string

# --- TargetSslProxiesSetCertificateMapRequest (1 fields) ---
# [[types]]
# schema = "TargetSslProxiesSetCertificateMapRequest"
# include_fields = ["certificateMap"]
#
#   certificateMap: string

# --- TargetSslProxiesSetProxyHeaderRequest (1 fields) ---
# [[types]]
# schema = "TargetSslProxiesSetProxyHeaderRequest"
# include_fields = ["proxyHeader"]
#
#   proxyHeader: string, enum: [NONE, PROXY_V1]
#
# [types.field_overrides]
# # proxyHeader = { enum_type = "TargetSslProxiesSetProxyHeaderRequestProxyHeader" }

# --- TargetSslProxiesSetSslCertificatesRequest (1 fields) ---
# [[types]]
# schema = "TargetSslProxiesSetSslCertificatesRequest"
# include_fields = ["sslCertificates"]
#
#   sslCertificates: array<string>

# --- TargetSslProxy (11 fields) ---
# Represents a Target SSL Proxy resource. A target SSL proxy is a component of a Proxy Network Load Ba
# [[types]]
# schema = "TargetSslProxy"
# include_fields = ["certificateMap", "creationTimestamp", "description", "id", "kind", "name", "proxyHeader", "selfLink", "service", "sslCertificates", "sslPolicy"]
#
#   certificateMap: string
#   creationTimestamp: string, readOnly
#   description: string
#   id: string, format: uint64
#   kind: string, readOnly
#   name: string
#   proxyHeader: string, enum: [NONE, PROXY_V1]
#   selfLink: string
#   service: string
#   sslCertificates: array<string>
#   sslPolicy: string
#
# [types.field_overrides]
# name = { required = true }
# # proxyHeader = { enum_type = "TargetSslProxyProxyHeader" }

# --- TargetSslProxyList (6 fields) ---
# Contains a list of TargetSslProxy resources.
# [[types]]
# schema = "TargetSslProxyList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<TargetSslProxy>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- TargetTcpProxiesScopedList (2 fields) ---
# [[types]]
# schema = "TargetTcpProxiesScopedList"
# include_fields = ["targetTcpProxies", "warning"]
#
#   targetTcpProxies: array<TargetTcpProxy>
#   warning: object

# --- TargetTcpProxiesSetBackendServiceRequest (1 fields) ---
# [[types]]
# schema = "TargetTcpProxiesSetBackendServiceRequest"
# include_fields = ["service"]
#
#   service: string

# --- TargetTcpProxiesSetProxyHeaderRequest (1 fields) ---
# [[types]]
# schema = "TargetTcpProxiesSetProxyHeaderRequest"
# include_fields = ["proxyHeader"]
#
#   proxyHeader: string, enum: [NONE, PROXY_V1]
#
# [types.field_overrides]
# # proxyHeader = { enum_type = "TargetTcpProxiesSetProxyHeaderRequestProxyHeader" }

# --- TargetTcpProxy (10 fields) ---
# Represents a Target TCP Proxy resource. A target TCP proxy is a component of a Proxy Network Load Ba
# [[types]]
# schema = "TargetTcpProxy"
# include_fields = ["creationTimestamp", "description", "id", "kind", "name", "proxyBind", "proxyHeader", "region", "selfLink", "service"]
#
#   creationTimestamp: string, readOnly
#   description: string
#   id: string, format: uint64
#   kind: string, readOnly
#   name: string
#   proxyBind: boolean
#   proxyHeader: string, enum: [NONE, PROXY_V1]
#   region: string, readOnly
#   selfLink: string
#   service: string
#
# [types.field_overrides]
# name = { required = true }
# # proxyHeader = { enum_type = "TargetTcpProxyProxyHeader" }

# --- TargetTcpProxyAggregatedList (7 fields) ---
# [[types]]
# schema = "TargetTcpProxyAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, TargetTcpProxiesScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- TargetTcpProxyList (6 fields) ---
# Contains a list of TargetTcpProxy resources.
# [[types]]
# schema = "TargetTcpProxyList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<TargetTcpProxy>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- TargetVpnGateway (13 fields) ---
# Represents a Target VPN Gateway resource. The target VPN gateway resource represents a Classic Cloud
# WARNING: format:"byte" fields: labelFingerprint
# [[types]]
# schema = "TargetVpnGateway"
# include_fields = ["creationTimestamp", "description", "forwardingRules", "id", "kind", "labelFingerprint", "labels", "name", "network", "region", "selfLink", "status", "tunnels"]
#
#   creationTimestamp: string, readOnly
#   description: string
#   forwardingRules: array<string>
#   id: string, format: uint64
#   kind: string, readOnly
#   labelFingerprint: string, format: byte
#   labels: map<string, string>
#   name: string
#   network: string
#   region: string
#   selfLink: string
#   status: string, enum: [CREATING, DELETING, FAILED, READY]
#   tunnels: array<string>
#
# [types.field_overrides]
# name = { required = true }
# labelFingerprint = { format = "bytes" }
# # status = { enum_type = "TargetVpnGatewayStatus" }

# --- TargetVpnGatewayAggregatedList (7 fields) ---
# [[types]]
# schema = "TargetVpnGatewayAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, TargetVpnGatewaysScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- TargetVpnGatewayList (6 fields) ---
# Contains a list of TargetVpnGateway resources.
# [[types]]
# schema = "TargetVpnGatewayList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<TargetVpnGateway>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- TargetVpnGatewaysScopedList (2 fields) ---
# [[types]]
# schema = "TargetVpnGatewaysScopedList"
# include_fields = ["targetVpnGateways", "warning"]
#
#   targetVpnGateways: array<TargetVpnGateway>
#   warning: object

# --- TestFailure (9 fields) ---
# [[types]]
# schema = "TestFailure"
# include_fields = ["actualOutputUrl", "actualRedirectResponseCode", "actualService", "expectedOutputUrl", "expectedRedirectResponseCode", "expectedService", "headers", "host", "path"]
#
#   actualOutputUrl: string
#   actualRedirectResponseCode: integer, format: int32
#   actualService: string
#   expectedOutputUrl: string
#   expectedRedirectResponseCode: integer, format: int32
#   expectedService: string
#   headers: array<UrlMapTestHeader>
#   host: string
#   path: string

# --- TestPermissionsRequest (1 fields) ---
# [[types]]
# schema = "TestPermissionsRequest"
# include_fields = ["permissions"]
#
#   permissions: array<string>

# --- TestPermissionsResponse (1 fields) ---
# [[types]]
# schema = "TestPermissionsResponse"
# include_fields = ["permissions"]
#
#   permissions: array<string>

# --- Uint128 (2 fields) ---
# [[types]]
# schema = "Uint128"
# include_fields = ["high", "low"]
#
#   high: string, format: uint64
#   low: string, format: uint64

# --- UpcomingMaintenance (8 fields) ---
# Upcoming Maintenance notification information.
# WARNING: reserved words: type
# [[types]]
# schema = "UpcomingMaintenance"
# include_fields = ["canReschedule", "latestWindowStartTime", "maintenanceOnShutdown", "maintenanceReasons", "maintenanceStatus", "type", "windowEndTime", "windowStartTime"]
#
#   canReschedule: boolean
#   latestWindowStartTime: string
#   maintenanceOnShutdown: boolean
#   maintenanceReasons: array<string>
#   maintenanceStatus: string, enum: [ONGOING, PENDING, UNKNOWN]
#   type: string, enum: [MULTIPLE, SCHEDULED, UNKNOWN_TYPE, UNSCHEDULED], RESERVED_WORD
#   windowEndTime: string
#   windowStartTime: string
#
# [types.field_overrides]
# type = { rust_name = "type_value", serde_rename = "type" }
# # maintenanceStatus = { enum_type = "UpcomingMaintenanceMaintenanceStatus" }
# # type = { enum_type = "UpcomingMaintenanceType" }

# --- UrlMap (16 fields) ---
# Represents a URL Map resource. Compute Engine has two URL Map resources: * [Global](/compute/docs/re
# WARNING: format:"byte" fields: fingerprint
# [[types]]
# schema = "UrlMap"
# include_fields = ["creationTimestamp", "defaultCustomErrorResponsePolicy", "defaultRouteAction", "defaultService", "defaultUrlRedirect", "description", "fingerprint", "headerAction", "hostRules", "id", "kind", "name", "pathMatchers", "region", "selfLink", "tests"]
#
#   creationTimestamp: string, readOnly
#   defaultCustomErrorResponsePolicy: $ref: CustomErrorResponsePolicy
#   defaultRouteAction: $ref: HttpRouteAction
#   defaultService: string
#   defaultUrlRedirect: $ref: HttpRedirectAction
#   description: string
#   fingerprint: string, format: byte
#   headerAction: $ref: HttpHeaderAction
#   hostRules: array<HostRule>
#   id: string, format: uint64
#   kind: string, readOnly
#   name: string
#   pathMatchers: array<PathMatcher>
#   region: string, readOnly
#   selfLink: string
#   tests: array<UrlMapTest>
#
# [types.field_overrides]
# name = { required = true }
# fingerprint = { format = "bytes" }

# --- UrlMapList (6 fields) ---
# Contains a list of UrlMap resources.
# [[types]]
# schema = "UrlMapList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<UrlMap>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- UrlMapReference (1 fields) ---
# [[types]]
# schema = "UrlMapReference"
# include_fields = ["urlMap"]
#
#   urlMap: string

# --- UrlMapTest (7 fields) ---
# Message for the expected URL mappings.
# [[types]]
# schema = "UrlMapTest"
# include_fields = ["description", "expectedOutputUrl", "expectedRedirectResponseCode", "headers", "host", "path", "service"]
#
#   description: string
#   expectedOutputUrl: string
#   expectedRedirectResponseCode: integer, format: int32
#   headers: array<UrlMapTestHeader>
#   host: string
#   path: string
#   service: string

# --- UrlMapTestHeader (2 fields) ---
# HTTP headers used in UrlMapTests.
# [[types]]
# schema = "UrlMapTestHeader"
# include_fields = ["name", "value"]
#
#   name: string
#   value: string
#
# [types.field_overrides]
# name = { required = true }

# --- UrlMapValidationResult (4 fields) ---
# Message representing the validation result for a UrlMap.
# [[types]]
# schema = "UrlMapValidationResult"
# include_fields = ["loadErrors", "loadSucceeded", "testFailures", "testPassed"]
#
#   loadErrors: array<string>
#   loadSucceeded: boolean
#   testFailures: array<TestFailure>
#   testPassed: boolean

# --- UrlMapsAggregatedList (7 fields) ---
# [[types]]
# schema = "UrlMapsAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, UrlMapsScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- UrlMapsScopedList (2 fields) ---
# [[types]]
# schema = "UrlMapsScopedList"
# include_fields = ["urlMaps", "warning"]
#
#   urlMaps: array<UrlMap>
#   warning: object

# --- UrlMapsValidateRequest (2 fields) ---
# [[types]]
# schema = "UrlMapsValidateRequest"
# include_fields = ["loadBalancingSchemes", "resource"]
#
#   loadBalancingSchemes: array<string>
#   resource: $ref: UrlMap

# --- UrlMapsValidateResponse (1 fields) ---
# [[types]]
# schema = "UrlMapsValidateResponse"
# include_fields = ["result"]
#
#   result: $ref: UrlMapValidationResult

# --- UrlRewrite (3 fields) ---
# The spec for modifying the path before sending the request to the matched backend service.
# [[types]]
# schema = "UrlRewrite"
# include_fields = ["hostRewrite", "pathPrefixRewrite", "pathTemplateRewrite"]
#
#   hostRewrite: string
#   pathPrefixRewrite: string
#   pathTemplateRewrite: string

# --- UsableSubnetwork (10 fields) ---
# Subnetwork which the current user has compute.subnetworks.use permission on.
# [[types]]
# schema = "UsableSubnetwork"
# include_fields = ["externalIpv6Prefix", "internalIpv6Prefix", "ipCidrRange", "ipv6AccessType", "network", "purpose", "role", "secondaryIpRanges", "stackType", "subnetwork"]
#
#   externalIpv6Prefix: string, readOnly
#   internalIpv6Prefix: string, readOnly
#   ipCidrRange: string
#   ipv6AccessType: string, enum: [EXTERNAL, INTERNAL]
#   network: string
#   purpose: string, enum: [GLOBAL_MANAGED_PROXY, INTERNAL_HTTPS_LOAD_BALANCER, PEER_MIGRATION, PRIVATE, ... +4]
#   role: string, enum: [ACTIVE, BACKUP]
#   secondaryIpRanges: array<UsableSubnetworkSecondaryRange>
#   stackType: string, enum: [IPV4_IPV6, IPV4_ONLY, IPV6_ONLY]
#   subnetwork: string
#
# [types.field_overrides]
# # role = { enum_type = "UsableSubnetworkRole" }
# # purpose = { enum_type = "UsableSubnetworkPurpose" }
# # stackType = { enum_type = "UsableSubnetworkStackType" }
# # ipv6AccessType = { enum_type = "UsableSubnetworkIpv6AccessType" }

# --- UsableSubnetworkSecondaryRange (2 fields) ---
# Secondary IP range of a usable subnetwork.
# [[types]]
# schema = "UsableSubnetworkSecondaryRange"
# include_fields = ["ipCidrRange", "rangeName"]
#
#   ipCidrRange: string
#   rangeName: string

# --- UsableSubnetworksAggregatedList (8 fields) ---
# [[types]]
# schema = "UsableSubnetworksAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "scopedWarnings", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: array<UsableSubnetwork>
#   kind: string, readOnly
#   nextPageToken: string
#   scopedWarnings: array<SubnetworksScopedWarning>, readOnly
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- UsageExportLocation (2 fields) ---
# The location in Cloud Storage and naming method of the daily usage report. Contains bucket_name and 
# [[types]]
# schema = "UsageExportLocation"
# include_fields = ["bucketName", "reportNamePrefix"]
#
#   bucketName: string
#   reportNamePrefix: string

# --- VmEndpointNatMappings (2 fields) ---
# Contain information of Nat mapping for a VM endpoint (i.e., NIC).
# [[types]]
# schema = "VmEndpointNatMappings"
# include_fields = ["instanceName", "interfaceNatMappings"]
#
#   instanceName: string, readOnly
#   interfaceNatMappings: array<VmEndpointNatMappingsInterfaceNatMappings>, readOnly

# --- VmEndpointNatMappingsInterfaceNatMappings (7 fields) ---
# Contain information of Nat mapping for an interface of this endpoint.
# [[types]]
# schema = "VmEndpointNatMappingsInterfaceNatMappings"
# include_fields = ["drainNatIpPortRanges", "natIpPortRanges", "numTotalDrainNatPorts", "numTotalNatPorts", "ruleMappings", "sourceAliasIpRange", "sourceVirtualIp"]
#
#   drainNatIpPortRanges: array<string>, readOnly
#   natIpPortRanges: array<string>, readOnly
#   numTotalDrainNatPorts: integer, format: int32, readOnly
#   numTotalNatPorts: integer, format: int32, readOnly
#   ruleMappings: array<VmEndpointNatMappingsInterfaceNatMappingsNatRuleMappings>, readOnly
#   sourceAliasIpRange: string, readOnly
#   sourceVirtualIp: string, readOnly

# --- VmEndpointNatMappingsInterfaceNatMappingsNatRuleMappings (5 fields) ---
# Contains information of NAT Mappings provided by a NAT Rule.
# [[types]]
# schema = "VmEndpointNatMappingsInterfaceNatMappingsNatRuleMappings"
# include_fields = ["drainNatIpPortRanges", "natIpPortRanges", "numTotalDrainNatPorts", "numTotalNatPorts", "ruleNumber"]
#
#   drainNatIpPortRanges: array<string>, readOnly
#   natIpPortRanges: array<string>, readOnly
#   numTotalDrainNatPorts: integer, format: int32, readOnly
#   numTotalNatPorts: integer, format: int32, readOnly
#   ruleNumber: integer, format: int32, readOnly

# --- VmEndpointNatMappingsList (6 fields) ---
# Contains a list of VmEndpointNatMappings.
# [[types]]
# schema = "VmEndpointNatMappingsList"
# include_fields = ["id", "kind", "nextPageToken", "result", "selfLink", "warning"]
#
#   id: string
#   kind: string, readOnly
#   nextPageToken: string
#   result: array<VmEndpointNatMappings>
#   selfLink: string, readOnly
#   warning: object

# --- VpnGateway (13 fields) ---
# Represents a HA VPN gateway. HA VPN is a high-availability (HA) Cloud VPN solution that lets you sec
# WARNING: format:"byte" fields: labelFingerprint
# [[types]]
# schema = "VpnGateway"
# include_fields = ["creationTimestamp", "description", "gatewayIpVersion", "id", "kind", "labelFingerprint", "labels", "name", "network", "region", "selfLink", "stackType", "vpnInterfaces"]
#
#   creationTimestamp: string, readOnly
#   description: string
#   gatewayIpVersion: string, enum: [IPV4, IPV6]
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   labelFingerprint: string, format: byte
#   labels: map<string, string>
#   name: string
#   network: string
#   region: string, readOnly
#   selfLink: string, readOnly
#   stackType: string, enum: [IPV4_IPV6, IPV4_ONLY, IPV6_ONLY]
#   vpnInterfaces: array<VpnGatewayVpnGatewayInterface>
#
# [types.field_overrides]
# name = { required = true }
# labelFingerprint = { format = "bytes" }
# # stackType = { enum_type = "VpnGatewayStackType" }
# # gatewayIpVersion = { enum_type = "VpnGatewayGatewayIpVersion" }

# --- VpnGatewayAggregatedList (7 fields) ---
# [[types]]
# schema = "VpnGatewayAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, VpnGatewaysScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- VpnGatewayList (6 fields) ---
# Contains a list of VpnGateway resources.
# [[types]]
# schema = "VpnGatewayList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<VpnGateway>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- VpnGatewayStatus (1 fields) ---
# [[types]]
# schema = "VpnGatewayStatus"
# include_fields = ["vpnConnections"]
#
#   vpnConnections: array<VpnGatewayStatusVpnConnection>, readOnly

# --- VpnGatewayStatusHighAvailabilityRequirementState (2 fields) ---
# Describes the high availability requirement state for the VPN connection between this Cloud VPN gate
# [[types]]
# schema = "VpnGatewayStatusHighAvailabilityRequirementState"
# include_fields = ["state", "unsatisfiedReason"]
#
#   state: string, enum: [CONNECTION_REDUNDANCY_MET, CONNECTION_REDUNDANCY_NOT_MET]
#   unsatisfiedReason: string, enum: [INCOMPLETE_TUNNELS_COVERAGE]
#
# [types.field_overrides]
# # state = { enum_type = "VpnGatewayStatusHighAvailabilityRequirementStateState" }
# # unsatisfiedReason = { enum_type = "VpnGatewayStatusHighAvailabilityRequirementStateUnsatisfiedReason" }

# --- VpnGatewayStatusTunnel (3 fields) ---
# Contains some information about a VPN tunnel.
# [[types]]
# schema = "VpnGatewayStatusTunnel"
# include_fields = ["localGatewayInterface", "peerGatewayInterface", "tunnelUrl"]
#
#   localGatewayInterface: integer, format: uint32, readOnly
#   peerGatewayInterface: integer, format: uint32, readOnly
#   tunnelUrl: string, readOnly

# --- VpnGatewayStatusVpnConnection (4 fields) ---
# A VPN connection contains all VPN tunnels connected from this VpnGateway to the same peer gateway. T
# [[types]]
# schema = "VpnGatewayStatusVpnConnection"
# include_fields = ["peerExternalGateway", "peerGcpGateway", "state", "tunnels"]
#
#   peerExternalGateway: string, readOnly
#   peerGcpGateway: string, readOnly
#   state: $ref: VpnGatewayStatusHighAvailabilityRequirementState
#   tunnels: array<VpnGatewayStatusTunnel>

# --- VpnGatewayVpnGatewayInterface (4 fields) ---
# A VPN gateway interface.
# [[types]]
# schema = "VpnGatewayVpnGatewayInterface"
# include_fields = ["id", "interconnectAttachment", "ipAddress", "ipv6Address"]
#
#   id: integer, format: uint32, readOnly
#   interconnectAttachment: string
#   ipAddress: string, readOnly
#   ipv6Address: string, readOnly

# --- VpnGatewaysGetStatusResponse (1 fields) ---
# [[types]]
# schema = "VpnGatewaysGetStatusResponse"
# include_fields = ["result"]
#
#   result: $ref: VpnGatewayStatus

# --- VpnGatewaysScopedList (2 fields) ---
# [[types]]
# schema = "VpnGatewaysScopedList"
# include_fields = ["vpnGateways", "warning"]
#
#   vpnGateways: array<VpnGateway>
#   warning: object

# --- VpnTunnel (25 fields) ---
# Represents a Cloud VPN Tunnel resource. For more information about VPN, read the the Cloud VPN Overv
# WARNING: format:"byte" fields: labelFingerprint
# [[types]]
# schema = "VpnTunnel"
# include_fields = ["cipherSuite", "creationTimestamp", "description", "detailedStatus", "id", "ikeVersion", "kind", "labelFingerprint", "labels", "localTrafficSelector", "name", "peerExternalGateway", "peerExternalGatewayInterface", "peerGcpGateway", "peerIp", "region", "remoteTrafficSelector", "router", "selfLink", "sharedSecret", "sharedSecretHash", "status", "targetVpnGateway", "vpnGateway", "vpnGatewayInterface"]
#
#   cipherSuite: $ref: VpnTunnelCipherSuite
#   creationTimestamp: string, readOnly
#   description: string
#   detailedStatus: string
#   id: string, format: uint64
#   ikeVersion: integer, format: int32
#   kind: string, readOnly
#   labelFingerprint: string, format: byte
#   labels: map<string, string>
#   localTrafficSelector: array<string>
#   name: string
#   peerExternalGateway: string
#   peerExternalGatewayInterface: integer, format: int32
#   peerGcpGateway: string
#   peerIp: string
#   region: string
#   remoteTrafficSelector: array<string>
#   router: string
#   selfLink: string
#   sharedSecret: string
#   sharedSecretHash: string
#   status: string, enum: [ALLOCATING_RESOURCES, AUTHORIZATION_ERROR, DEPROVISIONING, ESTABLISHED, ... +9]
#   targetVpnGateway: string
#   vpnGateway: string
#   vpnGatewayInterface: integer, format: int32
#
# [types.field_overrides]
# name = { required = true }
# labelFingerprint = { format = "bytes" }
# # status = { enum_type = "VpnTunnelStatus" }

# --- VpnTunnelAggregatedList (7 fields) ---
# [[types]]
# schema = "VpnTunnelAggregatedList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   id: string
#   items: map<string, VpnTunnelsScopedList>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   unreachables: array<string>, readOnly
#   warning: object

# --- VpnTunnelCipherSuite (2 fields) ---
# [[types]]
# schema = "VpnTunnelCipherSuite"
# include_fields = ["phase1", "phase2"]
#
#   phase1: $ref: VpnTunnelPhase1Algorithms
#   phase2: $ref: VpnTunnelPhase2Algorithms

# --- VpnTunnelList (6 fields) ---
# Contains a list of VpnTunnel resources.
# [[types]]
# schema = "VpnTunnelList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<VpnTunnel>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- VpnTunnelPhase1Algorithms (4 fields) ---
# [[types]]
# schema = "VpnTunnelPhase1Algorithms"
# include_fields = ["dh", "encryption", "integrity", "prf"]
#
#   dh: array<string>
#   encryption: array<string>
#   integrity: array<string>
#   prf: array<string>

# --- VpnTunnelPhase2Algorithms (3 fields) ---
# [[types]]
# schema = "VpnTunnelPhase2Algorithms"
# include_fields = ["encryption", "integrity", "pfs"]
#
#   encryption: array<string>
#   integrity: array<string>
#   pfs: array<string>

# --- VpnTunnelsScopedList (2 fields) ---
# [[types]]
# schema = "VpnTunnelsScopedList"
# include_fields = ["vpnTunnels", "warning"]
#
#   vpnTunnels: array<VpnTunnel>
#   warning: object

# --- WafExpressionSet (3 fields) ---
# [[types]]
# schema = "WafExpressionSet"
# include_fields = ["aliases", "expressions", "id"]
#
#   aliases: array<string>
#   expressions: array<WafExpressionSetExpression>
#   id: string

# --- WafExpressionSetExpression (2 fields) ---
# [[types]]
# schema = "WafExpressionSetExpression"
# include_fields = ["id", "sensitivity"]
#
#   id: string
#   sensitivity: integer, format: int32

# --- WeightedBackendService (3 fields) ---
# In contrast to a single BackendService in HttpRouteAction to which all matching traffic is directed 
# [[types]]
# schema = "WeightedBackendService"
# include_fields = ["backendService", "headerAction", "weight"]
#
#   backendService: string
#   headerAction: $ref: HttpHeaderAction
#   weight: integer, format: uint32

# --- Wire (4 fields) ---
# A pseudowire that connects two Interconnect connections.
# [[types]]
# schema = "Wire"
# include_fields = ["adminEnabled", "endpoints", "label", "wireProperties"]
#
#   adminEnabled: boolean, readOnly
#   endpoints: array<WireEndpoint>, readOnly
#   label: string, readOnly
#   wireProperties: $ref: WireProperties, readOnly

# --- WireEndpoint (2 fields) ---
# Wire endpoints are specific Interconnect connections.
# [[types]]
# schema = "WireEndpoint"
# include_fields = ["interconnect", "vlanTag"]
#
#   interconnect: string, readOnly
#   vlanTag: integer, format: int32, readOnly

# --- WireGroup (12 fields) ---
# A resource that represents a group of redundant wires.
# [[types]]
# schema = "WireGroup"
# include_fields = ["adminEnabled", "creationTimestamp", "description", "endpoints", "id", "kind", "name", "reconciling", "selfLink", "topology", "wireProperties", "wires"]
#
#   adminEnabled: boolean
#   creationTimestamp: string, readOnly
#   description: string
#   endpoints: map<string, WireGroupEndpoint>
#   id: string, format: uint64, readOnly
#   kind: string, readOnly
#   name: string
#   reconciling: boolean, readOnly
#   selfLink: string, readOnly
#   topology: $ref: WireGroupTopology, readOnly
#   wireProperties: $ref: WireProperties
#   wires: array<Wire>, readOnly
#
# [types.field_overrides]
# name = { required = true }

# --- WireGroupEndpoint (1 fields) ---
# A logical endpoint for the wire group. An endpoint represents a metro that contains redundant Interc
# [[types]]
# schema = "WireGroupEndpoint"
# include_fields = ["interconnects"]
#
#   interconnects: map<string, WireGroupEndpointInterconnect>

# --- WireGroupEndpointInterconnect (2 fields) ---
# The redundant Interconnect connections for this endpoint.
# [[types]]
# schema = "WireGroupEndpointInterconnect"
# include_fields = ["interconnect", "vlanTags"]
#
#   interconnect: string
#   vlanTags: array<integer>

# --- WireGroupList (8 fields) ---
# Response for the list request.
# [[types]]
# schema = "WireGroupList"
# include_fields = ["etag", "id", "items", "kind", "nextPageToken", "selfLink", "unreachables", "warning"]
#
#   etag: string
#   id: string
#   items: array<WireGroup>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string
#   unreachables: array<string>, readOnly
#   warning: object

# --- WireGroupTopology (1 fields) ---
# Topology details for the wire group.
# [[types]]
# schema = "WireGroupTopology"
# include_fields = ["endpoints"]
#
#   endpoints: array<WireGroupTopologyEndpoint>, readOnly

# --- WireGroupTopologyEndpoint (2 fields) ---
# Topology details for a single wire group endpoint.
# [[types]]
# schema = "WireGroupTopologyEndpoint"
# include_fields = ["city", "label"]
#
#   city: string, readOnly
#   label: string, readOnly

# --- WireProperties (3 fields) ---
# The properties of a wire.
# [[types]]
# schema = "WireProperties"
# include_fields = ["bandwidthAllocation", "bandwidthUnmetered", "faultResponse"]
#
#   bandwidthAllocation: string, enum: [ALLOCATE_PER_WIRE, SHARED_WITH_WIRE_GROUP]
#   bandwidthUnmetered: string, format: int64
#   faultResponse: string, enum: [DISABLE_PORT, NONE]
#
# [types.field_overrides]
# # bandwidthAllocation = { enum_type = "WirePropertiesBandwidthAllocation" }
# # faultResponse = { enum_type = "WirePropertiesFaultResponse" }

# --- XpnHostList (6 fields) ---
# [[types]]
# schema = "XpnHostList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<Project>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- XpnResourceId (2 fields) ---
# Service resource (a.k.a service project) ID.
# WARNING: reserved words: type
# [[types]]
# schema = "XpnResourceId"
# include_fields = ["id", "type"]
#
#   id: string
#   type: string, enum: [PROJECT, XPN_RESOURCE_TYPE_UNSPECIFIED], RESERVED_WORD
#
# [types.field_overrides]
# type = { rust_name = "type_value", serde_rename = "type" }
# # type = { enum_type = "XpnResourceIdType" }

# --- Zone (11 fields) ---
# Represents a Zone resource. A zone is a deployment area. These deployment areas are subsets of a reg
# [[types]]
# schema = "Zone"
# include_fields = ["availableCpuPlatforms", "creationTimestamp", "deprecated", "description", "id", "kind", "name", "region", "selfLink", "status", "supportsPzs"]
#
#   availableCpuPlatforms: array<string>
#   creationTimestamp: string
#   deprecated: $ref: DeprecationStatus
#   description: string
#   id: string, format: uint64
#   kind: string, readOnly
#   name: string
#   region: string
#   selfLink: string
#   status: string, enum: [DOWN, UP]
#   supportsPzs: boolean, readOnly
#
# [types.field_overrides]
# name = { required = true }
# # status = { enum_type = "ZoneStatus" }

# --- ZoneList (6 fields) ---
# Contains a list of zone resources.
# [[types]]
# schema = "ZoneList"
# include_fields = ["id", "items", "kind", "nextPageToken", "selfLink", "warning"]
#
#   id: string
#   items: array<Zone>
#   kind: string, readOnly
#   nextPageToken: string
#   selfLink: string, readOnly
#   warning: object

# --- ZoneSetLabelsRequest (2 fields) ---
# WARNING: format:"byte" fields: labelFingerprint
# [[types]]
# schema = "ZoneSetLabelsRequest"
# include_fields = ["labelFingerprint", "labels"]
#
#   labelFingerprint: string, format: byte
#   labels: map<string, string>
#
# [types.field_overrides]
# labelFingerprint = { format = "bytes" }

# --- ZoneSetNestedPolicyRequest (3 fields) ---
# WARNING: format:"byte" fields: etag
# [[types]]
# schema = "ZoneSetNestedPolicyRequest"
# include_fields = ["bindings", "etag", "policy"]
#
#   bindings: array<Binding>
#   etag: string, format: byte
#   policy: $ref: Policy
#
# [types.field_overrides]
# etag = { format = "bytes" }

# --- ZoneSetPolicyRequest (3 fields) ---
# WARNING: format:"byte" fields: etag
# [[types]]
# schema = "ZoneSetPolicyRequest"
# include_fields = ["bindings", "etag", "policy"]
#
#   bindings: array<Binding>
#   etag: string, format: byte
#   policy: $ref: Policy
#
# [types.field_overrides]
# etag = { format = "bytes" }

# ======================================================================
# OPERATIONS (901 total)
# ======================================================================

# --- instanceGroups.delete ---
# DELETE projects/{project}/zones/{zone}/instanceGroups/{instanceGroup}
# Deletes the specified instance group. The instances in the group are not deleted. Note that instance
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroups"
# discovery_method = "delete"
# rust_name = "delete_instance_group"
# is_lro = true
# query_params = ["requestId"]

# --- instanceGroups.testIamPermissions ---
# POST projects/{project}/zones/{zone}/instanceGroups/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "instanceGroups"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_instance_group"

# --- instanceGroups.get ---
# GET projects/{project}/zones/{zone}/instanceGroups/{instanceGroup}
# Returns the specified zonal instance group. Get a list of available zonal instance groups by making 
# Response: InstanceGroup
# [[operations]]
# discovery_resource = "instanceGroups"
# discovery_method = "get"
# rust_name = "get_instance_group"

# --- instanceGroups.listInstances ---
# POST projects/{project}/zones/{zone}/instanceGroups/{instanceGroup}/listInstances
# Lists the instances in the specified instance group. The orderBy query parameter is not supported. T
# Request: InstanceGroupsListInstancesRequest
# Response: InstanceGroupsListInstances
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "instanceGroups"
# discovery_method = "listInstances"
# rust_name = "listInstances_instance_group"
# list_response = { type_name = "InstanceGroupsListInstances", items_field = "items", item_type = "InstanceWithNamedPorts" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- instanceGroups.insert ---
# POST projects/{project}/zones/{zone}/instanceGroups
# Creates an instance group in the specified project using the parameters that are included in the req
# Request: InstanceGroup
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroups"
# discovery_method = "insert"
# rust_name = "create_instance_group"
# is_lro = true
# query_params = ["requestId"]

# --- instanceGroups.list ---
# GET projects/{project}/zones/{zone}/instanceGroups
# Retrieves the list of zonal instance group resources contained within the specified zone. For manage
# Response: InstanceGroupList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "instanceGroups"
# discovery_method = "list"
# rust_name = "list_instance_groups"
# list_response = { type_name = "InstanceGroupList", items_field = "items", item_type = "InstanceGroup" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- instanceGroups.removeInstances ---
# POST projects/{project}/zones/{zone}/instanceGroups/{instanceGroup}/removeInstances
# Removes one or more instances from the specified instance group, but does not delete those instances
# Request: InstanceGroupsRemoveInstancesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroups"
# discovery_method = "removeInstances"
# rust_name = "removeInstances_instance_group"
# is_lro = true
# query_params = ["requestId"]

# --- instanceGroups.aggregatedList ---
# GET projects/{project}/aggregated/instanceGroups
# Retrieves the list of instance groups and sorts them by zone. To prevent failure, Google recommends 
# Response: InstanceGroupAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "instanceGroups"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_instance_group"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- instanceGroups.setNamedPorts ---
# POST projects/{project}/zones/{zone}/instanceGroups/{instanceGroup}/setNamedPorts
# Sets the named ports for the specified instance group.
# Request: InstanceGroupsSetNamedPortsRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroups"
# discovery_method = "setNamedPorts"
# rust_name = "setNamedPorts_instance_group"
# is_lro = true
# query_params = ["requestId"]

# --- instanceGroups.addInstances ---
# POST projects/{project}/zones/{zone}/instanceGroups/{instanceGroup}/addInstances
# Adds a list of instances to the specified instance group. All of the instances in the instance group
# Request: InstanceGroupsAddInstancesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroups"
# discovery_method = "addInstances"
# rust_name = "addInstances_instance_group"
# is_lro = true
# query_params = ["requestId"]

# --- targetInstances.aggregatedList ---
# GET projects/{project}/aggregated/targetInstances
# Retrieves an aggregated list of target instances. To prevent failure, Google recommends that you set
# Response: TargetInstanceAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "targetInstances"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_target_instance"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- targetInstances.testIamPermissions ---
# POST projects/{project}/zones/{zone}/targetInstances/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "targetInstances"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_target_instance"

# --- targetInstances.delete ---
# DELETE projects/{project}/zones/{zone}/targetInstances/{targetInstance}
# Deletes the specified TargetInstance resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetInstances"
# discovery_method = "delete"
# rust_name = "delete_target_instance"
# is_lro = true
# query_params = ["requestId"]

# --- targetInstances.setSecurityPolicy ---
# POST projects/{project}/zones/{zone}/targetInstances/{targetInstance}/setSecurityPolicy
# Sets the Google Cloud Armor security policy for the specified target instance. For more information,
# Request: SecurityPolicyReference
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetInstances"
# discovery_method = "setSecurityPolicy"
# rust_name = "setSecurityPolicy_target_instance"
# is_lro = true
# query_params = ["requestId"]

# --- targetInstances.get ---
# GET projects/{project}/zones/{zone}/targetInstances/{targetInstance}
# Returns the specified TargetInstance resource.
# Response: TargetInstance
# [[operations]]
# discovery_resource = "targetInstances"
# discovery_method = "get"
# rust_name = "get_target_instance"

# --- targetInstances.list ---
# GET projects/{project}/zones/{zone}/targetInstances
# Retrieves a list of TargetInstance resources available to the specified project and zone.
# Response: TargetInstanceList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "targetInstances"
# discovery_method = "list"
# rust_name = "list_target_instances"
# list_response = { type_name = "TargetInstanceList", items_field = "items", item_type = "TargetInstance" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- targetInstances.insert ---
# POST projects/{project}/zones/{zone}/targetInstances
# Creates a TargetInstance resource in the specified project and zone using the data included in the r
# Request: TargetInstance
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetInstances"
# discovery_method = "insert"
# rust_name = "create_target_instance"
# is_lro = true
# query_params = ["requestId"]

# --- reservations.setIamPolicy ---
# POST projects/{project}/zones/{zone}/reservations/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: ZoneSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "reservations"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_reservation"

# --- reservations.get ---
# GET projects/{project}/zones/{zone}/reservations/{reservation}
# Retrieves information about the specified reservation.
# Response: Reservation
# [[operations]]
# discovery_resource = "reservations"
# discovery_method = "get"
# rust_name = "get_reservation"

# --- reservations.insert ---
# POST projects/{project}/zones/{zone}/reservations
# Creates a new reservation. For more information, readReserving zonal resources.
# Request: Reservation
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "reservations"
# discovery_method = "insert"
# rust_name = "create_reservation"
# is_lro = true
# query_params = ["requestId"]

# --- reservations.resize ---
# POST projects/{project}/zones/{zone}/reservations/{reservation}/resize
# Resizes the reservation (applicable to standalone reservations only). For more information, readModi
# Request: ReservationsResizeRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "reservations"
# discovery_method = "resize"
# rust_name = "resize_reservation"
# is_lro = true
# query_params = ["requestId"]

# --- reservations.testIamPermissions ---
# POST projects/{project}/zones/{zone}/reservations/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "reservations"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_reservation"

# --- reservations.delete ---
# DELETE projects/{project}/zones/{zone}/reservations/{reservation}
# Deletes the specified reservation.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "reservations"
# discovery_method = "delete"
# rust_name = "delete_reservation"
# is_lro = true
# query_params = ["requestId"]

# --- reservations.getIamPolicy ---
# GET projects/{project}/zones/{zone}/reservations/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "reservations"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_reservation"
# query_params = ["optionsRequestedPolicyVersion"]

# --- reservations.list ---
# GET projects/{project}/zones/{zone}/reservations
# A list of all the reservations that have been configured for the specified project in specified zone
# Response: ReservationList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "reservations"
# discovery_method = "list"
# rust_name = "list_reservations"
# list_response = { type_name = "ReservationList", items_field = "items", item_type = "Reservation" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- reservations.performMaintenance ---
# POST projects/{project}/zones/{zone}/reservations/{reservation}/performMaintenance
# Perform maintenance on an extended reservation
# Request: ReservationsPerformMaintenanceRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "reservations"
# discovery_method = "performMaintenance"
# rust_name = "performMaintenance_reservation"
# is_lro = true
# query_params = ["requestId"]

# --- reservations.update ---
# PATCH projects/{project}/zones/{zone}/reservations/{reservation}
# Update share settings of the reservation.
# Request: Reservation
# Response: Operation
# Query params: paths (repeated), requestId, updateMask
# [[operations]]
# discovery_resource = "reservations"
# discovery_method = "update"
# rust_name = "update_reservation"
# is_lro = true
# query_params = ["paths", "requestId", "updateMask"]

# --- reservations.aggregatedList ---
# GET projects/{project}/aggregated/reservations
# Retrieves an aggregated list of reservations. To prevent failure, it is recommended that you set the
# Response: ReservationAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "reservations"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_reservation"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- packetMirrorings.list ---
# GET projects/{project}/regions/{region}/packetMirrorings
# Retrieves a list of PacketMirroring resources available to the specified project and region.
# Response: PacketMirroringList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "packetMirrorings"
# discovery_method = "list"
# rust_name = "list_packet_mirrorings"
# list_response = { type_name = "PacketMirroringList", items_field = "items", item_type = "PacketMirroring" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- packetMirrorings.delete ---
# DELETE projects/{project}/regions/{region}/packetMirrorings/{packetMirroring}
# Deletes the specified PacketMirroring resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "packetMirrorings"
# discovery_method = "delete"
# rust_name = "delete_packet_mirroring"
# is_lro = true
# query_params = ["requestId"]

# --- packetMirrorings.testIamPermissions ---
# POST projects/{project}/regions/{region}/packetMirrorings/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "packetMirrorings"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_packet_mirroring"

# --- packetMirrorings.patch ---
# PATCH projects/{project}/regions/{region}/packetMirrorings/{packetMirroring}
# Patches the specified PacketMirroring resource with the data included in the request. This method su
# Request: PacketMirroring
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "packetMirrorings"
# discovery_method = "patch"
# rust_name = "update_packet_mirroring"
# is_lro = true
# query_params = ["requestId"]

# --- packetMirrorings.insert ---
# POST projects/{project}/regions/{region}/packetMirrorings
# Creates a PacketMirroring resource in the specified project and region using the data included in th
# Request: PacketMirroring
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "packetMirrorings"
# discovery_method = "insert"
# rust_name = "create_packet_mirroring"
# is_lro = true
# query_params = ["requestId"]

# --- packetMirrorings.get ---
# GET projects/{project}/regions/{region}/packetMirrorings/{packetMirroring}
# Returns the specified PacketMirroring resource.
# Response: PacketMirroring
# [[operations]]
# discovery_resource = "packetMirrorings"
# discovery_method = "get"
# rust_name = "get_packet_mirroring"

# --- packetMirrorings.aggregatedList ---
# GET projects/{project}/aggregated/packetMirrorings
# Retrieves an aggregated list of packetMirrorings. To prevent failure, Google recommends that you set
# Response: PacketMirroringAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "packetMirrorings"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_packet_mirroring"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- regionDiskTypes.get ---
# GET projects/{project}/regions/{region}/diskTypes/{diskType}
# Returns the specified regional disk type.
# Response: DiskType
# [[operations]]
# discovery_resource = "regionDiskTypes"
# discovery_method = "get"
# rust_name = "get_region_disk_type"

# --- regionDiskTypes.list ---
# GET projects/{project}/regions/{region}/diskTypes
# Retrieves a list of regional disk types available to the specified project.
# Response: RegionDiskTypeList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionDiskTypes"
# discovery_method = "list"
# rust_name = "list_region_disk_types"
# list_response = { type_name = "RegionDiskTypeList", items_field = "items", item_type = "DiskType" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionInstanceTemplates.get ---
# GET projects/{project}/regions/{region}/instanceTemplates/{instanceTemplate}
# Returns the specified instance template.
# Response: InstanceTemplate
# [[operations]]
# discovery_resource = "regionInstanceTemplates"
# discovery_method = "get"
# rust_name = "get_region_instance_template"

# --- regionInstanceTemplates.list ---
# GET projects/{project}/regions/{region}/instanceTemplates
# Retrieves a list of instance templates that are contained within the specified project and region.
# Response: InstanceTemplateList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionInstanceTemplates"
# discovery_method = "list"
# rust_name = "list_region_instance_templates"
# list_response = { type_name = "InstanceTemplateList", items_field = "items", item_type = "InstanceTemplate" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionInstanceTemplates.insert ---
# POST projects/{project}/regions/{region}/instanceTemplates
# Creates an instance template in the specified project and region using the global instance template 
# Request: InstanceTemplate
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionInstanceTemplates"
# discovery_method = "insert"
# rust_name = "create_region_instance_template"
# is_lro = true
# query_params = ["requestId"]

# --- regionInstanceTemplates.delete ---
# DELETE projects/{project}/regions/{region}/instanceTemplates/{instanceTemplate}
# Deletes the specified instance template. Deleting an instance template is permanent and cannot be un
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionInstanceTemplates"
# discovery_method = "delete"
# rust_name = "delete_region_instance_template"
# is_lro = true
# query_params = ["requestId"]

# --- regionTargetTcpProxies.get ---
# GET projects/{project}/regions/{region}/targetTcpProxies/{targetTcpProxy}
# Returns the specified TargetTcpProxy resource.
# Response: TargetTcpProxy
# [[operations]]
# discovery_resource = "regionTargetTcpProxies"
# discovery_method = "get"
# rust_name = "get_region_target_tcp_proxie"

# --- regionTargetTcpProxies.delete ---
# DELETE projects/{project}/regions/{region}/targetTcpProxies/{targetTcpProxy}
# Deletes the specified TargetTcpProxy resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionTargetTcpProxies"
# discovery_method = "delete"
# rust_name = "delete_region_target_tcp_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- regionTargetTcpProxies.list ---
# GET projects/{project}/regions/{region}/targetTcpProxies
# Retrieves a list of TargetTcpProxy resources available to the specified project in a given region.
# Response: TargetTcpProxyList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionTargetTcpProxies"
# discovery_method = "list"
# rust_name = "list_region_target_tcp_proxies"
# list_response = { type_name = "TargetTcpProxyList", items_field = "items", item_type = "TargetTcpProxy" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionTargetTcpProxies.insert ---
# POST projects/{project}/regions/{region}/targetTcpProxies
# Creates a TargetTcpProxy resource in the specified project and region using the data included in the
# Request: TargetTcpProxy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionTargetTcpProxies"
# discovery_method = "insert"
# rust_name = "create_region_target_tcp_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- vpnGateways.setLabels ---
# POST projects/{project}/regions/{region}/vpnGateways/{resource}/setLabels
# Sets the labels on a VpnGateway. To learn more about labels, read theLabeling Resources documentatio
# Request: RegionSetLabelsRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "vpnGateways"
# discovery_method = "setLabels"
# rust_name = "setLabels_vpn_gateway"
# is_lro = true
# query_params = ["requestId"]

# --- vpnGateways.get ---
# GET projects/{project}/regions/{region}/vpnGateways/{vpnGateway}
# Returns the specified VPN gateway.
# Response: VpnGateway
# [[operations]]
# discovery_resource = "vpnGateways"
# discovery_method = "get"
# rust_name = "get_vpn_gateway"

# --- vpnGateways.aggregatedList ---
# GET projects/{project}/aggregated/vpnGateways
# Retrieves an aggregated list of VPN gateways. To prevent failure, Google recommends that you set the
# Response: VpnGatewayAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "vpnGateways"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_vpn_gateway"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- vpnGateways.getStatus ---
# GET projects/{project}/regions/{region}/vpnGateways/{vpnGateway}/getStatus
# Returns the status for the specified VPN gateway.
# Response: VpnGatewaysGetStatusResponse
# [[operations]]
# discovery_resource = "vpnGateways"
# discovery_method = "getStatus"
# rust_name = "getStatus_vpn_gateway"

# --- vpnGateways.testIamPermissions ---
# POST projects/{project}/regions/{region}/vpnGateways/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "vpnGateways"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_vpn_gateway"

# --- vpnGateways.insert ---
# POST projects/{project}/regions/{region}/vpnGateways
# Creates a VPN gateway in the specified project and region using the data included in the request.
# Request: VpnGateway
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "vpnGateways"
# discovery_method = "insert"
# rust_name = "create_vpn_gateway"
# is_lro = true
# query_params = ["requestId"]

# --- vpnGateways.list ---
# GET projects/{project}/regions/{region}/vpnGateways
# Retrieves a list of VPN gateways available to the specified project and region.
# Response: VpnGatewayList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "vpnGateways"
# discovery_method = "list"
# rust_name = "list_vpn_gateways"
# list_response = { type_name = "VpnGatewayList", items_field = "items", item_type = "VpnGateway" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- vpnGateways.delete ---
# DELETE projects/{project}/regions/{region}/vpnGateways/{vpnGateway}
# Deletes the specified VPN gateway.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "vpnGateways"
# discovery_method = "delete"
# rust_name = "delete_vpn_gateway"
# is_lro = true
# query_params = ["requestId"]

# --- regionOperations.get ---
# GET projects/{project}/regions/{region}/operations/{operation}
# Retrieves the specified region-specific Operations resource.
# Response: Operation
# [[operations]]
# discovery_resource = "regionOperations"
# discovery_method = "get"
# rust_name = "get_region_operation"
# is_lro = true

# --- regionOperations.delete ---
# DELETE projects/{project}/regions/{region}/operations/{operation}
# Deletes the specified region-specific Operations resource.
# [[operations]]
# discovery_resource = "regionOperations"
# discovery_method = "delete"
# rust_name = "delete_region_operation"

# --- regionOperations.list ---
# GET projects/{project}/regions/{region}/operations
# Retrieves a list of Operation resources contained within the specified region.
# Response: OperationList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionOperations"
# discovery_method = "list"
# rust_name = "list_region_operations"
# list_response = { type_name = "OperationList", items_field = "items", item_type = "Operation" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionOperations.wait ---
# POST projects/{project}/regions/{region}/operations/{operation}/wait
# Waits for the specified Operation resource to return as `DONE` or for the request to approach the 2 
# Response: Operation
# [[operations]]
# discovery_resource = "regionOperations"
# discovery_method = "wait"
# rust_name = "wait_region_operation"
# is_lro = true

# --- regionInstanceGroupManagers.list ---
# GET projects/{project}/regions/{region}/instanceGroupManagers
# Retrieves the list of managed instance groups that are contained within the specified region.
# Response: RegionInstanceGroupManagerList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "list"
# rust_name = "list_region_instance_group_managers"
# list_response = { type_name = "RegionInstanceGroupManagerList", items_field = "items", item_type = "InstanceGroupManager" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionInstanceGroupManagers.get ---
# GET projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}
# Returns all of the details about the specified managed instance group.
# Response: InstanceGroupManager
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "get"
# rust_name = "get_region_instance_group_manager"

# --- regionInstanceGroupManagers.deleteInstances ---
# POST projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/deleteInstances
# Flags the specified instances in the managed instance group to be immediately deleted. The instances
# Request: RegionInstanceGroupManagersDeleteInstancesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "deleteInstances"
# rust_name = "deleteInstances_region_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- regionInstanceGroupManagers.listErrors ---
# GET projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/listErrors
# Lists all errors thrown by actions on instances for a given regional managed instance group. The fil
# Response: RegionInstanceGroupManagersListErrorsResponse
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "listErrors"
# rust_name = "listErrors_region_instance_group_manager"
# list_response = { type_name = "RegionInstanceGroupManagersListErrorsResponse", items_field = "items", item_type = "InstanceManagedByIgmError" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionInstanceGroupManagers.delete ---
# DELETE projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}
# Deletes the specified managed instance group and all of the instances in that group.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "delete"
# rust_name = "delete_region_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- regionInstanceGroupManagers.createInstances ---
# POST projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/createInstances
# Creates instances with per-instance configurations in this regional managed instance group. Instance
# Request: RegionInstanceGroupManagersCreateInstancesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "createInstances"
# rust_name = "createInstances_region_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- regionInstanceGroupManagers.patch ---
# PATCH projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}
# Updates a managed instance group using the information that you specify in the request. This operati
# Request: InstanceGroupManager
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "patch"
# rust_name = "update_region_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- regionInstanceGroupManagers.patchPerInstanceConfigs ---
# POST projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/patchPerInstanceConfigs
# Inserts or patches per-instance configurations for the managed instance group. perInstanceConfig.nam
# Request: RegionInstanceGroupManagerPatchInstanceConfigReq
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "patchPerInstanceConfigs"
# rust_name = "patchPerInstanceConfigs_region_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- regionInstanceGroupManagers.listManagedInstances ---
# POST projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/listManagedInstances
# Lists the instances in the managed instance group and instances that are scheduled to be created. Th
# Response: RegionInstanceGroupManagersListInstancesResponse
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "listManagedInstances"
# rust_name = "listManagedInstances_region_instance_group_manager"
# list_response = { type_name = "RegionInstanceGroupManagersListInstancesResponse", items_field = "managedInstances", item_type = "ManagedInstance" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionInstanceGroupManagers.listPerInstanceConfigs ---
# POST projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/listPerInstanceConfigs
# Lists all of the per-instance configurations defined for the managed instance group. The orderBy que
# Response: RegionInstanceGroupManagersListInstanceConfigsResp
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "listPerInstanceConfigs"
# rust_name = "listPerInstanceConfigs_region_instance_group_manager"
# list_response = { type_name = "RegionInstanceGroupManagersListInstanceConfigsResp", items_field = "items", item_type = "PerInstanceConfig" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionInstanceGroupManagers.insert ---
# POST projects/{project}/regions/{region}/instanceGroupManagers
# Creates a managed instance group using the information that you specify in the request. After the gr
# Request: InstanceGroupManager
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "insert"
# rust_name = "create_region_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- regionInstanceGroupManagers.recreateInstances ---
# POST projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/recreateInstances
# Flags the specified VM instances in the managed instance group to be immediately recreated. Each ins
# Request: RegionInstanceGroupManagersRecreateRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "recreateInstances"
# rust_name = "recreateInstances_region_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- regionInstanceGroupManagers.abandonInstances ---
# POST projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/abandonInstances
# Flags the specified instances to be immediately removed from the managed instance group. Abandoning 
# Request: RegionInstanceGroupManagersAbandonInstancesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "abandonInstances"
# rust_name = "abandonInstances_region_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- regionInstanceGroupManagers.resize ---
# POST projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/resize
# Changes the intended size of the managed instance group. If you increase the size, the group creates
# Response: Operation
# Query params: requestId, size
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "resize"
# rust_name = "resize_region_instance_group_manager"
# is_lro = true
# query_params = ["requestId", "size"]

# --- regionInstanceGroupManagers.suspendInstances ---
# POST projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/suspendInstances
# Flags the specified instances in the managed instance group to be immediately suspended. You can onl
# Request: RegionInstanceGroupManagersSuspendInstancesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "suspendInstances"
# rust_name = "suspendInstances_region_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- regionInstanceGroupManagers.resumeInstances ---
# POST projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/resumeInstances
# Flags the specified instances in the managed instance group to be resumed. This method increases the
# Request: RegionInstanceGroupManagersResumeInstancesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "resumeInstances"
# rust_name = "resumeInstances_region_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- regionInstanceGroupManagers.applyUpdatesToInstances ---
# POST projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/applyUpdatesToInstances
# Apply updates to selected instances the managed instance group.
# Request: RegionInstanceGroupManagersApplyUpdatesRequest
# Response: Operation
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "applyUpdatesToInstances"
# rust_name = "applyUpdatesToInstances_region_instance_group_manager"
# is_lro = true

# --- regionInstanceGroupManagers.deletePerInstanceConfigs ---
# POST projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/deletePerInstanceConfigs
# Deletes selected per-instance configurations for the managed instance group.
# Request: RegionInstanceGroupManagerDeleteInstanceConfigReq
# Response: Operation
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "deletePerInstanceConfigs"
# rust_name = "deletePerInstanceConfigs_region_instance_group_manager"
# is_lro = true

# --- regionInstanceGroupManagers.stopInstances ---
# POST projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/stopInstances
# Flags the specified instances in the managed instance group to be immediately stopped. You can only 
# Request: RegionInstanceGroupManagersStopInstancesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "stopInstances"
# rust_name = "stopInstances_region_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- regionInstanceGroupManagers.setTargetPools ---
# POST projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/setTargetPools
# Modifies the target pools to which all new instances in this group are assigned. Existing instances 
# Request: RegionInstanceGroupManagersSetTargetPoolsRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "setTargetPools"
# rust_name = "setTargetPools_region_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- regionInstanceGroupManagers.updatePerInstanceConfigs ---
# POST projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/updatePerInstanceConfigs
# Inserts or updates per-instance configurations for the managed instance group. perInstanceConfig.nam
# Request: RegionInstanceGroupManagerUpdateInstanceConfigReq
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "updatePerInstanceConfigs"
# rust_name = "updatePerInstanceConfigs_region_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- regionInstanceGroupManagers.setInstanceTemplate ---
# POST projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/setInstanceTemplate
# Sets the instance template to use when creating new instances or recreating instances in this group.
# Request: RegionInstanceGroupManagersSetTemplateRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "setInstanceTemplate"
# rust_name = "setInstanceTemplate_region_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- regionInstanceGroupManagers.startInstances ---
# POST projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/startInstances
# Flags the specified instances in the managed instance group to be started. This method increases the
# Request: RegionInstanceGroupManagersStartInstancesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionInstanceGroupManagers"
# discovery_method = "startInstances"
# rust_name = "startInstances_region_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- regionInstanceGroups.listInstances ---
# POST projects/{project}/regions/{region}/instanceGroups/{instanceGroup}/listInstances
# Lists the instances in the specified instance group and displays information about the named ports. 
# Request: RegionInstanceGroupsListInstancesRequest
# Response: RegionInstanceGroupsListInstances
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionInstanceGroups"
# discovery_method = "listInstances"
# rust_name = "listInstances_region_instance_group"
# list_response = { type_name = "RegionInstanceGroupsListInstances", items_field = "items", item_type = "InstanceWithNamedPorts" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionInstanceGroups.testIamPermissions ---
# POST projects/{project}/regions/{region}/instanceGroups/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "regionInstanceGroups"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_region_instance_group"

# --- regionInstanceGroups.get ---
# GET projects/{project}/regions/{region}/instanceGroups/{instanceGroup}
# Returns the specified instance group resource.
# Response: InstanceGroup
# [[operations]]
# discovery_resource = "regionInstanceGroups"
# discovery_method = "get"
# rust_name = "get_region_instance_group"

# --- regionInstanceGroups.list ---
# GET projects/{project}/regions/{region}/instanceGroups
# Retrieves the list of instance group resources contained within the specified region.
# Response: RegionInstanceGroupList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionInstanceGroups"
# discovery_method = "list"
# rust_name = "list_region_instance_groups"
# list_response = { type_name = "RegionInstanceGroupList", items_field = "items", item_type = "InstanceGroup" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionInstanceGroups.setNamedPorts ---
# POST projects/{project}/regions/{region}/instanceGroups/{instanceGroup}/setNamedPorts
# Sets the named ports for the specified regional instance group.
# Request: RegionInstanceGroupsSetNamedPortsRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionInstanceGroups"
# discovery_method = "setNamedPorts"
# rust_name = "setNamedPorts_region_instance_group"
# is_lro = true
# query_params = ["requestId"]

# --- reservationSlots.get ---
# GET projects/{project}/zones/{zone}/{+parentName}/reservationSlots/{reservationSlot}
# Retrieves information about the specified reservation slot.
# Response: ReservationSlotsGetResponse
# [[operations]]
# discovery_resource = "reservationSlots"
# discovery_method = "get"
# rust_name = "get_reservation_slot"

# --- reservationSlots.update ---
# POST projects/{project}/zones/{zone}/{+parentName}/reservationSlots/{reservationSlot}
# Update a reservation slot in the specified sub-block.
# Request: ReservationSlot
# Response: Operation
# Query params: updateMask
# [[operations]]
# discovery_resource = "reservationSlots"
# discovery_method = "update"
# rust_name = "update_reservation_slot"
# is_lro = true
# query_params = ["updateMask"]

# --- reservationSlots.list ---
# GET projects/{project}/zones/{zone}/{+parentName}/reservationSlots
# Retrieves a list of reservation slots under a single reservation.
# Response: ReservationSlotsListResponse
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "reservationSlots"
# discovery_method = "list"
# rust_name = "list_reservation_slots"
# list_response = { type_name = "ReservationSlotsListResponse", items_field = "items", item_type = "ReservationSlot" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- nodeGroups.listNodes ---
# POST projects/{project}/zones/{zone}/nodeGroups/{nodeGroup}/listNodes
# Lists nodes in the node group.
# Response: NodeGroupsListNodes
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "nodeGroups"
# discovery_method = "listNodes"
# rust_name = "listNodes_node_group"
# list_response = { type_name = "NodeGroupsListNodes", items_field = "items", item_type = "NodeGroupNode" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- nodeGroups.patch ---
# PATCH projects/{project}/zones/{zone}/nodeGroups/{nodeGroup}
# Updates the specified node group.
# Request: NodeGroup
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "nodeGroups"
# discovery_method = "patch"
# rust_name = "update_node_group"
# is_lro = true
# query_params = ["requestId"]

# --- nodeGroups.get ---
# GET projects/{project}/zones/{zone}/nodeGroups/{nodeGroup}
# Returns the specified NodeGroup. Get a list of available NodeGroups by making a list() request. Note
# Response: NodeGroup
# [[operations]]
# discovery_resource = "nodeGroups"
# discovery_method = "get"
# rust_name = "get_node_group"

# --- nodeGroups.performMaintenance ---
# POST projects/{project}/zones/{zone}/nodeGroups/{nodeGroup}/performMaintenance
# Perform maintenance on a subset of nodes in the node group.
# Request: NodeGroupsPerformMaintenanceRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "nodeGroups"
# discovery_method = "performMaintenance"
# rust_name = "performMaintenance_node_group"
# is_lro = true
# query_params = ["requestId"]

# --- nodeGroups.setIamPolicy ---
# POST projects/{project}/zones/{zone}/nodeGroups/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: ZoneSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "nodeGroups"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_node_group"

# --- nodeGroups.delete ---
# DELETE projects/{project}/zones/{zone}/nodeGroups/{nodeGroup}
# Deletes the specified NodeGroup resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "nodeGroups"
# discovery_method = "delete"
# rust_name = "delete_node_group"
# is_lro = true
# query_params = ["requestId"]

# --- nodeGroups.getIamPolicy ---
# GET projects/{project}/zones/{zone}/nodeGroups/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "nodeGroups"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_node_group"
# query_params = ["optionsRequestedPolicyVersion"]

# --- nodeGroups.simulateMaintenanceEvent ---
# POST projects/{project}/zones/{zone}/nodeGroups/{nodeGroup}/simulateMaintenanceEvent
# Simulates maintenance event on specified nodes from the node group.
# Request: NodeGroupsSimulateMaintenanceEventRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "nodeGroups"
# discovery_method = "simulateMaintenanceEvent"
# rust_name = "simulateMaintenanceEvent_node_group"
# is_lro = true
# query_params = ["requestId"]

# --- nodeGroups.insert ---
# POST projects/{project}/zones/{zone}/nodeGroups
# Creates a NodeGroup resource in the specified project using the data included in the request.
# Request: NodeGroup
# Response: Operation
# Query params: initialNodeCount, requestId
# [[operations]]
# discovery_resource = "nodeGroups"
# discovery_method = "insert"
# rust_name = "create_node_group"
# is_lro = true
# query_params = ["initialNodeCount", "requestId"]

# --- nodeGroups.aggregatedList ---
# GET projects/{project}/aggregated/nodeGroups
# Retrieves an aggregated list of node groups. Note: use nodeGroups.listNodes for more details about e
# Response: NodeGroupAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "nodeGroups"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_node_group"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- nodeGroups.deleteNodes ---
# POST projects/{project}/zones/{zone}/nodeGroups/{nodeGroup}/deleteNodes
# Deletes specified nodes from the node group.
# Request: NodeGroupsDeleteNodesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "nodeGroups"
# discovery_method = "deleteNodes"
# rust_name = "deleteNodes_node_group"
# is_lro = true
# query_params = ["requestId"]

# --- nodeGroups.addNodes ---
# POST projects/{project}/zones/{zone}/nodeGroups/{nodeGroup}/addNodes
# Adds specified number of nodes to the node group.
# Request: NodeGroupsAddNodesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "nodeGroups"
# discovery_method = "addNodes"
# rust_name = "addNodes_node_group"
# is_lro = true
# query_params = ["requestId"]

# --- nodeGroups.setNodeTemplate ---
# POST projects/{project}/zones/{zone}/nodeGroups/{nodeGroup}/setNodeTemplate
# Updates the node template of the node group.
# Request: NodeGroupsSetNodeTemplateRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "nodeGroups"
# discovery_method = "setNodeTemplate"
# rust_name = "setNodeTemplate_node_group"
# is_lro = true
# query_params = ["requestId"]

# --- nodeGroups.list ---
# GET projects/{project}/zones/{zone}/nodeGroups
# Retrieves a list of node groups available to the specified project. Note: use nodeGroups.listNodes f
# Response: NodeGroupList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "nodeGroups"
# discovery_method = "list"
# rust_name = "list_node_groups"
# list_response = { type_name = "NodeGroupList", items_field = "items", item_type = "NodeGroup" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- nodeGroups.testIamPermissions ---
# POST projects/{project}/zones/{zone}/nodeGroups/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "nodeGroups"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_node_group"

# --- regionNotificationEndpoints.insert ---
# POST projects/{project}/regions/{region}/notificationEndpoints
# Create a NotificationEndpoint in the specified project in the given region using the parameters that
# Request: NotificationEndpoint
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionNotificationEndpoints"
# discovery_method = "insert"
# rust_name = "create_region_notification_endpoint"
# is_lro = true
# query_params = ["requestId"]

# --- regionNotificationEndpoints.delete ---
# DELETE projects/{project}/regions/{region}/notificationEndpoints/{notificationEndpoint}
# Deletes the specified NotificationEndpoint in the given region
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionNotificationEndpoints"
# discovery_method = "delete"
# rust_name = "delete_region_notification_endpoint"
# is_lro = true
# query_params = ["requestId"]

# --- regionNotificationEndpoints.get ---
# GET projects/{project}/regions/{region}/notificationEndpoints/{notificationEndpoint}
# Returns the specified NotificationEndpoint resource in the given region.
# Response: NotificationEndpoint
# [[operations]]
# discovery_resource = "regionNotificationEndpoints"
# discovery_method = "get"
# rust_name = "get_region_notification_endpoint"

# --- regionNotificationEndpoints.list ---
# GET projects/{project}/regions/{region}/notificationEndpoints
# Lists the NotificationEndpoints for a project in the given region.
# Response: NotificationEndpointList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionNotificationEndpoints"
# discovery_method = "list"
# rust_name = "list_region_notification_endpoints"
# list_response = { type_name = "NotificationEndpointList", items_field = "items", item_type = "NotificationEndpoint" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionNotificationEndpoints.testIamPermissions ---
# POST projects/{project}/regions/{region}/notificationEndpoints/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "regionNotificationEndpoints"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_region_notification_endpoint"

# --- sslCertificates.get ---
# GET projects/{project}/global/sslCertificates/{sslCertificate}
# Returns the specified SslCertificate resource.
# Response: SslCertificate
# [[operations]]
# discovery_resource = "sslCertificates"
# discovery_method = "get"
# rust_name = "get_ssl_certificate"

# --- sslCertificates.list ---
# GET projects/{project}/global/sslCertificates
# Retrieves the list of SslCertificate resources available to the specified project.
# Response: SslCertificateList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "sslCertificates"
# discovery_method = "list"
# rust_name = "list_ssl_certificates"
# list_response = { type_name = "SslCertificateList", items_field = "items", item_type = "SslCertificate" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- sslCertificates.insert ---
# POST projects/{project}/global/sslCertificates
# Creates a SslCertificate resource in the specified project using the data included in the request.
# Request: SslCertificate
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "sslCertificates"
# discovery_method = "insert"
# rust_name = "create_ssl_certificate"
# is_lro = true
# query_params = ["requestId"]

# --- sslCertificates.aggregatedList ---
# GET projects/{project}/aggregated/sslCertificates
# Retrieves the list of all SslCertificate resources, regional and global, available to the specified 
# Response: SslCertificateAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "sslCertificates"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_ssl_certificate"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- sslCertificates.delete ---
# DELETE projects/{project}/global/sslCertificates/{sslCertificate}
# Deletes the specified SslCertificate resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "sslCertificates"
# discovery_method = "delete"
# rust_name = "delete_ssl_certificate"
# is_lro = true
# query_params = ["requestId"]

# --- backendServices.setSecurityPolicy ---
# POST projects/{project}/global/backendServices/{backendService}/setSecurityPolicy
# Sets the Google Cloud Armor security policy for the specified backend service. For more information,
# Request: SecurityPolicyReference
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "backendServices"
# discovery_method = "setSecurityPolicy"
# rust_name = "setSecurityPolicy_backend_service"
# is_lro = true
# query_params = ["requestId"]

# --- backendServices.setIamPolicy ---
# POST projects/{project}/global/backendServices/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: GlobalSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "backendServices"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_backend_service"

# --- backendServices.get [IN MANIFEST] ---
# GET projects/{project}/global/backendServices/{backendService}
# Returns the specified BackendService resource.
# Response: BackendService
# [[operations]]
# discovery_resource = "backendServices"
# discovery_method = "get"
# rust_name = "get_backend_service"

# --- backendServices.setEdgeSecurityPolicy ---
# POST projects/{project}/global/backendServices/{backendService}/setEdgeSecurityPolicy
# Sets the edge security policy for the specified backend service.
# Request: SecurityPolicyReference
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "backendServices"
# discovery_method = "setEdgeSecurityPolicy"
# rust_name = "setEdgeSecurityPolicy_backend_service"
# is_lro = true
# query_params = ["requestId"]

# --- backendServices.delete [IN MANIFEST] ---
# DELETE projects/{project}/global/backendServices/{backendService}
# Deletes the specified BackendService resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "backendServices"
# discovery_method = "delete"
# rust_name = "delete_backend_service"
# is_lro = true
# query_params = ["requestId"]

# --- backendServices.testIamPermissions ---
# POST projects/{project}/global/backendServices/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "backendServices"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_backend_service"

# --- backendServices.getHealth ---
# POST projects/{project}/global/backendServices/{backendService}/getHealth
# Gets the most recent health check results for this BackendService. Example request body: { "group": 
# Request: ResourceGroupReference
# Response: BackendServiceGroupHealth
# [[operations]]
# discovery_resource = "backendServices"
# discovery_method = "getHealth"
# rust_name = "getHealth_backend_service"

# --- backendServices.insert [IN MANIFEST] ---
# POST projects/{project}/global/backendServices
# Creates a BackendService resource in the specified project using the data included in the request. F
# Request: BackendService
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "backendServices"
# discovery_method = "insert"
# rust_name = "create_backend_service"
# is_lro = true
# query_params = ["requestId"]

# --- backendServices.update ---
# PUT projects/{project}/global/backendServices/{backendService}
# Updates the specified BackendService resource with the data included in the request. For more inform
# Request: BackendService
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "backendServices"
# discovery_method = "update"
# rust_name = "update_backend_service"
# is_lro = true
# query_params = ["requestId"]

# --- backendServices.listUsable ---
# GET projects/{project}/global/backendServices/listUsable
# Retrieves a list of all usable backend services in the specified project.
# Response: BackendServiceListUsable
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "backendServices"
# discovery_method = "listUsable"
# rust_name = "listUsable_backend_service"
# list_response = { type_name = "BackendServiceListUsable", items_field = "items", item_type = "BackendService" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- backendServices.getIamPolicy ---
# GET projects/{project}/global/backendServices/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "backendServices"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_backend_service"
# query_params = ["optionsRequestedPolicyVersion"]

# --- backendServices.patch [IN MANIFEST] ---
# PATCH projects/{project}/global/backendServices/{backendService}
# Patches the specified BackendService resource with the data included in the request. For more inform
# Request: BackendService
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "backendServices"
# discovery_method = "patch"
# rust_name = "update_backend_service"
# is_lro = true
# query_params = ["requestId"]

# --- backendServices.getEffectiveSecurityPolicies ---
# GET projects/{project}/global/backendServices/{backendService}/getEffectiveSecurityPolicies
# Returns effective security policies applied to this backend service.
# [[operations]]
# discovery_resource = "backendServices"
# discovery_method = "getEffectiveSecurityPolicies"
# rust_name = "getEffectiveSecurityPolicies_backend_service"

# --- backendServices.addSignedUrlKey ---
# POST projects/{project}/global/backendServices/{backendService}/addSignedUrlKey
# Adds a key for validating requests with signed URLs for this backend service.
# Request: SignedUrlKey
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "backendServices"
# discovery_method = "addSignedUrlKey"
# rust_name = "addSignedUrlKey_backend_service"
# is_lro = true
# query_params = ["requestId"]

# --- backendServices.aggregatedList ---
# GET projects/{project}/aggregated/backendServices
# Retrieves the list of all BackendService resources, regional and global, available to the specified 
# Response: BackendServiceAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "backendServices"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_backend_service"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- backendServices.deleteSignedUrlKey ---
# POST projects/{project}/global/backendServices/{backendService}/deleteSignedUrlKey
# Deletes a key for validating requests with signed URLs for this backend service.
# Response: Operation
# Query params: keyName, requestId
# [[operations]]
# discovery_resource = "backendServices"
# discovery_method = "deleteSignedUrlKey"
# rust_name = "deleteSignedUrlKey_backend_service"
# is_lro = true
# query_params = ["keyName", "requestId"]

# --- backendServices.list [IN MANIFEST] ---
# GET projects/{project}/global/backendServices
# Retrieves the list of BackendService resources available to the specified project.
# Response: BackendServiceList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "backendServices"
# discovery_method = "list"
# rust_name = "list_backend_services"
# list_response = { type_name = "BackendServiceList", items_field = "items", item_type = "BackendService" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regions.get ---
# GET projects/{project}/regions/{region}
# Returns the specified Region resource. To decrease latency for this method, you can optionally omit 
# Response: Region
# [[operations]]
# discovery_resource = "regions"
# discovery_method = "get"
# rust_name = "get_region"

# --- regions.list ---
# GET projects/{project}/regions
# Retrieves the list of region resources available to the specified project. To decrease latency for t
# Response: RegionList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regions"
# discovery_method = "list"
# rust_name = "list_regions"
# list_response = { type_name = "RegionList", items_field = "items", item_type = "Region" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- networkProfiles.list ---
# GET projects/{project}/global/networkProfiles
# Retrieves a list of network profiles available to the specified project.
# Response: NetworkProfilesListResponse
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "networkProfiles"
# discovery_method = "list"
# rust_name = "list_network_profiles"
# list_response = { type_name = "NetworkProfilesListResponse", items_field = "items", item_type = "NetworkProfile" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- networkProfiles.get ---
# GET projects/{project}/global/networkProfiles/{networkProfile}
# Returns the specified network profile.
# Response: NetworkProfile
# [[operations]]
# discovery_resource = "networkProfiles"
# discovery_method = "get"
# rust_name = "get_network_profile"

# --- nodeTypes.aggregatedList ---
# GET projects/{project}/aggregated/nodeTypes
# Retrieves an aggregated list of node types. To prevent failure, Google recommends that you set the `
# Response: NodeTypeAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "nodeTypes"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_node_type"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- nodeTypes.list ---
# GET projects/{project}/zones/{zone}/nodeTypes
# Retrieves a list of node types available to the specified project.
# Response: NodeTypeList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "nodeTypes"
# discovery_method = "list"
# rust_name = "list_node_types"
# list_response = { type_name = "NodeTypeList", items_field = "items", item_type = "NodeType" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- nodeTypes.get ---
# GET projects/{project}/zones/{zone}/nodeTypes/{nodeType}
# Returns the specified node type.
# Response: NodeType
# [[operations]]
# discovery_resource = "nodeTypes"
# discovery_method = "get"
# rust_name = "get_node_type"

# --- subnetworks.expandIpCidrRange ---
# POST projects/{project}/regions/{region}/subnetworks/{subnetwork}/expandIpCidrRange
# Expands the IP CIDR range of the subnetwork to a specified value.
# Request: SubnetworksExpandIpCidrRangeRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "subnetworks"
# discovery_method = "expandIpCidrRange"
# rust_name = "expandIpCidrRange_subnetwork"
# is_lro = true
# query_params = ["requestId"]

# --- subnetworks.delete ---
# DELETE projects/{project}/regions/{region}/subnetworks/{subnetwork}
# Deletes the specified subnetwork.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "subnetworks"
# discovery_method = "delete"
# rust_name = "delete_subnetwork"
# is_lro = true
# query_params = ["requestId"]

# --- subnetworks.listUsable ---
# GET projects/{project}/aggregated/subnetworks/listUsable
# Retrieves an aggregated list of all usable subnetworks in the project.
# Response: UsableSubnetworksAggregatedList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProject
# [[operations]]
# discovery_resource = "subnetworks"
# discovery_method = "listUsable"
# rust_name = "listUsable_subnetwork"
# list_response = { type_name = "UsableSubnetworksAggregatedList", items_field = "items", item_type = "UsableSubnetwork" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProject"]

# --- subnetworks.list ---
# GET projects/{project}/regions/{region}/subnetworks
# Retrieves a list of subnetworks available to the specified project.
# Response: SubnetworkList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess, views (repeated)
# [[operations]]
# discovery_resource = "subnetworks"
# discovery_method = "list"
# rust_name = "list_subnetworks"
# list_response = { type_name = "SubnetworkList", items_field = "items", item_type = "Subnetwork" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "views"]

# --- subnetworks.patch ---
# PATCH projects/{project}/regions/{region}/subnetworks/{subnetwork}
# Patches the specified subnetwork with the data included in the request. Only certain fields can be u
# Request: Subnetwork
# Response: Operation
# Query params: drainTimeoutSeconds, requestId
# [[operations]]
# discovery_resource = "subnetworks"
# discovery_method = "patch"
# rust_name = "update_subnetwork"
# is_lro = true
# query_params = ["drainTimeoutSeconds", "requestId"]

# --- subnetworks.get ---
# GET projects/{project}/regions/{region}/subnetworks/{subnetwork}
# Returns the specified subnetwork.
# Response: Subnetwork
# Query params: views (repeated)
# [[operations]]
# discovery_resource = "subnetworks"
# discovery_method = "get"
# rust_name = "get_subnetwork"
# query_params = ["views"]

# --- subnetworks.setPrivateIpGoogleAccess ---
# POST projects/{project}/regions/{region}/subnetworks/{subnetwork}/setPrivateIpGoogleAccess
# Set whether VMs in this subnet can access Google services without assigning external IP addresses th
# Request: SubnetworksSetPrivateIpGoogleAccessRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "subnetworks"
# discovery_method = "setPrivateIpGoogleAccess"
# rust_name = "setPrivateIpGoogleAccess_subnetwork"
# is_lro = true
# query_params = ["requestId"]

# --- subnetworks.getIamPolicy ---
# GET projects/{project}/regions/{region}/subnetworks/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "subnetworks"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_subnetwork"
# query_params = ["optionsRequestedPolicyVersion"]

# --- subnetworks.aggregatedList ---
# GET projects/{project}/aggregated/subnetworks
# Retrieves an aggregated list of subnetworks. To prevent failure, Google recommends that you set the 
# Response: SubnetworkAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber, views (repeated)
# [[operations]]
# discovery_resource = "subnetworks"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_subnetwork"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber", "views"]

# --- subnetworks.insert ---
# POST projects/{project}/regions/{region}/subnetworks
# Creates a subnetwork in the specified project using the data included in the request.
# Request: Subnetwork
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "subnetworks"
# discovery_method = "insert"
# rust_name = "create_subnetwork"
# is_lro = true
# query_params = ["requestId"]

# --- subnetworks.testIamPermissions ---
# POST projects/{project}/regions/{region}/subnetworks/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "subnetworks"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_subnetwork"

# --- subnetworks.setIamPolicy ---
# POST projects/{project}/regions/{region}/subnetworks/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: RegionSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "subnetworks"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_subnetwork"

# --- routes.testIamPermissions ---
# POST projects/{project}/global/routes/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "routes"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_route"

# --- routes.list ---
# GET projects/{project}/global/routes
# Retrieves the list of Route resources available to the specified project.
# Response: RouteList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "routes"
# discovery_method = "list"
# rust_name = "list_routes"
# list_response = { type_name = "RouteList", items_field = "items", item_type = "Route" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- routes.get ---
# GET projects/{project}/global/routes/{route}
# Returns the specified Route resource.
# Response: Route
# [[operations]]
# discovery_resource = "routes"
# discovery_method = "get"
# rust_name = "get_route"

# --- routes.insert ---
# POST projects/{project}/global/routes
# Creates a Route resource in the specified project using the data included in the request.
# Request: Route
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "routes"
# discovery_method = "insert"
# rust_name = "create_route"
# is_lro = true
# query_params = ["requestId"]

# --- routes.delete ---
# DELETE projects/{project}/global/routes/{route}
# Deletes the specified Route resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "routes"
# discovery_method = "delete"
# rust_name = "delete_route"
# is_lro = true
# query_params = ["requestId"]

# --- zoneOperations.list ---
# GET projects/{project}/zones/{zone}/operations
# Retrieves a list of Operation resources contained within the specified zone.
# Response: OperationList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "zoneOperations"
# discovery_method = "list"
# rust_name = "list_zone_operations"
# list_response = { type_name = "OperationList", items_field = "items", item_type = "Operation" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- zoneOperations.delete ---
# DELETE projects/{project}/zones/{zone}/operations/{operation}
# Deletes the specified zone-specific Operations resource.
# [[operations]]
# discovery_resource = "zoneOperations"
# discovery_method = "delete"
# rust_name = "delete_zone_operation"

# --- zoneOperations.wait ---
# POST projects/{project}/zones/{zone}/operations/{operation}/wait
# Waits for the specified Operation resource to return as `DONE` or for the request to approach the 2 
# Response: Operation
# [[operations]]
# discovery_resource = "zoneOperations"
# discovery_method = "wait"
# rust_name = "wait_zone_operation"
# is_lro = true

# --- zoneOperations.get ---
# GET projects/{project}/zones/{zone}/operations/{operation}
# Retrieves the specified zone-specific Operations resource.
# Response: Operation
# [[operations]]
# discovery_resource = "zoneOperations"
# discovery_method = "get"
# rust_name = "get_zone_operation"
# is_lro = true

# --- targetTcpProxies.list ---
# GET projects/{project}/global/targetTcpProxies
# Retrieves the list of TargetTcpProxy resources available to the specified project.
# Response: TargetTcpProxyList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "targetTcpProxies"
# discovery_method = "list"
# rust_name = "list_target_tcp_proxies"
# list_response = { type_name = "TargetTcpProxyList", items_field = "items", item_type = "TargetTcpProxy" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- targetTcpProxies.insert ---
# POST projects/{project}/global/targetTcpProxies
# Creates a TargetTcpProxy resource in the specified project using the data included in the request.
# Request: TargetTcpProxy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetTcpProxies"
# discovery_method = "insert"
# rust_name = "create_target_tcp_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetTcpProxies.delete ---
# DELETE projects/{project}/global/targetTcpProxies/{targetTcpProxy}
# Deletes the specified TargetTcpProxy resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetTcpProxies"
# discovery_method = "delete"
# rust_name = "delete_target_tcp_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetTcpProxies.get ---
# GET projects/{project}/global/targetTcpProxies/{targetTcpProxy}
# Returns the specified TargetTcpProxy resource.
# Response: TargetTcpProxy
# [[operations]]
# discovery_resource = "targetTcpProxies"
# discovery_method = "get"
# rust_name = "get_target_tcp_proxie"

# --- targetTcpProxies.testIamPermissions ---
# POST projects/{project}/global/targetTcpProxies/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "targetTcpProxies"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_target_tcp_proxie"

# --- targetTcpProxies.aggregatedList ---
# GET projects/{project}/aggregated/targetTcpProxies
# Retrieves the list of all TargetTcpProxy resources, regional and global, available to the specified 
# Response: TargetTcpProxyAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "targetTcpProxies"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_target_tcp_proxie"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- targetTcpProxies.setBackendService ---
# POST projects/{project}/global/targetTcpProxies/{targetTcpProxy}/setBackendService
# Changes the BackendService for TargetTcpProxy.
# Request: TargetTcpProxiesSetBackendServiceRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetTcpProxies"
# discovery_method = "setBackendService"
# rust_name = "setBackendService_target_tcp_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetTcpProxies.setProxyHeader ---
# POST projects/{project}/global/targetTcpProxies/{targetTcpProxy}/setProxyHeader
# Changes the ProxyHeaderType for TargetTcpProxy.
# Request: TargetTcpProxiesSetProxyHeaderRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetTcpProxies"
# discovery_method = "setProxyHeader"
# rust_name = "setProxyHeader_target_tcp_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- networkAttachments.setIamPolicy ---
# POST projects/{project}/regions/{region}/networkAttachments/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: RegionSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "networkAttachments"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_network_attachment"

# --- networkAttachments.testIamPermissions ---
# POST projects/{project}/regions/{region}/networkAttachments/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "networkAttachments"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_network_attachment"

# --- networkAttachments.list ---
# GET projects/{project}/regions/{region}/networkAttachments
# Lists the NetworkAttachments for a project in the given scope.
# Response: NetworkAttachmentList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "networkAttachments"
# discovery_method = "list"
# rust_name = "list_network_attachments"
# list_response = { type_name = "NetworkAttachmentList", items_field = "items", item_type = "NetworkAttachment" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- networkAttachments.delete ---
# DELETE projects/{project}/regions/{region}/networkAttachments/{networkAttachment}
# Deletes the specified NetworkAttachment in the given scope
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "networkAttachments"
# discovery_method = "delete"
# rust_name = "delete_network_attachment"
# is_lro = true
# query_params = ["requestId"]

# --- networkAttachments.getIamPolicy ---
# GET projects/{project}/regions/{region}/networkAttachments/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "networkAttachments"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_network_attachment"
# query_params = ["optionsRequestedPolicyVersion"]

# --- networkAttachments.get ---
# GET projects/{project}/regions/{region}/networkAttachments/{networkAttachment}
# Returns the specified NetworkAttachment resource in the given scope.
# Response: NetworkAttachment
# [[operations]]
# discovery_resource = "networkAttachments"
# discovery_method = "get"
# rust_name = "get_network_attachment"

# --- networkAttachments.patch ---
# PATCH projects/{project}/regions/{region}/networkAttachments/{networkAttachment}
# Patches the specified NetworkAttachment resource with the data included in the request. This method 
# Request: NetworkAttachment
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "networkAttachments"
# discovery_method = "patch"
# rust_name = "update_network_attachment"
# is_lro = true
# query_params = ["requestId"]

# --- networkAttachments.insert ---
# POST projects/{project}/regions/{region}/networkAttachments
# Creates a NetworkAttachment in the specified project in the given scope using the parameters that ar
# Request: NetworkAttachment
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "networkAttachments"
# discovery_method = "insert"
# rust_name = "create_network_attachment"
# is_lro = true
# query_params = ["requestId"]

# --- networkAttachments.aggregatedList ---
# GET projects/{project}/aggregated/networkAttachments
# Retrieves the list of all NetworkAttachment resources, regional and global, available to the specifi
# Response: NetworkAttachmentAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "networkAttachments"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_network_attachment"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- networks.delete ---
# DELETE projects/{project}/global/networks/{network}
# Deletes the specified network.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "networks"
# discovery_method = "delete"
# rust_name = "delete_network"
# is_lro = true
# query_params = ["requestId"]

# --- networks.listPeeringRoutes ---
# GET projects/{project}/global/networks/{network}/listPeeringRoutes
# Lists the peering routes exchanged over peering connection.
# Response: ExchangedPeeringRoutesList
# Query params: direction, filter, maxResults, orderBy, pageToken, peeringName, region, returnPartialSuccess
# [[operations]]
# discovery_resource = "networks"
# discovery_method = "listPeeringRoutes"
# rust_name = "listPeeringRoutes_network"
# list_response = { type_name = "ExchangedPeeringRoutesList", items_field = "items", item_type = "ExchangedPeeringRoute" }
# query_params = ["direction", "filter", "maxResults", "orderBy", "pageToken", "peeringName", "region", "returnPartialSuccess"]

# --- networks.requestRemovePeering ---
# POST projects/{project}/global/networks/{network}/requestRemovePeering
# Requests to remove a peering from the specified network. Applicable only for PeeringConnection with 
# Request: NetworksRequestRemovePeeringRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "networks"
# discovery_method = "requestRemovePeering"
# rust_name = "requestRemovePeering_network"
# is_lro = true
# query_params = ["requestId"]

# --- networks.switchToCustomMode ---
# POST projects/{project}/global/networks/{network}/switchToCustomMode
# Switches the network mode from auto subnet mode to custom subnet mode.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "networks"
# discovery_method = "switchToCustomMode"
# rust_name = "switchToCustomMode_network"
# is_lro = true
# query_params = ["requestId"]

# --- networks.addPeering ---
# POST projects/{project}/global/networks/{network}/addPeering
# Adds a peering to the specified network.
# Request: NetworksAddPeeringRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "networks"
# discovery_method = "addPeering"
# rust_name = "addPeering_network"
# is_lro = true
# query_params = ["requestId"]

# --- networks.get ---
# GET projects/{project}/global/networks/{network}
# Returns the specified network.
# Response: Network
# [[operations]]
# discovery_resource = "networks"
# discovery_method = "get"
# rust_name = "get_network"

# --- networks.insert ---
# POST projects/{project}/global/networks
# Creates a network in the specified project using the data included in the request.
# Request: Network
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "networks"
# discovery_method = "insert"
# rust_name = "create_network"
# is_lro = true
# query_params = ["requestId"]

# --- networks.updatePeering ---
# PATCH projects/{project}/global/networks/{network}/updatePeering
# Updates the specified network peering with the data included in the request. You can only modify the
# Request: NetworksUpdatePeeringRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "networks"
# discovery_method = "updatePeering"
# rust_name = "updatePeering_network"
# is_lro = true
# query_params = ["requestId"]

# --- networks.getEffectiveFirewalls ---
# GET projects/{project}/global/networks/{network}/getEffectiveFirewalls
# Returns the effective firewalls on a given network.
# Response: NetworksGetEffectiveFirewallsResponse
# [[operations]]
# discovery_resource = "networks"
# discovery_method = "getEffectiveFirewalls"
# rust_name = "getEffectiveFirewalls_network"

# --- networks.list ---
# GET projects/{project}/global/networks
# Retrieves the list of networks available to the specified project.
# Response: NetworkList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "networks"
# discovery_method = "list"
# rust_name = "list_networks"
# list_response = { type_name = "NetworkList", items_field = "items", item_type = "Network" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- networks.patch ---
# PATCH projects/{project}/global/networks/{network}
# Patches the specified network with the data included in the request. Only routingConfig can be modif
# Request: Network
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "networks"
# discovery_method = "patch"
# rust_name = "update_network"
# is_lro = true
# query_params = ["requestId"]

# --- networks.removePeering ---
# POST projects/{project}/global/networks/{network}/removePeering
# Removes a peering from the specified network.
# Request: NetworksRemovePeeringRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "networks"
# discovery_method = "removePeering"
# rust_name = "removePeering_network"
# is_lro = true
# query_params = ["requestId"]

# --- forwardingRules.insert ---
# POST projects/{project}/regions/{region}/forwardingRules
# Creates a ForwardingRule resource in the specified project and region using the data included in the
# Request: ForwardingRule
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "forwardingRules"
# discovery_method = "insert"
# rust_name = "create_forwarding_rule"
# is_lro = true
# query_params = ["requestId"]

# --- forwardingRules.delete ---
# DELETE projects/{project}/regions/{region}/forwardingRules/{forwardingRule}
# Deletes the specified ForwardingRule resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "forwardingRules"
# discovery_method = "delete"
# rust_name = "delete_forwarding_rule"
# is_lro = true
# query_params = ["requestId"]

# --- forwardingRules.setLabels ---
# POST projects/{project}/regions/{region}/forwardingRules/{resource}/setLabels
# Sets the labels on the specified resource. To learn more about labels, read the Labeling Resources d
# Request: RegionSetLabelsRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "forwardingRules"
# discovery_method = "setLabels"
# rust_name = "setLabels_forwarding_rule"
# is_lro = true
# query_params = ["requestId"]

# --- forwardingRules.list ---
# GET projects/{project}/regions/{region}/forwardingRules
# Retrieves a list of ForwardingRule resources available to the specified project and region.
# Response: ForwardingRuleList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "forwardingRules"
# discovery_method = "list"
# rust_name = "list_forwarding_rules"
# list_response = { type_name = "ForwardingRuleList", items_field = "items", item_type = "ForwardingRule" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- forwardingRules.aggregatedList ---
# GET projects/{project}/aggregated/forwardingRules
# Retrieves an aggregated list of forwarding rules. To prevent failure, it is recommended that you set
# Response: ForwardingRuleAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "forwardingRules"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_forwarding_rule"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- forwardingRules.get ---
# GET projects/{project}/regions/{region}/forwardingRules/{forwardingRule}
# Returns the specified ForwardingRule resource.
# Response: ForwardingRule
# [[operations]]
# discovery_resource = "forwardingRules"
# discovery_method = "get"
# rust_name = "get_forwarding_rule"

# --- forwardingRules.setTarget ---
# POST projects/{project}/regions/{region}/forwardingRules/{forwardingRule}/setTarget
# Changes target URL for forwarding rule. The new target should be of the same type as the old target.
# Request: TargetReference
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "forwardingRules"
# discovery_method = "setTarget"
# rust_name = "setTarget_forwarding_rule"
# is_lro = true
# query_params = ["requestId"]

# --- forwardingRules.patch ---
# PATCH projects/{project}/regions/{region}/forwardingRules/{forwardingRule}
# Updates the specified forwarding rule with the data included in the request. This method supportsPAT
# Request: ForwardingRule
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "forwardingRules"
# discovery_method = "patch"
# rust_name = "update_forwarding_rule"
# is_lro = true
# query_params = ["requestId"]

# --- globalOperations.list ---
# GET projects/{project}/global/operations
# Retrieves a list of Operation resources contained within the specified project.
# Response: OperationList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "globalOperations"
# discovery_method = "list"
# rust_name = "list_global_operations"
# list_response = { type_name = "OperationList", items_field = "items", item_type = "Operation" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- globalOperations.get ---
# GET projects/{project}/global/operations/{operation}
# Retrieves the specified Operations resource.
# Response: Operation
# [[operations]]
# discovery_resource = "globalOperations"
# discovery_method = "get"
# rust_name = "get_global_operation"
# is_lro = true

# --- globalOperations.delete ---
# DELETE projects/{project}/global/operations/{operation}
# Deletes the specified Operations resource.
# [[operations]]
# discovery_resource = "globalOperations"
# discovery_method = "delete"
# rust_name = "delete_global_operation"

# --- globalOperations.aggregatedList ---
# GET projects/{project}/aggregated/operations
# Retrieves an aggregated list of all operations. To prevent failure, Google recommends that you set t
# Response: OperationAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "globalOperations"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_global_operation"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- globalOperations.wait ---
# POST projects/{project}/global/operations/{operation}/wait
# Waits for the specified Operation resource to return as `DONE` or for the request to approach the 2 
# Response: Operation
# [[operations]]
# discovery_resource = "globalOperations"
# discovery_method = "wait"
# rust_name = "wait_global_operation"
# is_lro = true

# --- regionInstantSnapshots.delete ---
# DELETE projects/{project}/regions/{region}/instantSnapshots/{instantSnapshot}
# Deletes the specified InstantSnapshot resource. Keep in mind that deleting a single instantSnapshot 
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionInstantSnapshots"
# discovery_method = "delete"
# rust_name = "delete_region_instant_snapshot"
# is_lro = true
# query_params = ["requestId"]

# --- regionInstantSnapshots.setIamPolicy ---
# POST projects/{project}/regions/{region}/instantSnapshots/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: RegionSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "regionInstantSnapshots"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_region_instant_snapshot"

# --- regionInstantSnapshots.get ---
# GET projects/{project}/regions/{region}/instantSnapshots/{instantSnapshot}
# Returns the specified InstantSnapshot resource in the specified region.
# Response: InstantSnapshot
# [[operations]]
# discovery_resource = "regionInstantSnapshots"
# discovery_method = "get"
# rust_name = "get_region_instant_snapshot"

# --- regionInstantSnapshots.setLabels ---
# POST projects/{project}/regions/{region}/instantSnapshots/{resource}/setLabels
# Sets the labels on a instantSnapshot in the given region. To learn more about labels, read the Label
# Request: RegionSetLabelsRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionInstantSnapshots"
# discovery_method = "setLabels"
# rust_name = "setLabels_region_instant_snapshot"
# is_lro = true
# query_params = ["requestId"]

# --- regionInstantSnapshots.getIamPolicy ---
# GET projects/{project}/regions/{region}/instantSnapshots/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "regionInstantSnapshots"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_region_instant_snapshot"
# query_params = ["optionsRequestedPolicyVersion"]

# --- regionInstantSnapshots.list ---
# GET projects/{project}/regions/{region}/instantSnapshots
# Retrieves the list of InstantSnapshot resources contained within the specified region.
# Response: InstantSnapshotList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionInstantSnapshots"
# discovery_method = "list"
# rust_name = "list_region_instant_snapshots"
# list_response = { type_name = "InstantSnapshotList", items_field = "items", item_type = "InstantSnapshot" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionInstantSnapshots.testIamPermissions ---
# POST projects/{project}/regions/{region}/instantSnapshots/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "regionInstantSnapshots"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_region_instant_snapshot"

# --- regionInstantSnapshots.insert ---
# POST projects/{project}/regions/{region}/instantSnapshots
# Creates an instant snapshot in the specified region.
# Request: InstantSnapshot
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionInstantSnapshots"
# discovery_method = "insert"
# rust_name = "create_region_instant_snapshot"
# is_lro = true
# query_params = ["requestId"]

# --- instanceSettings.patch ---
# PATCH projects/{project}/zones/{zone}/instanceSettings
# Patch Instance settings
# Request: InstanceSettings
# Response: Operation
# Query params: requestId, updateMask
# [[operations]]
# discovery_resource = "instanceSettings"
# discovery_method = "patch"
# rust_name = "update_instance_setting"
# is_lro = true
# query_params = ["requestId", "updateMask"]

# --- instanceSettings.get ---
# GET projects/{project}/zones/{zone}/instanceSettings
# Get Instance settings.
# Response: InstanceSettings
# [[operations]]
# discovery_resource = "instanceSettings"
# discovery_method = "get"
# rust_name = "get_instance_setting"

# --- instances.getScreenshot ---
# GET projects/{project}/zones/{zone}/instances/{instance}/screenshot
# Returns the screenshot from the specified instance.
# Response: Screenshot
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "getScreenshot"
# rust_name = "getScreenshot_instance"

# --- instances.list [IN MANIFEST] ---
# GET projects/{project}/zones/{zone}/instances
# Retrieves the list of instances contained within the specified zone.
# Response: InstanceList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "list"
# rust_name = "list_instances"
# list_response = { type_name = "InstanceList", items_field = "items", item_type = "Instance" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- instances.updateAccessConfig ---
# POST projects/{project}/zones/{zone}/instances/{instance}/updateAccessConfig
# Updates the specified access config from an instance's network interface with the data included in t
# Request: AccessConfig
# Response: Operation
# Query params: networkInterface, requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "updateAccessConfig"
# rust_name = "updateAccessConfig_instance"
# is_lro = true
# query_params = ["networkInterface", "requestId"]

# --- instances.start [IN MANIFEST] ---
# POST projects/{project}/zones/{zone}/instances/{instance}/start
# Starts an instance that was stopped using theinstances().stop method. For more information, seeResta
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "start"
# rust_name = "start_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.deleteAccessConfig [IN MANIFEST] ---
# POST projects/{project}/zones/{zone}/instances/{instance}/deleteAccessConfig
# Deletes an access config from an instance's network interface.
# Response: Operation
# Query params: accessConfig, networkInterface, requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "deleteAccessConfig"
# rust_name = "deleteAccessConfig_instance"
# is_lro = true
# query_params = ["accessConfig", "networkInterface", "requestId"]

# --- instances.removeResourcePolicies ---
# POST projects/{project}/zones/{zone}/instances/{instance}/removeResourcePolicies
# Removes resource policies from an instance.
# Request: InstancesRemoveResourcePoliciesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "removeResourcePolicies"
# rust_name = "removeResourcePolicies_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.addResourcePolicies ---
# POST projects/{project}/zones/{zone}/instances/{instance}/addResourcePolicies
# Adds existing resource policies to an instance. You can only add one policy right now which will be 
# Request: InstancesAddResourcePoliciesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "addResourcePolicies"
# rust_name = "addResourcePolicies_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.update ---
# PUT projects/{project}/zones/{zone}/instances/{instance}
# Updates an instance only if the necessary resources are available. This method can update only a spe
# Request: Instance
# Response: Operation
# Query params: minimalAction, mostDisruptiveAllowedAction, requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "update"
# rust_name = "update_instance"
# is_lro = true
# query_params = ["minimalAction", "mostDisruptiveAllowedAction", "requestId"]

# --- instances.setSecurityPolicy ---
# POST projects/{project}/zones/{zone}/instances/{instance}/setSecurityPolicy
# Sets the Google Cloud Armor security policy for the specified instance. For more information, seeGoo
# Request: InstancesSetSecurityPolicyRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "setSecurityPolicy"
# rust_name = "setSecurityPolicy_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.bulkInsert ---
# POST projects/{project}/zones/{zone}/instances/bulkInsert
# Creates multiple instances. Count specifies the number of instances to create. For more information,
# Request: BulkInsertInstanceResource
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "bulkInsert"
# rust_name = "bulkInsert_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.simulateMaintenanceEvent ---
# POST projects/{project}/zones/{zone}/instances/{instance}/simulateMaintenanceEvent
# Simulates a host maintenance event on a VM. For more information, see Simulate a host maintenance ev
# Response: Operation
# Query params: requestId, withExtendedNotifications
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "simulateMaintenanceEvent"
# rust_name = "simulateMaintenanceEvent_instance"
# is_lro = true
# query_params = ["requestId", "withExtendedNotifications"]

# --- instances.setName ---
# POST projects/{project}/zones/{zone}/instances/{instance}/setName
# Sets name of an instance.
# Request: InstancesSetNameRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "setName"
# rust_name = "setName_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.sendDiagnosticInterrupt ---
# POST projects/{project}/zones/{zone}/instances/{instance}/sendDiagnosticInterrupt
# Sends diagnostic interrupt to the instance.
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "sendDiagnosticInterrupt"
# rust_name = "sendDiagnosticInterrupt_instance"

# --- instances.reset [IN MANIFEST] ---
# POST projects/{project}/zones/{zone}/instances/{instance}/reset
# Performs a reset on the instance. This is a hard reset. The VM does not do a graceful shutdown. For 
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "reset"
# rust_name = "reset_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.addNetworkInterface ---
# POST projects/{project}/zones/{zone}/instances/{instance}/addNetworkInterface
# Adds one dynamic network interface to an active instance.
# Request: NetworkInterface
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "addNetworkInterface"
# rust_name = "addNetworkInterface_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.setShieldedInstanceIntegrityPolicy ---
# PATCH projects/{project}/zones/{zone}/instances/{instance}/setShieldedInstanceIntegrityPolicy
# Sets the Shielded Instance integrity policy for an instance. You can only use this method on a runni
# Request: ShieldedInstanceIntegrityPolicy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "setShieldedInstanceIntegrityPolicy"
# rust_name = "setShieldedInstanceIntegrityPolicy_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.resume ---
# POST projects/{project}/zones/{zone}/instances/{instance}/resume
# Resumes an instance that was suspended using theinstances().suspend method.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "resume"
# rust_name = "resume_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.deleteNetworkInterface ---
# POST projects/{project}/zones/{zone}/instances/{instance}/deleteNetworkInterface
# Deletes one dynamic network interface from an active instance. InstancesDeleteNetworkInterfaceReques
# Response: Operation
# Query params: networkInterfaceName, requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "deleteNetworkInterface"
# rust_name = "deleteNetworkInterface_instance"
# is_lro = true
# query_params = ["networkInterfaceName", "requestId"]

# --- instances.detachDisk ---
# POST projects/{project}/zones/{zone}/instances/{instance}/detachDisk
# Detaches a disk from an instance.
# Response: Operation
# Query params: deviceName, requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "detachDisk"
# rust_name = "detachDisk_instance"
# is_lro = true
# query_params = ["deviceName", "requestId"]

# --- instances.aggregatedList ---
# GET projects/{project}/aggregated/instances
# Retrieves an aggregated list of all of the instances in your project across all regions and zones. T
# Response: InstanceAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_instance"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- instances.setDeletionProtection ---
# POST projects/{project}/zones/{zone}/instances/{resource}/setDeletionProtection
# Sets deletion protection on the instance.
# Response: Operation
# Query params: deletionProtection, requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "setDeletionProtection"
# rust_name = "setDeletionProtection_instance"
# is_lro = true
# query_params = ["deletionProtection", "requestId"]

# --- instances.setTags ---
# POST projects/{project}/zones/{zone}/instances/{instance}/setTags
# Sets network tags for the specified instance to the data included in the request.
# Request: Tags
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "setTags"
# rust_name = "setTags_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.delete [IN MANIFEST] ---
# DELETE projects/{project}/zones/{zone}/instances/{instance}
# Deletes the specified Instance resource. For more information, seeDeleting an instance.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "delete"
# rust_name = "delete_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.suspend ---
# POST projects/{project}/zones/{zone}/instances/{instance}/suspend
# This method suspends a running instance, saving its state to persistent storage, and allows you to r
# Response: Operation
# Query params: discardLocalSsd, requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "suspend"
# rust_name = "suspend_instance"
# is_lro = true
# query_params = ["discardLocalSsd", "requestId"]

# --- instances.updateShieldedInstanceConfig ---
# PATCH projects/{project}/zones/{zone}/instances/{instance}/updateShieldedInstanceConfig
# Updates the Shielded Instance config for an instance. You can only use this method on a stopped inst
# Request: ShieldedInstanceConfig
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "updateShieldedInstanceConfig"
# rust_name = "updateShieldedInstanceConfig_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.startWithEncryptionKey ---
# POST projects/{project}/zones/{zone}/instances/{instance}/startWithEncryptionKey
# Starts an instance that was stopped using theinstances().stop method. For more information, seeResta
# Request: InstancesStartWithEncryptionKeyRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "startWithEncryptionKey"
# rust_name = "startWithEncryptionKey_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.get [IN MANIFEST] ---
# GET projects/{project}/zones/{zone}/instances/{instance}
# Returns the specified Instance resource.
# Response: Instance
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "get"
# rust_name = "get_instance"

# --- instances.setMetadata ---
# POST projects/{project}/zones/{zone}/instances/{instance}/setMetadata
# Sets metadata for the specified instance to the data included in the request.
# Request: Metadata
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "setMetadata"
# rust_name = "setMetadata_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.insert [IN MANIFEST] ---
# POST projects/{project}/zones/{zone}/instances
# Creates an instance resource in the specified project using the data included in the request.
# Request: Instance
# Response: Operation
# Query params: requestId, sourceInstanceTemplate, sourceMachineImage
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "insert"
# rust_name = "create_instance"
# is_lro = true
# query_params = ["requestId", "sourceInstanceTemplate", "sourceMachineImage"]

# --- instances.getShieldedInstanceIdentity ---
# GET projects/{project}/zones/{zone}/instances/{instance}/getShieldedInstanceIdentity
# Returns the Shielded Instance Identity of an instance
# Response: ShieldedInstanceIdentity
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "getShieldedInstanceIdentity"
# rust_name = "getShieldedInstanceIdentity_instance"

# --- instances.setServiceAccount ---
# POST projects/{project}/zones/{zone}/instances/{instance}/setServiceAccount
# Sets the service account on the instance. For more information, readChanging the service account and
# Request: InstancesSetServiceAccountRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "setServiceAccount"
# rust_name = "setServiceAccount_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.setDiskAutoDelete ---
# POST projects/{project}/zones/{zone}/instances/{instance}/setDiskAutoDelete
# Sets the auto-delete flag for a disk attached to an instance.
# Response: Operation
# Query params: autoDelete, deviceName, requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "setDiskAutoDelete"
# rust_name = "setDiskAutoDelete_instance"
# is_lro = true
# query_params = ["autoDelete", "deviceName", "requestId"]

# --- instances.stop [IN MANIFEST] ---
# POST projects/{project}/zones/{zone}/instances/{instance}/stop
# Stops a running instance, shutting it down cleanly, and allows you to restart the instance at a late
# Response: Operation
# Query params: discardLocalSsd, requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "stop"
# rust_name = "stop_instance"
# is_lro = true
# query_params = ["discardLocalSsd", "requestId"]

# --- instances.getEffectiveFirewalls ---
# GET projects/{project}/zones/{zone}/instances/{instance}/getEffectiveFirewalls
# Returns effective firewalls applied to an interface of the instance.
# Response: InstancesGetEffectiveFirewallsResponse
# Query params: networkInterface
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "getEffectiveFirewalls"
# rust_name = "getEffectiveFirewalls_instance"
# query_params = ["networkInterface"]

# --- instances.getIamPolicy ---
# GET projects/{project}/zones/{zone}/instances/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_instance"
# query_params = ["optionsRequestedPolicyVersion"]

# --- instances.listReferrers ---
# GET projects/{project}/zones/{zone}/instances/{instance}/referrers
# Retrieves a list of resources that refer to the VM instance specified in the request. For example, i
# Response: InstanceListReferrers
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "listReferrers"
# rust_name = "listReferrers_instance"
# list_response = { type_name = "InstanceListReferrers", items_field = "items", item_type = "Reference" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- instances.setMinCpuPlatform ---
# POST projects/{project}/zones/{zone}/instances/{instance}/setMinCpuPlatform
# Changes the minimum CPU platform that this instance should use. This method can only be called on a 
# Request: InstancesSetMinCpuPlatformRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "setMinCpuPlatform"
# rust_name = "setMinCpuPlatform_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.setLabels ---
# POST projects/{project}/zones/{zone}/instances/{instance}/setLabels
# Sets labels on an instance. To learn more about labels, read theLabeling Resources documentation.
# Request: InstancesSetLabelsRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "setLabels"
# rust_name = "setLabels_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.setIamPolicy ---
# POST projects/{project}/zones/{zone}/instances/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: ZoneSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_instance"

# --- instances.updateNetworkInterface ---
# PATCH projects/{project}/zones/{zone}/instances/{instance}/updateNetworkInterface
# Updates an instance's network interface. This method can only update an interface's alias IP range a
# Request: NetworkInterface
# Response: Operation
# Query params: networkInterface, requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "updateNetworkInterface"
# rust_name = "updateNetworkInterface_instance"
# is_lro = true
# query_params = ["networkInterface", "requestId"]

# --- instances.attachDisk ---
# POST projects/{project}/zones/{zone}/instances/{instance}/attachDisk
# Attaches an existing Disk resource to an instance. You must first create the disk before you can att
# Request: AttachedDisk
# Response: Operation
# Query params: forceAttach, requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "attachDisk"
# rust_name = "attachDisk_instance"
# is_lro = true
# query_params = ["forceAttach", "requestId"]

# --- instances.setMachineType [IN MANIFEST] ---
# POST projects/{project}/zones/{zone}/instances/{instance}/setMachineType
# Changes the machine type for a stopped instance to the machine type specified in the request.
# Request: InstancesSetMachineTypeRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "setMachineType"
# rust_name = "setMachineType_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.getGuestAttributes ---
# GET projects/{project}/zones/{zone}/instances/{instance}/getGuestAttributes
# Returns the specified guest attributes entry.
# Response: GuestAttributes
# Query params: queryPath, variableKey
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "getGuestAttributes"
# rust_name = "getGuestAttributes_instance"
# query_params = ["queryPath", "variableKey"]

# --- instances.reportHostAsFaulty ---
# POST projects/{project}/zones/{zone}/instances/{instance}/reportHostAsFaulty
# Mark the host as faulty and try to restart the instance on a new host.
# Request: InstancesReportHostAsFaultyRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "reportHostAsFaulty"
# rust_name = "reportHostAsFaulty_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.setScheduling ---
# POST projects/{project}/zones/{zone}/instances/{instance}/setScheduling
# Sets an instance's scheduling options. You can only call this method on astopped instance, that is, 
# Request: Scheduling
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "setScheduling"
# rust_name = "setScheduling_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.setMachineResources ---
# POST projects/{project}/zones/{zone}/instances/{instance}/setMachineResources
# Changes the number and/or type of accelerator for a stopped instance to the values specified in the 
# Request: InstancesSetMachineResourcesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "setMachineResources"
# rust_name = "setMachineResources_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.updateDisplayDevice ---
# PATCH projects/{project}/zones/{zone}/instances/{instance}/updateDisplayDevice
# Updates the Display config for a VM instance. You can only use this method on a stopped VM instance.
# Request: DisplayDevice
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "updateDisplayDevice"
# rust_name = "updateDisplayDevice_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.getSerialPortOutput ---
# GET projects/{project}/zones/{zone}/instances/{instance}/serialPort
# Returns the last 1 MB of serial port output from the specified instance.
# Response: SerialPortOutput
# Query params: port, start
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "getSerialPortOutput"
# rust_name = "getSerialPortOutput_instance"
# query_params = ["port", "start"]

# --- instances.performMaintenance ---
# POST projects/{project}/zones/{zone}/instances/{instance}/performMaintenance
# Perform a manual maintenance on the instance.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "performMaintenance"
# rust_name = "performMaintenance_instance"
# is_lro = true
# query_params = ["requestId"]

# --- instances.addAccessConfig ---
# POST projects/{project}/zones/{zone}/instances/{instance}/addAccessConfig
# Adds an access config to an instance's network interface.
# Request: AccessConfig
# Response: Operation
# Query params: networkInterface, requestId
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "addAccessConfig"
# rust_name = "addAccessConfig_instance"
# is_lro = true
# query_params = ["networkInterface", "requestId"]

# --- instances.testIamPermissions ---
# POST projects/{project}/zones/{zone}/instances/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "instances"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_instance"

# --- globalNetworkEndpointGroups.insert ---
# POST projects/{project}/global/networkEndpointGroups
# Creates a network endpoint group in the specified project using the parameters that are included in 
# Request: NetworkEndpointGroup
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "globalNetworkEndpointGroups"
# discovery_method = "insert"
# rust_name = "create_global_network_endpoint_group"
# is_lro = true
# query_params = ["requestId"]

# --- globalNetworkEndpointGroups.delete ---
# DELETE projects/{project}/global/networkEndpointGroups/{networkEndpointGroup}
# Deletes the specified network endpoint group.Note that the NEG cannot be deleted if there are backen
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "globalNetworkEndpointGroups"
# discovery_method = "delete"
# rust_name = "delete_global_network_endpoint_group"
# is_lro = true
# query_params = ["requestId"]

# --- globalNetworkEndpointGroups.get ---
# GET projects/{project}/global/networkEndpointGroups/{networkEndpointGroup}
# Returns the specified network endpoint group.
# Response: NetworkEndpointGroup
# [[operations]]
# discovery_resource = "globalNetworkEndpointGroups"
# discovery_method = "get"
# rust_name = "get_global_network_endpoint_group"

# --- globalNetworkEndpointGroups.attachNetworkEndpoints ---
# POST projects/{project}/global/networkEndpointGroups/{networkEndpointGroup}/attachNetworkEndpoints
# Attach a network endpoint to the specified network endpoint group.
# Request: GlobalNetworkEndpointGroupsAttachEndpointsRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "globalNetworkEndpointGroups"
# discovery_method = "attachNetworkEndpoints"
# rust_name = "attachNetworkEndpoints_global_network_endpoint_group"
# is_lro = true
# query_params = ["requestId"]

# --- globalNetworkEndpointGroups.listNetworkEndpoints ---
# POST projects/{project}/global/networkEndpointGroups/{networkEndpointGroup}/listNetworkEndpoints
# Lists the network endpoints in the specified network endpoint group.
# Response: NetworkEndpointGroupsListNetworkEndpoints
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "globalNetworkEndpointGroups"
# discovery_method = "listNetworkEndpoints"
# rust_name = "listNetworkEndpoints_global_network_endpoint_group"
# list_response = { type_name = "NetworkEndpointGroupsListNetworkEndpoints", items_field = "items", item_type = "NetworkEndpointWithHealthStatus" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- globalNetworkEndpointGroups.list ---
# GET projects/{project}/global/networkEndpointGroups
# Retrieves the list of network endpoint groups that are located in the specified project.
# Response: NetworkEndpointGroupList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "globalNetworkEndpointGroups"
# discovery_method = "list"
# rust_name = "list_global_network_endpoint_groups"
# list_response = { type_name = "NetworkEndpointGroupList", items_field = "items", item_type = "NetworkEndpointGroup" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- globalNetworkEndpointGroups.detachNetworkEndpoints ---
# POST projects/{project}/global/networkEndpointGroups/{networkEndpointGroup}/detachNetworkEndpoints
# Detach the network endpoint from the specified network endpoint group.
# Request: GlobalNetworkEndpointGroupsDetachEndpointsRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "globalNetworkEndpointGroups"
# discovery_method = "detachNetworkEndpoints"
# rust_name = "detachNetworkEndpoints_global_network_endpoint_group"
# is_lro = true
# query_params = ["requestId"]

# --- urlMaps.testIamPermissions ---
# POST projects/{project}/global/urlMaps/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "urlMaps"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_url_map"

# --- urlMaps.insert ---
# POST projects/{project}/global/urlMaps
# Creates a UrlMap resource in the specified project using the data included in the request.
# Request: UrlMap
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "urlMaps"
# discovery_method = "insert"
# rust_name = "create_url_map"
# is_lro = true
# query_params = ["requestId"]

# --- urlMaps.invalidateCache ---
# POST projects/{project}/global/urlMaps/{urlMap}/invalidateCache
# Initiates a cache invalidation operation, invalidating the specified path, scoped to the specified U
# Request: CacheInvalidationRule
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "urlMaps"
# discovery_method = "invalidateCache"
# rust_name = "invalidateCache_url_map"
# is_lro = true
# query_params = ["requestId"]

# --- urlMaps.delete ---
# DELETE projects/{project}/global/urlMaps/{urlMap}
# Deletes the specified UrlMap resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "urlMaps"
# discovery_method = "delete"
# rust_name = "delete_url_map"
# is_lro = true
# query_params = ["requestId"]

# --- urlMaps.patch ---
# PATCH projects/{project}/global/urlMaps/{urlMap}
# Patches the specified UrlMap resource with the data included in the request. This method supportsPAT
# Request: UrlMap
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "urlMaps"
# discovery_method = "patch"
# rust_name = "update_url_map"
# is_lro = true
# query_params = ["requestId"]

# --- urlMaps.update ---
# PUT projects/{project}/global/urlMaps/{urlMap}
# Updates the specified UrlMap resource with the data included in the request.
# Request: UrlMap
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "urlMaps"
# discovery_method = "update"
# rust_name = "update_url_map"
# is_lro = true
# query_params = ["requestId"]

# --- urlMaps.validate ---
# POST projects/{project}/global/urlMaps/{urlMap}/validate
# Runs static validation for the UrlMap. In particular, the tests of the provided UrlMap will be run. 
# Request: UrlMapsValidateRequest
# Response: UrlMapsValidateResponse
# [[operations]]
# discovery_resource = "urlMaps"
# discovery_method = "validate"
# rust_name = "validate_url_map"

# --- urlMaps.list ---
# GET projects/{project}/global/urlMaps
# Retrieves the list of UrlMap resources available to the specified project.
# Response: UrlMapList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "urlMaps"
# discovery_method = "list"
# rust_name = "list_url_maps"
# list_response = { type_name = "UrlMapList", items_field = "items", item_type = "UrlMap" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- urlMaps.get ---
# GET projects/{project}/global/urlMaps/{urlMap}
# Returns the specified UrlMap resource.
# Response: UrlMap
# [[operations]]
# discovery_resource = "urlMaps"
# discovery_method = "get"
# rust_name = "get_url_map"

# --- urlMaps.aggregatedList ---
# GET projects/{project}/aggregated/urlMaps
# Retrieves the list of all UrlMap resources, regional and global, available to the specified project.
# Response: UrlMapsAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "urlMaps"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_url_map"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- firewallPolicies.listAssociations ---
# GET locations/global/firewallPolicies/listAssociations
# Lists associations of a specified target, i.e., organization or folder.
# Response: FirewallPoliciesListAssociationsResponse
# Query params: targetResource
# [[operations]]
# discovery_resource = "firewallPolicies"
# discovery_method = "listAssociations"
# rust_name = "listAssociations_firewall_policie"
# query_params = ["targetResource"]

# --- firewallPolicies.getIamPolicy ---
# GET locations/global/firewallPolicies/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "firewallPolicies"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_firewall_policie"
# query_params = ["optionsRequestedPolicyVersion"]

# --- firewallPolicies.insert ---
# POST locations/global/firewallPolicies
# Creates a new policy in the specified project using the data included in the request.
# Request: FirewallPolicy
# Response: Operation
# Query params: parentId, requestId
# [[operations]]
# discovery_resource = "firewallPolicies"
# discovery_method = "insert"
# rust_name = "create_firewall_policie"
# is_lro = true
# query_params = ["parentId", "requestId"]

# --- firewallPolicies.patch ---
# PATCH locations/global/firewallPolicies/{firewallPolicy}
# Patches the specified policy with the data included in the request.
# Request: FirewallPolicy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "firewallPolicies"
# discovery_method = "patch"
# rust_name = "update_firewall_policie"
# is_lro = true
# query_params = ["requestId"]

# --- firewallPolicies.get ---
# GET locations/global/firewallPolicies/{firewallPolicy}
# Returns the specified firewall policy.
# Response: FirewallPolicy
# [[operations]]
# discovery_resource = "firewallPolicies"
# discovery_method = "get"
# rust_name = "get_firewall_policie"

# --- firewallPolicies.getAssociation ---
# GET locations/global/firewallPolicies/{firewallPolicy}/getAssociation
# Gets an association with the specified name.
# Response: FirewallPolicyAssociation
# Query params: name
# [[operations]]
# discovery_resource = "firewallPolicies"
# discovery_method = "getAssociation"
# rust_name = "getAssociation_firewall_policie"
# query_params = ["name"]

# --- firewallPolicies.removeRule ---
# POST locations/global/firewallPolicies/{firewallPolicy}/removeRule
# Deletes a rule of the specified priority.
# Response: Operation
# Query params: priority, requestId
# [[operations]]
# discovery_resource = "firewallPolicies"
# discovery_method = "removeRule"
# rust_name = "removeRule_firewall_policie"
# is_lro = true
# query_params = ["priority", "requestId"]

# --- firewallPolicies.move ---
# POST locations/global/firewallPolicies/{firewallPolicy}/move
# Moves the specified firewall policy.
# Response: Operation
# Query params: parentId, requestId
# [[operations]]
# discovery_resource = "firewallPolicies"
# discovery_method = "move"
# rust_name = "move_firewall_policie"
# is_lro = true
# query_params = ["parentId", "requestId"]

# --- firewallPolicies.cloneRules ---
# POST locations/global/firewallPolicies/{firewallPolicy}/cloneRules
# Copies rules to the specified firewall policy.
# Response: Operation
# Query params: requestId, sourceFirewallPolicy
# [[operations]]
# discovery_resource = "firewallPolicies"
# discovery_method = "cloneRules"
# rust_name = "cloneRules_firewall_policie"
# is_lro = true
# query_params = ["requestId", "sourceFirewallPolicy"]

# --- firewallPolicies.delete ---
# DELETE locations/global/firewallPolicies/{firewallPolicy}
# Deletes the specified policy.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "firewallPolicies"
# discovery_method = "delete"
# rust_name = "delete_firewall_policie"
# is_lro = true
# query_params = ["requestId"]

# --- firewallPolicies.removeAssociation ---
# POST locations/global/firewallPolicies/{firewallPolicy}/removeAssociation
# Removes an association for the specified firewall policy.
# Response: Operation
# Query params: name, requestId
# [[operations]]
# discovery_resource = "firewallPolicies"
# discovery_method = "removeAssociation"
# rust_name = "removeAssociation_firewall_policie"
# is_lro = true
# query_params = ["name", "requestId"]

# --- firewallPolicies.testIamPermissions ---
# POST locations/global/firewallPolicies/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "firewallPolicies"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_firewall_policie"

# --- firewallPolicies.list ---
# GET locations/global/firewallPolicies
# Lists all the policies that have been configured for the specified folder or organization.
# Response: FirewallPolicyList
# Query params: filter, maxResults, orderBy, pageToken, parentId, returnPartialSuccess
# [[operations]]
# discovery_resource = "firewallPolicies"
# discovery_method = "list"
# rust_name = "list_firewall_policies"
# list_response = { type_name = "FirewallPolicyList", items_field = "items", item_type = "FirewallPolicy" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "parentId", "returnPartialSuccess"]

# --- firewallPolicies.addRule ---
# POST locations/global/firewallPolicies/{firewallPolicy}/addRule
# Inserts a rule into a firewall policy.
# Request: FirewallPolicyRule
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "firewallPolicies"
# discovery_method = "addRule"
# rust_name = "addRule_firewall_policie"
# is_lro = true
# query_params = ["requestId"]

# --- firewallPolicies.setIamPolicy ---
# POST locations/global/firewallPolicies/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: GlobalOrganizationSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "firewallPolicies"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_firewall_policie"

# --- firewallPolicies.getRule ---
# GET locations/global/firewallPolicies/{firewallPolicy}/getRule
# Gets a rule of the specified priority.
# Response: FirewallPolicyRule
# Query params: priority
# [[operations]]
# discovery_resource = "firewallPolicies"
# discovery_method = "getRule"
# rust_name = "getRule_firewall_policie"
# query_params = ["priority"]

# --- firewallPolicies.patchRule ---
# POST locations/global/firewallPolicies/{firewallPolicy}/patchRule
# Patches a rule of the specified priority.
# Request: FirewallPolicyRule
# Response: Operation
# Query params: priority, requestId
# [[operations]]
# discovery_resource = "firewallPolicies"
# discovery_method = "patchRule"
# rust_name = "patchRule_firewall_policie"
# is_lro = true
# query_params = ["priority", "requestId"]

# --- firewallPolicies.addAssociation ---
# POST locations/global/firewallPolicies/{firewallPolicy}/addAssociation
# Inserts an association for the specified firewall policy.
# Request: FirewallPolicyAssociation
# Response: Operation
# Query params: replaceExistingAssociation, requestId
# [[operations]]
# discovery_resource = "firewallPolicies"
# discovery_method = "addAssociation"
# rust_name = "addAssociation_firewall_policie"
# is_lro = true
# query_params = ["replaceExistingAssociation", "requestId"]

# --- diskTypes.aggregatedList ---
# GET projects/{project}/aggregated/diskTypes
# Retrieves an aggregated list of disk types. To prevent failure, it is recommended that you set the `
# Response: DiskTypeAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "diskTypes"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_disk_type"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- diskTypes.list ---
# GET projects/{project}/zones/{zone}/diskTypes
# Retrieves a list of disk types available to the specified project.
# Response: DiskTypeList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "diskTypes"
# discovery_method = "list"
# rust_name = "list_disk_types"
# list_response = { type_name = "DiskTypeList", items_field = "items", item_type = "DiskType" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- diskTypes.get ---
# GET projects/{project}/zones/{zone}/diskTypes/{diskType}
# Returns the specified disk type.
# Response: DiskType
# [[operations]]
# discovery_resource = "diskTypes"
# discovery_method = "get"
# rust_name = "get_disk_type"

# --- imageFamilyViews.get ---
# GET projects/{project}/zones/{zone}/imageFamilyViews/{family}
# Returns the latest image that is part of an image family, is not deprecated and is rolled out in the
# Response: ImageFamilyView
# [[operations]]
# discovery_resource = "imageFamilyViews"
# discovery_method = "get"
# rust_name = "get_image_family_view"

# --- machineTypes.get ---
# GET projects/{project}/zones/{zone}/machineTypes/{machineType}
# Returns the specified machine type.
# Response: MachineType
# [[operations]]
# discovery_resource = "machineTypes"
# discovery_method = "get"
# rust_name = "get_machine_type"

# --- machineTypes.list ---
# GET projects/{project}/zones/{zone}/machineTypes
# Retrieves a list of machine types available to the specified project.
# Response: MachineTypeList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "machineTypes"
# discovery_method = "list"
# rust_name = "list_machine_types"
# list_response = { type_name = "MachineTypeList", items_field = "items", item_type = "MachineType" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- machineTypes.aggregatedList ---
# GET projects/{project}/aggregated/machineTypes
# Retrieves an aggregated list of machine types. To prevent failure, Google recommends that you set th
# Response: MachineTypeAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "machineTypes"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_machine_type"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- instanceGroupManagers.startInstances ---
# POST projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/startInstances
# Flags the specified instances in the managed instance group to be started. This method increases the
# Request: InstanceGroupManagersStartInstancesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "startInstances"
# rust_name = "startInstances_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- instanceGroupManagers.resize ---
# POST projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/resize
# Resizes the managed instance group. If you increase the size, the group creates new instances using 
# Response: Operation
# Query params: requestId, size
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "resize"
# rust_name = "resize_instance_group_manager"
# is_lro = true
# query_params = ["requestId", "size"]

# --- instanceGroupManagers.abandonInstances ---
# POST projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/abandonInstances
# Flags the specified instances to be removed from the managed instance group. Abandoning an instance 
# Request: InstanceGroupManagersAbandonInstancesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "abandonInstances"
# rust_name = "abandonInstances_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- instanceGroupManagers.applyUpdatesToInstances ---
# POST projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/applyUpdatesToInstances
# Applies changes to selected instances on the managed instance group. This method can be used to appl
# Request: InstanceGroupManagersApplyUpdatesRequest
# Response: Operation
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "applyUpdatesToInstances"
# rust_name = "applyUpdatesToInstances_instance_group_manager"
# is_lro = true

# --- instanceGroupManagers.patchPerInstanceConfigs ---
# POST projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/patchPerInstanceConfigs
# Inserts or patches per-instance configurations for the managed instance group. perInstanceConfig.nam
# Request: InstanceGroupManagersPatchPerInstanceConfigsReq
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "patchPerInstanceConfigs"
# rust_name = "patchPerInstanceConfigs_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- instanceGroupManagers.createInstances ---
# POST projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/createInstances
# Creates instances with per-instance configurations in this managed instance group. Instances are cre
# Request: InstanceGroupManagersCreateInstancesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "createInstances"
# rust_name = "createInstances_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- instanceGroupManagers.aggregatedList ---
# GET projects/{project}/aggregated/instanceGroupManagers
# Retrieves the list of managed instance groups and groups them by zone. To prevent failure, Google re
# Response: InstanceGroupManagerAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_instance_group_manager"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- instanceGroupManagers.setInstanceTemplate ---
# POST projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/setInstanceTemplate
# Specifies the instance template to use when creating new instances in this group. The templates for 
# Request: InstanceGroupManagersSetInstanceTemplateRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "setInstanceTemplate"
# rust_name = "setInstanceTemplate_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- instanceGroupManagers.stopInstances ---
# POST projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/stopInstances
# Flags the specified instances in the managed instance group to be immediately stopped. You can only 
# Request: InstanceGroupManagersStopInstancesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "stopInstances"
# rust_name = "stopInstances_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- instanceGroupManagers.listManagedInstances ---
# POST projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/listManagedInstances
# Lists all of the instances in the managed instance group. Each instance in the list has a currentAct
# Response: InstanceGroupManagersListManagedInstancesResponse
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "listManagedInstances"
# rust_name = "listManagedInstances_instance_group_manager"
# list_response = { type_name = "InstanceGroupManagersListManagedInstancesResponse", items_field = "managedInstances", item_type = "ManagedInstance" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- instanceGroupManagers.list ---
# GET projects/{project}/zones/{zone}/instanceGroupManagers
# Retrieves a list of managed instance groups that are contained within the specified project and zone
# Response: InstanceGroupManagerList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "list"
# rust_name = "list_instance_group_managers"
# list_response = { type_name = "InstanceGroupManagerList", items_field = "items", item_type = "InstanceGroupManager" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- instanceGroupManagers.deleteInstances ---
# POST projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/deleteInstances
# Flags the specified instances in the managed instance group for immediate deletion. The instances ar
# Request: InstanceGroupManagersDeleteInstancesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "deleteInstances"
# rust_name = "deleteInstances_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- instanceGroupManagers.listErrors ---
# GET projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/listErrors
# Lists all errors thrown by actions on instances for a given managed instance group. The filter and o
# Response: InstanceGroupManagersListErrorsResponse
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "listErrors"
# rust_name = "listErrors_instance_group_manager"
# list_response = { type_name = "InstanceGroupManagersListErrorsResponse", items_field = "items", item_type = "InstanceManagedByIgmError" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- instanceGroupManagers.patch ---
# PATCH projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}
# Updates a managed instance group using the information that you specify in the request. This operati
# Request: InstanceGroupManager
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "patch"
# rust_name = "update_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- instanceGroupManagers.listPerInstanceConfigs ---
# POST projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/listPerInstanceConfigs
# Lists all of the per-instance configurations defined for the managed instance group. The orderBy que
# Response: InstanceGroupManagersListPerInstanceConfigsResp
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "listPerInstanceConfigs"
# rust_name = "listPerInstanceConfigs_instance_group_manager"
# list_response = { type_name = "InstanceGroupManagersListPerInstanceConfigsResp", items_field = "items", item_type = "PerInstanceConfig" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- instanceGroupManagers.resumeInstances ---
# POST projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/resumeInstances
# Flags the specified instances in the managed instance group to be resumed. This method increases the
# Request: InstanceGroupManagersResumeInstancesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "resumeInstances"
# rust_name = "resumeInstances_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- instanceGroupManagers.recreateInstances ---
# POST projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/recreateInstances
# Flags the specified VM instances in the managed instance group to be immediately recreated. Each ins
# Request: InstanceGroupManagersRecreateInstancesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "recreateInstances"
# rust_name = "recreateInstances_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- instanceGroupManagers.delete ---
# DELETE projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}
# Deletes the specified managed instance group and all of the instances in that group. Note that the i
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "delete"
# rust_name = "delete_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- instanceGroupManagers.get ---
# GET projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}
# Returns all of the details about the specified managed instance group.
# Response: InstanceGroupManager
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "get"
# rust_name = "get_instance_group_manager"

# --- instanceGroupManagers.deletePerInstanceConfigs ---
# POST projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/deletePerInstanceConfigs
# Deletes selected per-instance configurations for the managed instance group.
# Request: InstanceGroupManagersDeletePerInstanceConfigsReq
# Response: Operation
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "deletePerInstanceConfigs"
# rust_name = "deletePerInstanceConfigs_instance_group_manager"
# is_lro = true

# --- instanceGroupManagers.insert ---
# POST projects/{project}/zones/{zone}/instanceGroupManagers
# Creates a managed instance group using the information that you specify in the request. After the gr
# Request: InstanceGroupManager
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "insert"
# rust_name = "create_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- instanceGroupManagers.updatePerInstanceConfigs ---
# POST projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/updatePerInstanceConfigs
# Inserts or updates per-instance configurations for the managed instance group. perInstanceConfig.nam
# Request: InstanceGroupManagersUpdatePerInstanceConfigsReq
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "updatePerInstanceConfigs"
# rust_name = "updatePerInstanceConfigs_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- instanceGroupManagers.suspendInstances ---
# POST projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/suspendInstances
# Flags the specified instances in the managed instance group to be immediately suspended. You can onl
# Request: InstanceGroupManagersSuspendInstancesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "suspendInstances"
# rust_name = "suspendInstances_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- instanceGroupManagers.setTargetPools ---
# POST projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/setTargetPools
# Modifies the target pools to which all instances in this managed instance group are assigned. The ta
# Request: InstanceGroupManagersSetTargetPoolsRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroupManagers"
# discovery_method = "setTargetPools"
# rust_name = "setTargetPools_instance_group_manager"
# is_lro = true
# query_params = ["requestId"]

# --- futureReservations.aggregatedList ---
# GET projects/{project}/aggregated/futureReservations
# Retrieves an aggregated list of future reservations. To prevent failure, it is recommended that you 
# Response: FutureReservationsAggregatedListResponse
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "futureReservations"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_future_reservation"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- futureReservations.cancel ---
# POST projects/{project}/zones/{zone}/futureReservations/{futureReservation}/cancel
# Cancel the specified future reservation.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "futureReservations"
# discovery_method = "cancel"
# rust_name = "cancel_future_reservation"
# is_lro = true
# query_params = ["requestId"]

# --- futureReservations.list ---
# GET projects/{project}/zones/{zone}/futureReservations
# A list of all the future reservations that have been configured for the specified project in specifi
# Response: FutureReservationsListResponse
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "futureReservations"
# discovery_method = "list"
# rust_name = "list_future_reservations"
# list_response = { type_name = "FutureReservationsListResponse", items_field = "items", item_type = "FutureReservation" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- futureReservations.get ---
# GET projects/{project}/zones/{zone}/futureReservations/{futureReservation}
# Retrieves information about the specified future reservation.
# Response: FutureReservation
# [[operations]]
# discovery_resource = "futureReservations"
# discovery_method = "get"
# rust_name = "get_future_reservation"

# --- futureReservations.update ---
# PATCH projects/{project}/zones/{zone}/futureReservations/{futureReservation}
# Updates the specified future reservation.
# Request: FutureReservation
# Response: Operation
# Query params: requestId, updateMask
# [[operations]]
# discovery_resource = "futureReservations"
# discovery_method = "update"
# rust_name = "update_future_reservation"
# is_lro = true
# query_params = ["requestId", "updateMask"]

# --- futureReservations.insert ---
# POST projects/{project}/zones/{zone}/futureReservations
# Creates a new Future Reservation.
# Request: FutureReservation
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "futureReservations"
# discovery_method = "insert"
# rust_name = "create_future_reservation"
# is_lro = true
# query_params = ["requestId"]

# --- futureReservations.delete ---
# DELETE projects/{project}/zones/{zone}/futureReservations/{futureReservation}
# Deletes the specified future reservation.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "futureReservations"
# discovery_method = "delete"
# rust_name = "delete_future_reservation"
# is_lro = true
# query_params = ["requestId"]

# --- regionSslPolicies.list ---
# GET projects/{project}/regions/{region}/sslPolicies
# Lists all the SSL policies that have been configured for the specified project and region.
# Response: SslPoliciesList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionSslPolicies"
# discovery_method = "list"
# rust_name = "list_region_ssl_policies"
# list_response = { type_name = "SslPoliciesList", items_field = "items", item_type = "SslPolicy" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionSslPolicies.patch ---
# PATCH projects/{project}/regions/{region}/sslPolicies/{sslPolicy}
# Patches the specified SSL policy with the data included in the request.
# Request: SslPolicy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionSslPolicies"
# discovery_method = "patch"
# rust_name = "update_region_ssl_policie"
# is_lro = true
# query_params = ["requestId"]

# --- regionSslPolicies.insert ---
# POST projects/{project}/regions/{region}/sslPolicies
# Creates a new policy in the specified project and region using the data included in the request.
# Request: SslPolicy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionSslPolicies"
# discovery_method = "insert"
# rust_name = "create_region_ssl_policie"
# is_lro = true
# query_params = ["requestId"]

# --- regionSslPolicies.delete ---
# DELETE projects/{project}/regions/{region}/sslPolicies/{sslPolicy}
# Deletes the specified SSL policy. The SSL policy resource can be deleted only if it is not in use by
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionSslPolicies"
# discovery_method = "delete"
# rust_name = "delete_region_ssl_policie"
# is_lro = true
# query_params = ["requestId"]

# --- regionSslPolicies.listAvailableFeatures ---
# GET projects/{project}/regions/{region}/sslPolicies/listAvailableFeatures
# Lists all features that can be specified in the SSL policy when using custom profile.
# Response: SslPoliciesListAvailableFeaturesResponse
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionSslPolicies"
# discovery_method = "listAvailableFeatures"
# rust_name = "listAvailableFeatures_region_ssl_policie"
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionSslPolicies.get ---
# GET projects/{project}/regions/{region}/sslPolicies/{sslPolicy}
# Lists all of the ordered rules present in a single specified policy.
# Response: SslPolicy
# [[operations]]
# discovery_resource = "regionSslPolicies"
# discovery_method = "get"
# rust_name = "get_region_ssl_policie"

# --- globalForwardingRules.delete ---
# DELETE projects/{project}/global/forwardingRules/{forwardingRule}
# Deletes the specified GlobalForwardingRule resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "globalForwardingRules"
# discovery_method = "delete"
# rust_name = "delete_global_forwarding_rule"
# is_lro = true
# query_params = ["requestId"]

# --- globalForwardingRules.patch ---
# PATCH projects/{project}/global/forwardingRules/{forwardingRule}
# Updates the specified forwarding rule with the data included in the request. This method supportsPAT
# Request: ForwardingRule
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "globalForwardingRules"
# discovery_method = "patch"
# rust_name = "update_global_forwarding_rule"
# is_lro = true
# query_params = ["requestId"]

# --- globalForwardingRules.insert ---
# POST projects/{project}/global/forwardingRules
# Creates a GlobalForwardingRule resource in the specified project using the data included in the requ
# Request: ForwardingRule
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "globalForwardingRules"
# discovery_method = "insert"
# rust_name = "create_global_forwarding_rule"
# is_lro = true
# query_params = ["requestId"]

# --- globalForwardingRules.setTarget ---
# POST projects/{project}/global/forwardingRules/{forwardingRule}/setTarget
# Changes target URL for the GlobalForwardingRule resource. The new target should be of the same type 
# Request: TargetReference
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "globalForwardingRules"
# discovery_method = "setTarget"
# rust_name = "setTarget_global_forwarding_rule"
# is_lro = true
# query_params = ["requestId"]

# --- globalForwardingRules.list ---
# GET projects/{project}/global/forwardingRules
# Retrieves a list of GlobalForwardingRule resources available to the specified project.
# Response: ForwardingRuleList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "globalForwardingRules"
# discovery_method = "list"
# rust_name = "list_global_forwarding_rules"
# list_response = { type_name = "ForwardingRuleList", items_field = "items", item_type = "ForwardingRule" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- globalForwardingRules.setLabels ---
# POST projects/{project}/global/forwardingRules/{resource}/setLabels
# Sets the labels on the specified resource. To learn more about labels, read the Labeling resources d
# Request: GlobalSetLabelsRequest
# Response: Operation
# [[operations]]
# discovery_resource = "globalForwardingRules"
# discovery_method = "setLabels"
# rust_name = "setLabels_global_forwarding_rule"
# is_lro = true

# --- globalForwardingRules.get ---
# GET projects/{project}/global/forwardingRules/{forwardingRule}
# Returns the specified GlobalForwardingRule resource. Gets a list of available forwarding rules by ma
# Response: ForwardingRule
# [[operations]]
# discovery_resource = "globalForwardingRules"
# discovery_method = "get"
# rust_name = "get_global_forwarding_rule"

# --- targetHttpProxies.delete ---
# DELETE projects/{project}/global/targetHttpProxies/{targetHttpProxy}
# Deletes the specified TargetHttpProxy resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetHttpProxies"
# discovery_method = "delete"
# rust_name = "delete_target_http_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetHttpProxies.insert ---
# POST projects/{project}/global/targetHttpProxies
# Creates a TargetHttpProxy resource in the specified project using the data included in the request.
# Request: TargetHttpProxy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetHttpProxies"
# discovery_method = "insert"
# rust_name = "create_target_http_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetHttpProxies.list ---
# GET projects/{project}/global/targetHttpProxies
# Retrieves the list of TargetHttpProxy resources available to the specified project.
# Response: TargetHttpProxyList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "targetHttpProxies"
# discovery_method = "list"
# rust_name = "list_target_http_proxies"
# list_response = { type_name = "TargetHttpProxyList", items_field = "items", item_type = "TargetHttpProxy" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- targetHttpProxies.aggregatedList ---
# GET projects/{project}/aggregated/targetHttpProxies
# Retrieves the list of all TargetHttpProxy resources, regional and global, available to the specified
# Response: TargetHttpProxyAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "targetHttpProxies"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_target_http_proxie"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- targetHttpProxies.get ---
# GET projects/{project}/global/targetHttpProxies/{targetHttpProxy}
# Returns the specified TargetHttpProxy resource.
# Response: TargetHttpProxy
# [[operations]]
# discovery_resource = "targetHttpProxies"
# discovery_method = "get"
# rust_name = "get_target_http_proxie"

# --- targetHttpProxies.patch ---
# PATCH projects/{project}/global/targetHttpProxies/{targetHttpProxy}
# Patches the specified TargetHttpProxy resource with the data included in the request. This method su
# Request: TargetHttpProxy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetHttpProxies"
# discovery_method = "patch"
# rust_name = "update_target_http_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetHttpProxies.setUrlMap ---
# POST projects/{project}/targetHttpProxies/{targetHttpProxy}/setUrlMap
# Changes the URL map for TargetHttpProxy.
# Request: UrlMapReference
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetHttpProxies"
# discovery_method = "setUrlMap"
# rust_name = "setUrlMap_target_http_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- httpHealthChecks.testIamPermissions ---
# POST projects/{project}/global/httpHealthChecks/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "httpHealthChecks"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_http_health_check"

# --- httpHealthChecks.insert ---
# POST projects/{project}/global/httpHealthChecks
# Creates a HttpHealthCheck resource in the specified project using the data included in the request.
# Request: HttpHealthCheck
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "httpHealthChecks"
# discovery_method = "insert"
# rust_name = "create_http_health_check"
# is_lro = true
# query_params = ["requestId"]

# --- httpHealthChecks.delete ---
# DELETE projects/{project}/global/httpHealthChecks/{httpHealthCheck}
# Deletes the specified HttpHealthCheck resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "httpHealthChecks"
# discovery_method = "delete"
# rust_name = "delete_http_health_check"
# is_lro = true
# query_params = ["requestId"]

# --- httpHealthChecks.list ---
# GET projects/{project}/global/httpHealthChecks
# Retrieves the list of HttpHealthCheck resources available to the specified project.
# Response: HttpHealthCheckList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "httpHealthChecks"
# discovery_method = "list"
# rust_name = "list_http_health_checks"
# list_response = { type_name = "HttpHealthCheckList", items_field = "items", item_type = "HttpHealthCheck" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- httpHealthChecks.get ---
# GET projects/{project}/global/httpHealthChecks/{httpHealthCheck}
# Returns the specified HttpHealthCheck resource.
# Response: HttpHealthCheck
# [[operations]]
# discovery_resource = "httpHealthChecks"
# discovery_method = "get"
# rust_name = "get_http_health_check"

# --- httpHealthChecks.patch ---
# PATCH projects/{project}/global/httpHealthChecks/{httpHealthCheck}
# Updates a HttpHealthCheck resource in the specified project using the data included in the request. 
# Request: HttpHealthCheck
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "httpHealthChecks"
# discovery_method = "patch"
# rust_name = "update_http_health_check"
# is_lro = true
# query_params = ["requestId"]

# --- httpHealthChecks.update ---
# PUT projects/{project}/global/httpHealthChecks/{httpHealthCheck}
# Updates a HttpHealthCheck resource in the specified project using the data included in the request.
# Request: HttpHealthCheck
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "httpHealthChecks"
# discovery_method = "update"
# rust_name = "update_http_health_check"
# is_lro = true
# query_params = ["requestId"]

# --- images.list ---
# GET projects/{project}/global/images
# Retrieves the list of custom images available to the specified project. Custom images are images you
# Response: ImageList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "images"
# discovery_method = "list"
# rust_name = "list_images"
# list_response = { type_name = "ImageList", items_field = "items", item_type = "Image" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- images.getFromFamily ---
# GET projects/{project}/global/images/family/{family}
# Returns the latest image that is part of an image family and is not deprecated. For more information
# Response: Image
# [[operations]]
# discovery_resource = "images"
# discovery_method = "getFromFamily"
# rust_name = "getFromFamily_image"

# --- images.delete ---
# DELETE projects/{project}/global/images/{image}
# Deletes the specified image.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "images"
# discovery_method = "delete"
# rust_name = "delete_image"
# is_lro = true
# query_params = ["requestId"]

# --- images.get ---
# GET projects/{project}/global/images/{image}
# Returns the specified image.
# Response: Image
# [[operations]]
# discovery_resource = "images"
# discovery_method = "get"
# rust_name = "get_image"

# --- images.insert ---
# POST projects/{project}/global/images
# Creates an image in the specified project using the data included in the request.
# Request: Image
# Response: Operation
# Query params: forceCreate, requestId
# [[operations]]
# discovery_resource = "images"
# discovery_method = "insert"
# rust_name = "create_image"
# is_lro = true
# query_params = ["forceCreate", "requestId"]

# --- images.getIamPolicy ---
# GET projects/{project}/global/images/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "images"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_image"
# query_params = ["optionsRequestedPolicyVersion"]

# --- images.testIamPermissions ---
# POST projects/{project}/global/images/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "images"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_image"

# --- images.setLabels ---
# POST projects/{project}/global/images/{resource}/setLabels
# Sets the labels on an image. To learn more about labels, read theLabeling Resources documentation.
# Request: GlobalSetLabelsRequest
# Response: Operation
# [[operations]]
# discovery_resource = "images"
# discovery_method = "setLabels"
# rust_name = "setLabels_image"
# is_lro = true

# --- images.deprecate ---
# POST projects/{project}/global/images/{image}/deprecate
# Sets the deprecation status of an image. If an empty request body is given, clears the deprecation s
# Request: DeprecationStatus
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "images"
# discovery_method = "deprecate"
# rust_name = "deprecate_image"
# is_lro = true
# query_params = ["requestId"]

# --- images.patch ---
# PATCH projects/{project}/global/images/{image}
# Patches the specified image with the data included in the request. Only the following fields can be 
# Request: Image
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "images"
# discovery_method = "patch"
# rust_name = "update_image"
# is_lro = true
# query_params = ["requestId"]

# --- images.setIamPolicy ---
# POST projects/{project}/global/images/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: GlobalSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "images"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_image"

# --- wireGroups.delete ---
# DELETE projects/{project}/global/crossSiteNetworks/{crossSiteNetwork}/wireGroups/{wireGroup}
# Deletes the specified wire group in the given scope.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "wireGroups"
# discovery_method = "delete"
# rust_name = "delete_wire_group"
# is_lro = true
# query_params = ["requestId"]

# --- wireGroups.insert ---
# POST projects/{project}/global/crossSiteNetworks/{crossSiteNetwork}/wireGroups
# Creates a wire group in the specified project in the given scope using the parameters that are inclu
# Request: WireGroup
# Response: Operation
# Query params: requestId, validateOnly
# [[operations]]
# discovery_resource = "wireGroups"
# discovery_method = "insert"
# rust_name = "create_wire_group"
# is_lro = true
# query_params = ["requestId", "validateOnly"]

# --- wireGroups.get ---
# GET projects/{project}/global/crossSiteNetworks/{crossSiteNetwork}/wireGroups/{wireGroup}
# Gets the specified wire group resource in the given scope.
# Response: WireGroup
# [[operations]]
# discovery_resource = "wireGroups"
# discovery_method = "get"
# rust_name = "get_wire_group"

# --- wireGroups.list ---
# GET projects/{project}/global/crossSiteNetworks/{crossSiteNetwork}/wireGroups
# Lists the wire groups for a project in the given scope.
# Response: WireGroupList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "wireGroups"
# discovery_method = "list"
# rust_name = "list_wire_groups"
# list_response = { type_name = "WireGroupList", items_field = "items", item_type = "WireGroup" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- wireGroups.patch ---
# PATCH projects/{project}/global/crossSiteNetworks/{crossSiteNetwork}/wireGroups/{wireGroup}
# Updates the specified wire group resource with the data included in the request. This method support
# Request: WireGroup
# Response: Operation
# Query params: requestId, updateMask, validateOnly
# [[operations]]
# discovery_resource = "wireGroups"
# discovery_method = "patch"
# rust_name = "update_wire_group"
# is_lro = true
# query_params = ["requestId", "updateMask", "validateOnly"]

# --- advice.calendarMode ---
# POST projects/{project}/regions/{region}/advice/calendarMode
# Advise how, where and when to create the requested amount of instances with specified accelerators, 
# Request: CalendarModeAdviceRequest
# Response: CalendarModeAdviceResponse
# [[operations]]
# discovery_resource = "advice"
# discovery_method = "calendarMode"
# rust_name = "calendarMode_advice"

# --- serviceAttachments.insert ---
# POST projects/{project}/regions/{region}/serviceAttachments
# Creates a ServiceAttachment in the specified project in the given scope using the parameters that ar
# Request: ServiceAttachment
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "serviceAttachments"
# discovery_method = "insert"
# rust_name = "create_service_attachment"
# is_lro = true
# query_params = ["requestId"]

# --- serviceAttachments.delete ---
# DELETE projects/{project}/regions/{region}/serviceAttachments/{serviceAttachment}
# Deletes the specified ServiceAttachment in the given scope
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "serviceAttachments"
# discovery_method = "delete"
# rust_name = "delete_service_attachment"
# is_lro = true
# query_params = ["requestId"]

# --- serviceAttachments.setIamPolicy ---
# POST projects/{project}/regions/{region}/serviceAttachments/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: RegionSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "serviceAttachments"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_service_attachment"

# --- serviceAttachments.aggregatedList ---
# GET projects/{project}/aggregated/serviceAttachments
# Retrieves the list of all ServiceAttachment resources, regional and global, available to the specifi
# Response: ServiceAttachmentAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "serviceAttachments"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_service_attachment"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- serviceAttachments.get ---
# GET projects/{project}/regions/{region}/serviceAttachments/{serviceAttachment}
# Returns the specified ServiceAttachment resource in the given scope.
# Response: ServiceAttachment
# Query params: showNatIps
# [[operations]]
# discovery_resource = "serviceAttachments"
# discovery_method = "get"
# rust_name = "get_service_attachment"
# query_params = ["showNatIps"]

# --- serviceAttachments.patch ---
# PATCH projects/{project}/regions/{region}/serviceAttachments/{serviceAttachment}
# Patches the specified ServiceAttachment resource with the data included in the request. This method 
# Request: ServiceAttachment
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "serviceAttachments"
# discovery_method = "patch"
# rust_name = "update_service_attachment"
# is_lro = true
# query_params = ["requestId"]

# --- serviceAttachments.getIamPolicy ---
# GET projects/{project}/regions/{region}/serviceAttachments/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "serviceAttachments"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_service_attachment"
# query_params = ["optionsRequestedPolicyVersion"]

# --- serviceAttachments.list ---
# GET projects/{project}/regions/{region}/serviceAttachments
# Lists the ServiceAttachments for a project in the given scope.
# Response: ServiceAttachmentList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "serviceAttachments"
# discovery_method = "list"
# rust_name = "list_service_attachments"
# list_response = { type_name = "ServiceAttachmentList", items_field = "items", item_type = "ServiceAttachment" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- serviceAttachments.testIamPermissions ---
# POST projects/{project}/regions/{region}/serviceAttachments/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "serviceAttachments"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_service_attachment"

# --- regionDisks.list ---
# GET projects/{project}/regions/{region}/disks
# Retrieves the list of persistent disks contained within the specified region.
# Response: DiskList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionDisks"
# discovery_method = "list"
# rust_name = "list_region_disks"
# list_response = { type_name = "DiskList", items_field = "items", item_type = "Disk" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionDisks.getIamPolicy ---
# GET projects/{project}/regions/{region}/disks/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "regionDisks"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_region_disk"
# query_params = ["optionsRequestedPolicyVersion"]

# --- regionDisks.removeResourcePolicies ---
# POST projects/{project}/regions/{region}/disks/{disk}/removeResourcePolicies
# Removes resource policies from a regional disk.
# Request: RegionDisksRemoveResourcePoliciesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionDisks"
# discovery_method = "removeResourcePolicies"
# rust_name = "removeResourcePolicies_region_disk"
# is_lro = true
# query_params = ["requestId"]

# --- regionDisks.resize ---
# POST projects/{project}/regions/{region}/disks/{disk}/resize
# Resizes the specified regional persistent disk.
# Request: RegionDisksResizeRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionDisks"
# discovery_method = "resize"
# rust_name = "resize_region_disk"
# is_lro = true
# query_params = ["requestId"]

# --- regionDisks.get ---
# GET projects/{project}/regions/{region}/disks/{disk}
# Returns a specified regional persistent disk.
# Response: Disk
# [[operations]]
# discovery_resource = "regionDisks"
# discovery_method = "get"
# rust_name = "get_region_disk"

# --- regionDisks.setIamPolicy ---
# POST projects/{project}/regions/{region}/disks/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: RegionSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "regionDisks"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_region_disk"

# --- regionDisks.addResourcePolicies ---
# POST projects/{project}/regions/{region}/disks/{disk}/addResourcePolicies
# Adds existing resource policies to a regional disk. You can only add one policy which will be applie
# Request: RegionDisksAddResourcePoliciesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionDisks"
# discovery_method = "addResourcePolicies"
# rust_name = "addResourcePolicies_region_disk"
# is_lro = true
# query_params = ["requestId"]

# --- regionDisks.insert ---
# POST projects/{project}/regions/{region}/disks
# Creates a persistent regional disk in the specified project using the data included in the request.
# Request: Disk
# Response: Operation
# Query params: requestId, sourceImage
# [[operations]]
# discovery_resource = "regionDisks"
# discovery_method = "insert"
# rust_name = "create_region_disk"
# is_lro = true
# query_params = ["requestId", "sourceImage"]

# --- regionDisks.delete ---
# DELETE projects/{project}/regions/{region}/disks/{disk}
# Deletes the specified regional persistent disk. Deleting a regional disk removes all the replicas of
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionDisks"
# discovery_method = "delete"
# rust_name = "delete_region_disk"
# is_lro = true
# query_params = ["requestId"]

# --- regionDisks.update ---
# PATCH projects/{project}/regions/{region}/disks/{disk}
# Update the specified disk with the data included in the request. Update is performed only on selecte
# Request: Disk
# Response: Operation
# Query params: paths (repeated), requestId, updateMask
# [[operations]]
# discovery_resource = "regionDisks"
# discovery_method = "update"
# rust_name = "update_region_disk"
# is_lro = true
# query_params = ["paths", "requestId", "updateMask"]

# --- regionDisks.testIamPermissions ---
# POST projects/{project}/regions/{region}/disks/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "regionDisks"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_region_disk"

# --- regionDisks.stopAsyncReplication ---
# POST projects/{project}/regions/{region}/disks/{disk}/stopAsyncReplication
# Stops asynchronous replication. Can be invoked either on the primary or on the secondary disk.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionDisks"
# discovery_method = "stopAsyncReplication"
# rust_name = "stopAsyncReplication_region_disk"
# is_lro = true
# query_params = ["requestId"]

# --- regionDisks.createSnapshot ---
# POST projects/{project}/regions/{region}/disks/{disk}/createSnapshot
# Creates a snapshot of a specified persistent disk. For regular snapshot creation, consider using sna
# Request: Snapshot
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionDisks"
# discovery_method = "createSnapshot"
# rust_name = "createSnapshot_region_disk"
# is_lro = true
# query_params = ["requestId"]

# --- regionDisks.setLabels ---
# POST projects/{project}/regions/{region}/disks/{resource}/setLabels
# Sets the labels on the target regional disk.
# Request: RegionSetLabelsRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionDisks"
# discovery_method = "setLabels"
# rust_name = "setLabels_region_disk"
# is_lro = true
# query_params = ["requestId"]

# --- regionDisks.bulkInsert ---
# POST projects/{project}/regions/{region}/disks/bulkInsert
# Bulk create a set of disks.
# Request: BulkInsertDiskResource
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionDisks"
# discovery_method = "bulkInsert"
# rust_name = "bulkInsert_region_disk"
# is_lro = true
# query_params = ["requestId"]

# --- regionDisks.startAsyncReplication ---
# POST projects/{project}/regions/{region}/disks/{disk}/startAsyncReplication
# Starts asynchronous replication. Must be invoked on the primary disk.
# Request: RegionDisksStartAsyncReplicationRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionDisks"
# discovery_method = "startAsyncReplication"
# rust_name = "startAsyncReplication_region_disk"
# is_lro = true
# query_params = ["requestId"]

# --- regionDisks.stopGroupAsyncReplication ---
# POST projects/{project}/regions/{region}/disks/stopGroupAsyncReplication
# Stops asynchronous replication for a consistency group of disks. Can be invoked either in the primar
# Request: DisksStopGroupAsyncReplicationResource
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionDisks"
# discovery_method = "stopGroupAsyncReplication"
# rust_name = "stopGroupAsyncReplication_region_disk"
# is_lro = true
# query_params = ["requestId"]

# --- autoscalers.get ---
# GET projects/{project}/zones/{zone}/autoscalers/{autoscaler}
# Returns the specified autoscaler resource.
# Response: Autoscaler
# [[operations]]
# discovery_resource = "autoscalers"
# discovery_method = "get"
# rust_name = "get_autoscaler"

# --- autoscalers.patch ---
# PATCH projects/{project}/zones/{zone}/autoscalers
# Updates an autoscaler in the specified project using the data included in the request. This method s
# Request: Autoscaler
# Response: Operation
# Query params: autoscaler, requestId
# [[operations]]
# discovery_resource = "autoscalers"
# discovery_method = "patch"
# rust_name = "update_autoscaler"
# is_lro = true
# query_params = ["autoscaler", "requestId"]

# --- autoscalers.aggregatedList ---
# GET projects/{project}/aggregated/autoscalers
# Retrieves an aggregated list of autoscalers. To prevent failure, it is recommended that you set the 
# Response: AutoscalerAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "autoscalers"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_autoscaler"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- autoscalers.list ---
# GET projects/{project}/zones/{zone}/autoscalers
# Retrieves a list of autoscalers contained within the specified zone.
# Response: AutoscalerList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "autoscalers"
# discovery_method = "list"
# rust_name = "list_autoscalers"
# list_response = { type_name = "AutoscalerList", items_field = "items", item_type = "Autoscaler" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- autoscalers.update ---
# PUT projects/{project}/zones/{zone}/autoscalers
# Updates an autoscaler in the specified project using the data included in the request.
# Request: Autoscaler
# Response: Operation
# Query params: autoscaler, requestId
# [[operations]]
# discovery_resource = "autoscalers"
# discovery_method = "update"
# rust_name = "update_autoscaler"
# is_lro = true
# query_params = ["autoscaler", "requestId"]

# --- autoscalers.insert ---
# POST projects/{project}/zones/{zone}/autoscalers
# Creates an autoscaler in the specified project using the data included in the request.
# Request: Autoscaler
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "autoscalers"
# discovery_method = "insert"
# rust_name = "create_autoscaler"
# is_lro = true
# query_params = ["requestId"]

# --- autoscalers.testIamPermissions ---
# POST projects/{project}/zones/{zone}/autoscalers/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "autoscalers"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_autoscaler"

# --- autoscalers.delete ---
# DELETE projects/{project}/zones/{zone}/autoscalers/{autoscaler}
# Deletes the specified autoscaler.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "autoscalers"
# discovery_method = "delete"
# rust_name = "delete_autoscaler"
# is_lro = true
# query_params = ["requestId"]

# --- instantSnapshots.setLabels ---
# POST projects/{project}/zones/{zone}/instantSnapshots/{resource}/setLabels
# Sets the labels on a instantSnapshot in the given zone. To learn more about labels, read the Labelin
# Request: ZoneSetLabelsRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instantSnapshots"
# discovery_method = "setLabels"
# rust_name = "setLabels_instant_snapshot"
# is_lro = true
# query_params = ["requestId"]

# --- instantSnapshots.aggregatedList ---
# GET projects/{project}/aggregated/instantSnapshots
# Retrieves an aggregated list of instantSnapshots. To prevent failure, Google recommends that you set
# Response: InstantSnapshotAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "instantSnapshots"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_instant_snapshot"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- instantSnapshots.get ---
# GET projects/{project}/zones/{zone}/instantSnapshots/{instantSnapshot}
# Returns the specified InstantSnapshot resource in the specified zone.
# Response: InstantSnapshot
# [[operations]]
# discovery_resource = "instantSnapshots"
# discovery_method = "get"
# rust_name = "get_instant_snapshot"

# --- instantSnapshots.list ---
# GET projects/{project}/zones/{zone}/instantSnapshots
# Retrieves the list of InstantSnapshot resources contained within the specified zone.
# Response: InstantSnapshotList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "instantSnapshots"
# discovery_method = "list"
# rust_name = "list_instant_snapshots"
# list_response = { type_name = "InstantSnapshotList", items_field = "items", item_type = "InstantSnapshot" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- instantSnapshots.insert ---
# POST projects/{project}/zones/{zone}/instantSnapshots
# Creates an instant snapshot in the specified zone.
# Request: InstantSnapshot
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instantSnapshots"
# discovery_method = "insert"
# rust_name = "create_instant_snapshot"
# is_lro = true
# query_params = ["requestId"]

# --- instantSnapshots.getIamPolicy ---
# GET projects/{project}/zones/{zone}/instantSnapshots/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "instantSnapshots"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_instant_snapshot"
# query_params = ["optionsRequestedPolicyVersion"]

# --- instantSnapshots.setIamPolicy ---
# POST projects/{project}/zones/{zone}/instantSnapshots/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: ZoneSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "instantSnapshots"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_instant_snapshot"

# --- instantSnapshots.testIamPermissions ---
# POST projects/{project}/zones/{zone}/instantSnapshots/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "instantSnapshots"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_instant_snapshot"

# --- instantSnapshots.delete ---
# DELETE projects/{project}/zones/{zone}/instantSnapshots/{instantSnapshot}
# Deletes the specified InstantSnapshot resource. Keep in mind that deleting a single instantSnapshot 
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instantSnapshots"
# discovery_method = "delete"
# rust_name = "delete_instant_snapshot"
# is_lro = true
# query_params = ["requestId"]

# --- interconnectAttachments.aggregatedList ---
# GET projects/{project}/aggregated/interconnectAttachments
# Retrieves an aggregated list of interconnect attachments. To prevent failure, Google recommends that
# Response: InterconnectAttachmentAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "interconnectAttachments"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_interconnect_attachment"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- interconnectAttachments.setLabels ---
# POST projects/{project}/regions/{region}/interconnectAttachments/{resource}/setLabels
# Sets the labels on an InterconnectAttachment. To learn more about labels, read the Labeling Resource
# Request: RegionSetLabelsRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "interconnectAttachments"
# discovery_method = "setLabels"
# rust_name = "setLabels_interconnect_attachment"
# is_lro = true
# query_params = ["requestId"]

# --- interconnectAttachments.insert ---
# POST projects/{project}/regions/{region}/interconnectAttachments
# Creates an InterconnectAttachment in the specified project using the data included in the request.
# Request: InterconnectAttachment
# Response: Operation
# Query params: requestId, validateOnly
# [[operations]]
# discovery_resource = "interconnectAttachments"
# discovery_method = "insert"
# rust_name = "create_interconnect_attachment"
# is_lro = true
# query_params = ["requestId", "validateOnly"]

# --- interconnectAttachments.list ---
# GET projects/{project}/regions/{region}/interconnectAttachments
# Retrieves the list of interconnect attachments contained within the specified region.
# Response: InterconnectAttachmentList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "interconnectAttachments"
# discovery_method = "list"
# rust_name = "list_interconnect_attachments"
# list_response = { type_name = "InterconnectAttachmentList", items_field = "items", item_type = "InterconnectAttachment" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- interconnectAttachments.get ---
# GET projects/{project}/regions/{region}/interconnectAttachments/{interconnectAttachment}
# Returns the specified interconnect attachment.
# Response: InterconnectAttachment
# [[operations]]
# discovery_resource = "interconnectAttachments"
# discovery_method = "get"
# rust_name = "get_interconnect_attachment"

# --- interconnectAttachments.delete ---
# DELETE projects/{project}/regions/{region}/interconnectAttachments/{interconnectAttachment}
# Deletes the specified interconnect attachment.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "interconnectAttachments"
# discovery_method = "delete"
# rust_name = "delete_interconnect_attachment"
# is_lro = true
# query_params = ["requestId"]

# --- interconnectAttachments.patch ---
# PATCH projects/{project}/regions/{region}/interconnectAttachments/{interconnectAttachment}
# Updates the specified interconnect attachment with the data included in the request. This method sup
# Request: InterconnectAttachment
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "interconnectAttachments"
# discovery_method = "patch"
# rust_name = "update_interconnect_attachment"
# is_lro = true
# query_params = ["requestId"]

# --- organizationSecurityPolicies.listAssociations ---
# GET locations/global/securityPolicies/listAssociations
# Lists associations of a specified target, i.e., organization or folder. Use this API to read Cloud A
# Response: OrganizationSecurityPoliciesListAssociationsResponse
# Query params: targetResource
# [[operations]]
# discovery_resource = "organizationSecurityPolicies"
# discovery_method = "listAssociations"
# rust_name = "listAssociations_organization_security_policie"
# query_params = ["targetResource"]

# --- organizationSecurityPolicies.listPreconfiguredExpressionSets ---
# GET locations/global/securityPolicies/listPreconfiguredExpressionSets
# Gets the current list of preconfigured Web Application Firewall (WAF) expressions.
# Response: SecurityPoliciesListPreconfiguredExpressionSetsResponse
# Query params: filter, maxResults, orderBy, pageToken, parentId, returnPartialSuccess
# [[operations]]
# discovery_resource = "organizationSecurityPolicies"
# discovery_method = "listPreconfiguredExpressionSets"
# rust_name = "listPreconfiguredExpressionSets_organization_security_policie"
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "parentId", "returnPartialSuccess"]

# --- organizationSecurityPolicies.addRule ---
# POST locations/global/securityPolicies/{securityPolicy}/addRule
# Inserts a rule into a security policy. Use this API to modify Cloud Armor policies. Previously, alph
# Request: SecurityPolicyRule
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "organizationSecurityPolicies"
# discovery_method = "addRule"
# rust_name = "addRule_organization_security_policie"
# is_lro = true
# query_params = ["requestId"]

# --- organizationSecurityPolicies.insert ---
# POST locations/global/securityPolicies
# Creates a new policy in the specified organization using the data included in the request. Use this 
# Request: SecurityPolicy
# Response: Operation
# Query params: parentId, requestId
# [[operations]]
# discovery_resource = "organizationSecurityPolicies"
# discovery_method = "insert"
# rust_name = "create_organization_security_policie"
# is_lro = true
# query_params = ["parentId", "requestId"]

# --- organizationSecurityPolicies.getAssociation ---
# GET locations/global/securityPolicies/{securityPolicy}/getAssociation
# Gets an association with the specified name. Use this API to read Cloud Armor policies. Previously, 
# Response: SecurityPolicyAssociation
# Query params: name
# [[operations]]
# discovery_resource = "organizationSecurityPolicies"
# discovery_method = "getAssociation"
# rust_name = "getAssociation_organization_security_policie"
# query_params = ["name"]

# --- organizationSecurityPolicies.list ---
# GET locations/global/securityPolicies
# List all the policies that have been configured for the specified organization. Use this API to read
# Response: SecurityPolicyList
# Query params: filter, maxResults, orderBy, pageToken, parentId, returnPartialSuccess
# [[operations]]
# discovery_resource = "organizationSecurityPolicies"
# discovery_method = "list"
# rust_name = "list_organization_security_policies"
# list_response = { type_name = "SecurityPolicyList", items_field = "items", item_type = "SecurityPolicy" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "parentId", "returnPartialSuccess"]

# --- organizationSecurityPolicies.removeAssociation ---
# POST locations/global/securityPolicies/{securityPolicy}/removeAssociation
# Removes an association for the specified security policy. Use this API to modify Cloud Armor policie
# Response: Operation
# Query params: name, requestId
# [[operations]]
# discovery_resource = "organizationSecurityPolicies"
# discovery_method = "removeAssociation"
# rust_name = "removeAssociation_organization_security_policie"
# is_lro = true
# query_params = ["name", "requestId"]

# --- organizationSecurityPolicies.patchRule ---
# POST locations/global/securityPolicies/{securityPolicy}/patchRule
# Patches a rule at the specified priority. Use this API to modify Cloud Armor policies. Previously, a
# Request: SecurityPolicyRule
# Response: Operation
# Query params: priority, requestId
# [[operations]]
# discovery_resource = "organizationSecurityPolicies"
# discovery_method = "patchRule"
# rust_name = "patchRule_organization_security_policie"
# is_lro = true
# query_params = ["priority", "requestId"]

# --- organizationSecurityPolicies.move ---
# POST locations/global/securityPolicies/{securityPolicy}/move
# Moves the specified security policy. Use this API to modify Cloud Armor policies. Previously, alpha 
# Response: Operation
# Query params: parentId, requestId
# [[operations]]
# discovery_resource = "organizationSecurityPolicies"
# discovery_method = "move"
# rust_name = "move_organization_security_policie"
# is_lro = true
# query_params = ["parentId", "requestId"]

# --- organizationSecurityPolicies.copyRules ---
# POST locations/global/securityPolicies/{securityPolicy}/copyRules
# Copies rules to the specified security policy. Use this API to modify Cloud Armor policies. Previous
# Response: Operation
# Query params: requestId, sourceSecurityPolicy
# [[operations]]
# discovery_resource = "organizationSecurityPolicies"
# discovery_method = "copyRules"
# rust_name = "copyRules_organization_security_policie"
# is_lro = true
# query_params = ["requestId", "sourceSecurityPolicy"]

# --- organizationSecurityPolicies.removeRule ---
# POST locations/global/securityPolicies/{securityPolicy}/removeRule
# Deletes a rule at the specified priority. Use this API to modify Cloud Armor policies. Previously, a
# Response: Operation
# Query params: priority, requestId
# [[operations]]
# discovery_resource = "organizationSecurityPolicies"
# discovery_method = "removeRule"
# rust_name = "removeRule_organization_security_policie"
# is_lro = true
# query_params = ["priority", "requestId"]

# --- organizationSecurityPolicies.patch ---
# PATCH locations/global/securityPolicies/{securityPolicy}
# Patches the specified policy with the data included in the request. Use this API to modify Cloud Arm
# Request: SecurityPolicy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "organizationSecurityPolicies"
# discovery_method = "patch"
# rust_name = "update_organization_security_policie"
# is_lro = true
# query_params = ["requestId"]

# --- organizationSecurityPolicies.getRule ---
# GET locations/global/securityPolicies/{securityPolicy}/getRule
# Gets a rule at the specified priority. Use this API to read Cloud Armor policies. Previously, alpha 
# Response: SecurityPolicyRule
# Query params: priority
# [[operations]]
# discovery_resource = "organizationSecurityPolicies"
# discovery_method = "getRule"
# rust_name = "getRule_organization_security_policie"
# query_params = ["priority"]

# --- organizationSecurityPolicies.get ---
# GET locations/global/securityPolicies/{securityPolicy}
# List all of the ordered rules present in a single specified policy. Use this API to read Cloud Armor
# Response: SecurityPolicy
# [[operations]]
# discovery_resource = "organizationSecurityPolicies"
# discovery_method = "get"
# rust_name = "get_organization_security_policie"

# --- organizationSecurityPolicies.delete ---
# DELETE locations/global/securityPolicies/{securityPolicy}
# Deletes the specified policy. Use this API to remove Cloud Armor policies. Previously, alpha and bet
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "organizationSecurityPolicies"
# discovery_method = "delete"
# rust_name = "delete_organization_security_policie"
# is_lro = true
# query_params = ["requestId"]

# --- organizationSecurityPolicies.addAssociation ---
# POST locations/global/securityPolicies/{securityPolicy}/addAssociation
# Inserts an association for the specified security policy. This has billing implications. Projects in
# Request: SecurityPolicyAssociation
# Response: Operation
# Query params: replaceExistingAssociation, requestId
# [[operations]]
# discovery_resource = "organizationSecurityPolicies"
# discovery_method = "addAssociation"
# rust_name = "addAssociation_organization_security_policie"
# is_lro = true
# query_params = ["replaceExistingAssociation", "requestId"]

# --- globalAddresses.testIamPermissions ---
# POST projects/{project}/global/addresses/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "globalAddresses"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_global_addresse"

# --- globalAddresses.move ---
# POST projects/{project}/global/addresses/{address}/move
# Moves the specified address resource from one project to another project.
# Request: GlobalAddressesMoveRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "globalAddresses"
# discovery_method = "move"
# rust_name = "move_global_addresse"
# is_lro = true
# query_params = ["requestId"]

# --- globalAddresses.list ---
# GET projects/{project}/global/addresses
# Retrieves a list of global addresses.
# Response: AddressList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "globalAddresses"
# discovery_method = "list"
# rust_name = "list_global_addresses"
# list_response = { type_name = "AddressList", items_field = "items", item_type = "Address" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- globalAddresses.delete ---
# DELETE projects/{project}/global/addresses/{address}
# Deletes the specified address resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "globalAddresses"
# discovery_method = "delete"
# rust_name = "delete_global_addresse"
# is_lro = true
# query_params = ["requestId"]

# --- globalAddresses.insert ---
# POST projects/{project}/global/addresses
# Creates an address resource in the specified project by using the data included in the request.
# Request: Address
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "globalAddresses"
# discovery_method = "insert"
# rust_name = "create_global_addresse"
# is_lro = true
# query_params = ["requestId"]

# --- globalAddresses.setLabels ---
# POST projects/{project}/global/addresses/{resource}/setLabels
# Sets the labels on a GlobalAddress. To learn more about labels, read theLabeling Resources documenta
# Request: GlobalSetLabelsRequest
# Response: Operation
# [[operations]]
# discovery_resource = "globalAddresses"
# discovery_method = "setLabels"
# rust_name = "setLabels_global_addresse"
# is_lro = true

# --- globalAddresses.get ---
# GET projects/{project}/global/addresses/{address}
# Returns the specified address resource.
# Response: Address
# [[operations]]
# discovery_resource = "globalAddresses"
# discovery_method = "get"
# rust_name = "get_global_addresse"

# --- externalVpnGateways.get ---
# GET projects/{project}/global/externalVpnGateways/{externalVpnGateway}
# Returns the specified externalVpnGateway. Get a list of available externalVpnGateways by making a li
# Response: ExternalVpnGateway
# [[operations]]
# discovery_resource = "externalVpnGateways"
# discovery_method = "get"
# rust_name = "get_external_vpn_gateway"

# --- externalVpnGateways.list ---
# GET projects/{project}/global/externalVpnGateways
# Retrieves the list of ExternalVpnGateway available to the specified project.
# Response: ExternalVpnGatewayList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "externalVpnGateways"
# discovery_method = "list"
# rust_name = "list_external_vpn_gateways"
# list_response = { type_name = "ExternalVpnGatewayList", items_field = "items", item_type = "ExternalVpnGateway" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- externalVpnGateways.insert ---
# POST projects/{project}/global/externalVpnGateways
# Creates a ExternalVpnGateway in the specified project using the data included in the request.
# Request: ExternalVpnGateway
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "externalVpnGateways"
# discovery_method = "insert"
# rust_name = "create_external_vpn_gateway"
# is_lro = true
# query_params = ["requestId"]

# --- externalVpnGateways.testIamPermissions ---
# POST projects/{project}/global/externalVpnGateways/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "externalVpnGateways"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_external_vpn_gateway"

# --- externalVpnGateways.setLabels ---
# POST projects/{project}/global/externalVpnGateways/{resource}/setLabels
# Sets the labels on an ExternalVpnGateway. To learn more about labels, read the Labeling Resources do
# Request: GlobalSetLabelsRequest
# Response: Operation
# [[operations]]
# discovery_resource = "externalVpnGateways"
# discovery_method = "setLabels"
# rust_name = "setLabels_external_vpn_gateway"
# is_lro = true

# --- externalVpnGateways.delete ---
# DELETE projects/{project}/global/externalVpnGateways/{externalVpnGateway}
# Deletes the specified externalVpnGateway.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "externalVpnGateways"
# discovery_method = "delete"
# rust_name = "delete_external_vpn_gateway"
# is_lro = true
# query_params = ["requestId"]

# --- nodeTemplates.get ---
# GET projects/{project}/regions/{region}/nodeTemplates/{nodeTemplate}
# Returns the specified node template.
# Response: NodeTemplate
# [[operations]]
# discovery_resource = "nodeTemplates"
# discovery_method = "get"
# rust_name = "get_node_template"

# --- nodeTemplates.delete ---
# DELETE projects/{project}/regions/{region}/nodeTemplates/{nodeTemplate}
# Deletes the specified NodeTemplate resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "nodeTemplates"
# discovery_method = "delete"
# rust_name = "delete_node_template"
# is_lro = true
# query_params = ["requestId"]

# --- nodeTemplates.testIamPermissions ---
# POST projects/{project}/regions/{region}/nodeTemplates/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "nodeTemplates"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_node_template"

# --- nodeTemplates.getIamPolicy ---
# GET projects/{project}/regions/{region}/nodeTemplates/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "nodeTemplates"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_node_template"
# query_params = ["optionsRequestedPolicyVersion"]

# --- nodeTemplates.list ---
# GET projects/{project}/regions/{region}/nodeTemplates
# Retrieves a list of node templates available to the specified project.
# Response: NodeTemplateList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "nodeTemplates"
# discovery_method = "list"
# rust_name = "list_node_templates"
# list_response = { type_name = "NodeTemplateList", items_field = "items", item_type = "NodeTemplate" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- nodeTemplates.insert ---
# POST projects/{project}/regions/{region}/nodeTemplates
# Creates a NodeTemplate resource in the specified project using the data included in the request.
# Request: NodeTemplate
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "nodeTemplates"
# discovery_method = "insert"
# rust_name = "create_node_template"
# is_lro = true
# query_params = ["requestId"]

# --- nodeTemplates.aggregatedList ---
# GET projects/{project}/aggregated/nodeTemplates
# Retrieves an aggregated list of node templates. To prevent failure, Google recommends that you set t
# Response: NodeTemplateAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "nodeTemplates"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_node_template"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- nodeTemplates.setIamPolicy ---
# POST projects/{project}/regions/{region}/nodeTemplates/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: RegionSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "nodeTemplates"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_node_template"

# --- targetGrpcProxies.get ---
# GET projects/{project}/global/targetGrpcProxies/{targetGrpcProxy}
# Returns the specified TargetGrpcProxy resource in the given scope.
# Response: TargetGrpcProxy
# [[operations]]
# discovery_resource = "targetGrpcProxies"
# discovery_method = "get"
# rust_name = "get_target_grpc_proxie"

# --- targetGrpcProxies.patch ---
# PATCH projects/{project}/global/targetGrpcProxies/{targetGrpcProxy}
# Patches the specified TargetGrpcProxy resource with the data included in the request. This method su
# Request: TargetGrpcProxy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetGrpcProxies"
# discovery_method = "patch"
# rust_name = "update_target_grpc_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetGrpcProxies.delete ---
# DELETE projects/{project}/global/targetGrpcProxies/{targetGrpcProxy}
# Deletes the specified TargetGrpcProxy in the given scope
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetGrpcProxies"
# discovery_method = "delete"
# rust_name = "delete_target_grpc_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetGrpcProxies.insert ---
# POST projects/{project}/global/targetGrpcProxies
# Creates a TargetGrpcProxy in the specified project in the given scope using the parameters that are 
# Request: TargetGrpcProxy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetGrpcProxies"
# discovery_method = "insert"
# rust_name = "create_target_grpc_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetGrpcProxies.list ---
# GET projects/{project}/global/targetGrpcProxies
# Lists the TargetGrpcProxies for a project in the given scope.
# Response: TargetGrpcProxyList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "targetGrpcProxies"
# discovery_method = "list"
# rust_name = "list_target_grpc_proxies"
# list_response = { type_name = "TargetGrpcProxyList", items_field = "items", item_type = "TargetGrpcProxy" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- storagePoolTypes.get ---
# GET projects/{project}/zones/{zone}/storagePoolTypes/{storagePoolType}
# Returns the specified storage pool type.
# Response: StoragePoolType
# [[operations]]
# discovery_resource = "storagePoolTypes"
# discovery_method = "get"
# rust_name = "get_storage_pool_type"

# --- storagePoolTypes.list ---
# GET projects/{project}/zones/{zone}/storagePoolTypes
# Retrieves a list of storage pool types available to the specified project.
# Response: StoragePoolTypeList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "storagePoolTypes"
# discovery_method = "list"
# rust_name = "list_storage_pool_types"
# list_response = { type_name = "StoragePoolTypeList", items_field = "items", item_type = "StoragePoolType" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- storagePoolTypes.aggregatedList ---
# GET projects/{project}/aggregated/storagePoolTypes
# Retrieves an aggregated list of storage pool types. To prevent failure, Google recommends that you s
# Response: StoragePoolTypeAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "storagePoolTypes"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_storage_pool_type"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- targetVpnGateways.list ---
# GET projects/{project}/regions/{region}/targetVpnGateways
# Retrieves a list of target VPN gateways available to the specified project and region.
# Response: TargetVpnGatewayList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "targetVpnGateways"
# discovery_method = "list"
# rust_name = "list_target_vpn_gateways"
# list_response = { type_name = "TargetVpnGatewayList", items_field = "items", item_type = "TargetVpnGateway" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- targetVpnGateways.aggregatedList ---
# GET projects/{project}/aggregated/targetVpnGateways
# Retrieves an aggregated list of target VPN gateways. To prevent failure, Google recommends that you 
# Response: TargetVpnGatewayAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "targetVpnGateways"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_target_vpn_gateway"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- targetVpnGateways.get ---
# GET projects/{project}/regions/{region}/targetVpnGateways/{targetVpnGateway}
# Returns the specified target VPN gateway.
# Response: TargetVpnGateway
# [[operations]]
# discovery_resource = "targetVpnGateways"
# discovery_method = "get"
# rust_name = "get_target_vpn_gateway"

# --- targetVpnGateways.delete ---
# DELETE projects/{project}/regions/{region}/targetVpnGateways/{targetVpnGateway}
# Deletes the specified target VPN gateway.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetVpnGateways"
# discovery_method = "delete"
# rust_name = "delete_target_vpn_gateway"
# is_lro = true
# query_params = ["requestId"]

# --- targetVpnGateways.insert ---
# POST projects/{project}/regions/{region}/targetVpnGateways
# Creates a target VPN gateway in the specified project and region using the data included in the requ
# Request: TargetVpnGateway
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetVpnGateways"
# discovery_method = "insert"
# rust_name = "create_target_vpn_gateway"
# is_lro = true
# query_params = ["requestId"]

# --- targetVpnGateways.setLabels ---
# POST projects/{project}/regions/{region}/targetVpnGateways/{resource}/setLabels
# Sets the labels on a TargetVpnGateway. To learn more about labels, read theLabeling Resources docume
# Request: RegionSetLabelsRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetVpnGateways"
# discovery_method = "setLabels"
# rust_name = "setLabels_target_vpn_gateway"
# is_lro = true
# query_params = ["requestId"]

# --- interconnectGroups.testIamPermissions ---
# POST projects/{project}/global/interconnectGroups/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "interconnectGroups"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_interconnect_group"

# --- interconnectGroups.getIamPolicy ---
# GET projects/{project}/global/interconnectGroups/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "interconnectGroups"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_interconnect_group"
# query_params = ["optionsRequestedPolicyVersion"]

# --- interconnectGroups.createMembers ---
# POST projects/{project}/global/interconnectGroups/{interconnectGroup}/createMembers
# Create Interconnects with redundancy by creating them in a specified interconnect group.
# Request: InterconnectGroupsCreateMembersRequest
# Response: Operation
# [[operations]]
# discovery_resource = "interconnectGroups"
# discovery_method = "createMembers"
# rust_name = "createMembers_interconnect_group"
# is_lro = true

# --- interconnectGroups.insert ---
# POST projects/{project}/global/interconnectGroups
# Creates a InterconnectGroup in the specified project in the given scope using the parameters that ar
# Request: InterconnectGroup
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "interconnectGroups"
# discovery_method = "insert"
# rust_name = "create_interconnect_group"
# is_lro = true
# query_params = ["requestId"]

# --- interconnectGroups.list ---
# GET projects/{project}/global/interconnectGroups
# Lists the InterconnectGroups for a project in the given scope.
# Response: InterconnectGroupsListResponse
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "interconnectGroups"
# discovery_method = "list"
# rust_name = "list_interconnect_groups"
# list_response = { type_name = "InterconnectGroupsListResponse", items_field = "items", item_type = "InterconnectGroup" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- interconnectGroups.get ---
# GET projects/{project}/global/interconnectGroups/{interconnectGroup}
# Returns the specified InterconnectGroup resource in the given scope.
# Response: InterconnectGroup
# [[operations]]
# discovery_resource = "interconnectGroups"
# discovery_method = "get"
# rust_name = "get_interconnect_group"

# --- interconnectGroups.delete ---
# DELETE projects/{project}/global/interconnectGroups/{interconnectGroup}
# Deletes the specified InterconnectGroup in the given scope
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "interconnectGroups"
# discovery_method = "delete"
# rust_name = "delete_interconnect_group"
# is_lro = true
# query_params = ["requestId"]

# --- interconnectGroups.patch ---
# PATCH projects/{project}/global/interconnectGroups/{interconnectGroup}
# Patches the specified InterconnectGroup resource with the data included in the request. This method 
# Request: InterconnectGroup
# Response: Operation
# Query params: requestId, updateMask
# [[operations]]
# discovery_resource = "interconnectGroups"
# discovery_method = "patch"
# rust_name = "update_interconnect_group"
# is_lro = true
# query_params = ["requestId", "updateMask"]

# --- interconnectGroups.setIamPolicy ---
# POST projects/{project}/global/interconnectGroups/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: GlobalSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "interconnectGroups"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_interconnect_group"

# --- interconnectGroups.getOperationalStatus ---
# GET projects/{project}/global/interconnectGroups/{interconnectGroup}/getOperationalStatus
# Returns the interconnectStatuses for the specified InterconnectGroup.
# Response: InterconnectGroupsGetOperationalStatusResponse
# [[operations]]
# discovery_resource = "interconnectGroups"
# discovery_method = "getOperationalStatus"
# rust_name = "getOperationalStatus_interconnect_group"

# --- crossSiteNetworks.delete ---
# DELETE projects/{project}/global/crossSiteNetworks/{crossSiteNetwork}
# Deletes the specified cross-site network in the given scope.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "crossSiteNetworks"
# discovery_method = "delete"
# rust_name = "delete_cross_site_network"
# is_lro = true
# query_params = ["requestId"]

# --- crossSiteNetworks.get ---
# GET projects/{project}/global/crossSiteNetworks/{crossSiteNetwork}
# Returns the specified cross-site network in the given scope.
# Response: CrossSiteNetwork
# [[operations]]
# discovery_resource = "crossSiteNetworks"
# discovery_method = "get"
# rust_name = "get_cross_site_network"

# --- crossSiteNetworks.list ---
# GET projects/{project}/global/crossSiteNetworks
# Lists the cross-site networks for a project in the given scope.
# Response: CrossSiteNetworkList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "crossSiteNetworks"
# discovery_method = "list"
# rust_name = "list_cross_site_networks"
# list_response = { type_name = "CrossSiteNetworkList", items_field = "items", item_type = "CrossSiteNetwork" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- crossSiteNetworks.patch ---
# PATCH projects/{project}/global/crossSiteNetworks/{crossSiteNetwork}
# Updates the specified cross-site network with the data included in the request. This method supports
# Request: CrossSiteNetwork
# Response: Operation
# Query params: requestId, updateMask, validateOnly
# [[operations]]
# discovery_resource = "crossSiteNetworks"
# discovery_method = "patch"
# rust_name = "update_cross_site_network"
# is_lro = true
# query_params = ["requestId", "updateMask", "validateOnly"]

# --- crossSiteNetworks.insert ---
# POST projects/{project}/global/crossSiteNetworks
# Creates a cross-site network in the specified project in the given scope using the parameters that a
# Request: CrossSiteNetwork
# Response: Operation
# Query params: requestId, validateOnly
# [[operations]]
# discovery_resource = "crossSiteNetworks"
# discovery_method = "insert"
# rust_name = "create_cross_site_network"
# is_lro = true
# query_params = ["requestId", "validateOnly"]

# --- addresses.insert ---
# POST projects/{project}/regions/{region}/addresses
# Creates an address resource in the specified project by using the data included in the request.
# Request: Address
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "addresses"
# discovery_method = "insert"
# rust_name = "create_addresse"
# is_lro = true
# query_params = ["requestId"]

# --- addresses.get [IN MANIFEST] ---
# GET projects/{project}/regions/{region}/addresses/{address}
# Returns the specified address resource.
# Response: Address
# [[operations]]
# discovery_resource = "addresses"
# discovery_method = "get"
# rust_name = "get_addresse"

# --- addresses.delete [IN MANIFEST] ---
# DELETE projects/{project}/regions/{region}/addresses/{address}
# Deletes the specified address resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "addresses"
# discovery_method = "delete"
# rust_name = "delete_addresse"
# is_lro = true
# query_params = ["requestId"]

# --- addresses.testIamPermissions ---
# POST projects/{project}/regions/{region}/addresses/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "addresses"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_addresse"

# --- addresses.aggregatedList ---
# GET projects/{project}/aggregated/addresses
# Retrieves an aggregated list of addresses. To prevent failure, it is recommended that you set the `r
# Response: AddressAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "addresses"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_addresse"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- addresses.list [IN MANIFEST] ---
# GET projects/{project}/regions/{region}/addresses
# Retrieves a list of addresses contained within the specified region.
# Response: AddressList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "addresses"
# discovery_method = "list"
# rust_name = "list_addresses"
# list_response = { type_name = "AddressList", items_field = "items", item_type = "Address" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- addresses.move ---
# POST projects/{project}/regions/{region}/addresses/{address}/move
# Moves the specified address resource.
# Request: RegionAddressesMoveRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "addresses"
# discovery_method = "move"
# rust_name = "move_addresse"
# is_lro = true
# query_params = ["requestId"]

# --- addresses.setLabels ---
# POST projects/{project}/regions/{region}/addresses/{resource}/setLabels
# Sets the labels on an Address. To learn more about labels, read theLabeling Resources documentation.
# Request: RegionSetLabelsRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "addresses"
# discovery_method = "setLabels"
# rust_name = "setLabels_addresse"
# is_lro = true
# query_params = ["requestId"]

# --- regionHealthCheckServices.insert ---
# POST projects/{project}/regions/{region}/healthCheckServices
# Creates a regional HealthCheckService resource in the specified project and region using the data in
# Request: HealthCheckService
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionHealthCheckServices"
# discovery_method = "insert"
# rust_name = "create_region_health_check_service"
# is_lro = true
# query_params = ["requestId"]

# --- regionHealthCheckServices.testIamPermissions ---
# POST projects/{project}/regions/{region}/healthCheckServices/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "regionHealthCheckServices"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_region_health_check_service"

# --- regionHealthCheckServices.list ---
# GET projects/{project}/regions/{region}/healthCheckServices
# Lists all the HealthCheckService resources that have been configured for the specified project in th
# Response: HealthCheckServicesList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionHealthCheckServices"
# discovery_method = "list"
# rust_name = "list_region_health_check_services"
# list_response = { type_name = "HealthCheckServicesList", items_field = "items", item_type = "HealthCheckService" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionHealthCheckServices.get ---
# GET projects/{project}/regions/{region}/healthCheckServices/{healthCheckService}
# Returns the specified regional HealthCheckService resource.
# Response: HealthCheckService
# [[operations]]
# discovery_resource = "regionHealthCheckServices"
# discovery_method = "get"
# rust_name = "get_region_health_check_service"

# --- regionHealthCheckServices.delete ---
# DELETE projects/{project}/regions/{region}/healthCheckServices/{healthCheckService}
# Deletes the specified regional HealthCheckService.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionHealthCheckServices"
# discovery_method = "delete"
# rust_name = "delete_region_health_check_service"
# is_lro = true
# query_params = ["requestId"]

# --- regionHealthCheckServices.patch ---
# PATCH projects/{project}/regions/{region}/healthCheckServices/{healthCheckService}
# Updates the specified regional HealthCheckService resource with the data included in the request. Th
# Request: HealthCheckService
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionHealthCheckServices"
# discovery_method = "patch"
# rust_name = "update_region_health_check_service"
# is_lro = true
# query_params = ["requestId"]

# --- reservationBlocks.testIamPermissions ---
# POST projects/{project}/zones/{zone}/reservations/{parentResource}/reservationBlocks/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "reservationBlocks"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_reservation_block"

# --- reservationBlocks.list ---
# GET projects/{project}/zones/{zone}/reservations/{reservation}/reservationBlocks
# Retrieves a list of reservation blocks under a single reservation.
# Response: ReservationBlocksListResponse
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "reservationBlocks"
# discovery_method = "list"
# rust_name = "list_reservation_blocks"
# list_response = { type_name = "ReservationBlocksListResponse", items_field = "items", item_type = "ReservationBlock" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- reservationBlocks.setIamPolicy ---
# POST projects/{project}/zones/{zone}/reservations/{parentResource}/reservationBlocks/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: ZoneSetNestedPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "reservationBlocks"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_reservation_block"

# --- reservationBlocks.getIamPolicy ---
# GET projects/{project}/zones/{zone}/reservations/{parentResource}/reservationBlocks/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "reservationBlocks"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_reservation_block"
# query_params = ["optionsRequestedPolicyVersion"]

# --- reservationBlocks.performMaintenance ---
# POST projects/{project}/zones/{zone}/reservations/{reservation}/reservationBlocks/{reservationBlock}/performMaintenance
# Allows customers to perform maintenance on a reservation block
# Request: ReservationsBlocksPerformMaintenanceRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "reservationBlocks"
# discovery_method = "performMaintenance"
# rust_name = "performMaintenance_reservation_block"
# is_lro = true
# query_params = ["requestId"]

# --- reservationBlocks.get ---
# GET projects/{project}/zones/{zone}/reservations/{reservation}/reservationBlocks/{reservationBlock}
# Retrieves information about the specified reservation block.
# Response: ReservationBlocksGetResponse
# Query params: view
# [[operations]]
# discovery_resource = "reservationBlocks"
# discovery_method = "get"
# rust_name = "get_reservation_block"
# query_params = ["view"]

# --- zones.get ---
# GET projects/{project}/zones/{zone}
# Returns the specified Zone resource.
# Response: Zone
# [[operations]]
# discovery_resource = "zones"
# discovery_method = "get"
# rust_name = "get_zone"

# --- zones.list ---
# GET projects/{project}/zones
# Retrieves the list of Zone resources available to the specified project.
# Response: ZoneList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "zones"
# discovery_method = "list"
# rust_name = "list_zones"
# list_response = { type_name = "ZoneList", items_field = "items", item_type = "Zone" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- routers.aggregatedList ---
# GET projects/{project}/aggregated/routers
# Retrieves an aggregated list of routers. To prevent failure, Google recommends that you set the `ret
# Response: RouterAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "routers"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_router"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- routers.insert ---
# POST projects/{project}/regions/{region}/routers
# Creates a Router resource in the specified project and region using the data included in the request
# Request: Router
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "routers"
# discovery_method = "insert"
# rust_name = "create_router"
# is_lro = true
# query_params = ["requestId"]

# --- routers.update ---
# PUT projects/{project}/regions/{region}/routers/{router}
# Updates the specified Router resource with the data included in the request. This method conforms to
# Request: Router
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "routers"
# discovery_method = "update"
# rust_name = "update_router"
# is_lro = true
# query_params = ["requestId"]

# --- routers.updateRoutePolicy ---
# POST projects/{project}/regions/{region}/routers/{router}/updateRoutePolicy
# Updates or creates new Route Policy
# Request: RoutePolicy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "routers"
# discovery_method = "updateRoutePolicy"
# rust_name = "updateRoutePolicy_router"
# is_lro = true
# query_params = ["requestId"]

# --- routers.getNatMappingInfo ---
# GET projects/{project}/regions/{region}/routers/{router}/getNatMappingInfo
# Retrieves runtime Nat mapping information of VM endpoints.
# Response: VmEndpointNatMappingsList
# Query params: filter, maxResults, natName, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "routers"
# discovery_method = "getNatMappingInfo"
# rust_name = "getNatMappingInfo_router"
# list_response = { type_name = "VmEndpointNatMappingsList", items_field = "result", item_type = "VmEndpointNatMappings" }
# query_params = ["filter", "maxResults", "natName", "orderBy", "pageToken", "returnPartialSuccess"]

# --- routers.patchRoutePolicy ---
# POST projects/{project}/regions/{region}/routers/{router}/patchRoutePolicy
# Patches Route Policy
# Request: RoutePolicy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "routers"
# discovery_method = "patchRoutePolicy"
# rust_name = "patchRoutePolicy_router"
# is_lro = true
# query_params = ["requestId"]

# --- routers.listRoutePolicies ---
# GET projects/{project}/regions/{region}/routers/{router}/listRoutePolicies
# Retrieves a list of router route policy subresources available to the specified project.
# Response: RoutersListRoutePolicies
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "routers"
# discovery_method = "listRoutePolicies"
# rust_name = "listRoutePolicies_router"
# list_response = { type_name = "RoutersListRoutePolicies", items_field = "result", item_type = "RoutePolicy" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- routers.get [IN MANIFEST] ---
# GET projects/{project}/regions/{region}/routers/{router}
# Returns the specified Router resource.
# Response: Router
# [[operations]]
# discovery_resource = "routers"
# discovery_method = "get"
# rust_name = "get_router"

# --- routers.patch [IN MANIFEST] ---
# PATCH projects/{project}/regions/{region}/routers/{router}
# Patches the specified Router resource with the data included in the request. This method supportsPAT
# Request: Router
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "routers"
# discovery_method = "patch"
# rust_name = "update_router"
# is_lro = true
# query_params = ["requestId"]

# --- routers.list ---
# GET projects/{project}/regions/{region}/routers
# Retrieves a list of Router resources available to the specified project.
# Response: RouterList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "routers"
# discovery_method = "list"
# rust_name = "list_routers"
# list_response = { type_name = "RouterList", items_field = "items", item_type = "Router" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- routers.getNatIpInfo ---
# GET projects/{project}/regions/{region}/routers/{router}/getNatIpInfo
# Retrieves runtime NAT IP information.
# Response: NatIpInfoResponse
# Query params: natName
# [[operations]]
# discovery_resource = "routers"
# discovery_method = "getNatIpInfo"
# rust_name = "getNatIpInfo_router"
# query_params = ["natName"]

# --- routers.getRoutePolicy ---
# GET projects/{project}/regions/{region}/routers/{router}/getRoutePolicy
# Returns specified Route Policy
# Response: RoutersGetRoutePolicyResponse
# Query params: policy
# [[operations]]
# discovery_resource = "routers"
# discovery_method = "getRoutePolicy"
# rust_name = "getRoutePolicy_router"
# query_params = ["policy"]

# --- routers.preview ---
# POST projects/{project}/regions/{region}/routers/{router}/preview
# Preview fields auto-generated during router create andupdate operations. Calling this method does NO
# Request: Router
# Response: RoutersPreviewResponse
# [[operations]]
# discovery_resource = "routers"
# discovery_method = "preview"
# rust_name = "preview_router"

# --- routers.listBgpRoutes ---
# GET projects/{project}/regions/{region}/routers/{router}/listBgpRoutes
# Retrieves a list of router bgp routes available to the specified project.
# Response: RoutersListBgpRoutes
# Query params: addressFamily, destinationPrefix, filter, maxResults, orderBy, pageToken, peer, policyApplied, returnPartialSuccess, routeType
# [[operations]]
# discovery_resource = "routers"
# discovery_method = "listBgpRoutes"
# rust_name = "listBgpRoutes_router"
# list_response = { type_name = "RoutersListBgpRoutes", items_field = "result", item_type = "BgpRoute" }
# query_params = ["addressFamily", "destinationPrefix", "filter", "maxResults", "orderBy", "pageToken", "peer", "policyApplied", "returnPartialSuccess", "routeType"]

# --- routers.getRouterStatus ---
# GET projects/{project}/regions/{region}/routers/{router}/getRouterStatus
# Retrieves runtime information of the specified router.
# Response: RouterStatusResponse
# [[operations]]
# discovery_resource = "routers"
# discovery_method = "getRouterStatus"
# rust_name = "getRouterStatus_router"

# --- routers.deleteRoutePolicy ---
# POST projects/{project}/regions/{region}/routers/{router}/deleteRoutePolicy
# Deletes Route Policy
# Response: Operation
# Query params: policy, requestId
# [[operations]]
# discovery_resource = "routers"
# discovery_method = "deleteRoutePolicy"
# rust_name = "deleteRoutePolicy_router"
# is_lro = true
# query_params = ["policy", "requestId"]

# --- routers.delete ---
# DELETE projects/{project}/regions/{region}/routers/{router}
# Deletes the specified Router resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "routers"
# discovery_method = "delete"
# rust_name = "delete_router"
# is_lro = true
# query_params = ["requestId"]

# --- acceleratorTypes.aggregatedList ---
# GET projects/{project}/aggregated/acceleratorTypes
# Retrieves an aggregated list of accelerator types. To prevent failure, it is recommended that you se
# Response: AcceleratorTypeAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "acceleratorTypes"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_accelerator_type"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- acceleratorTypes.list ---
# GET projects/{project}/zones/{zone}/acceleratorTypes
# Retrieves a list of accelerator types that are available to the specified project.
# Response: AcceleratorTypeList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "acceleratorTypes"
# discovery_method = "list"
# rust_name = "list_accelerator_types"
# list_response = { type_name = "AcceleratorTypeList", items_field = "items", item_type = "AcceleratorType" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- acceleratorTypes.get ---
# GET projects/{project}/zones/{zone}/acceleratorTypes/{acceleratorType}
# Returns the specified accelerator type.
# Response: AcceleratorType
# [[operations]]
# discovery_resource = "acceleratorTypes"
# discovery_method = "get"
# rust_name = "get_accelerator_type"

# --- networkEndpointGroups.detachNetworkEndpoints ---
# POST projects/{project}/zones/{zone}/networkEndpointGroups/{networkEndpointGroup}/detachNetworkEndpoints
# Detach a list of network endpoints from the specified network endpoint group.
# Request: NetworkEndpointGroupsDetachEndpointsRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "networkEndpointGroups"
# discovery_method = "detachNetworkEndpoints"
# rust_name = "detachNetworkEndpoints_network_endpoint_group"
# is_lro = true
# query_params = ["requestId"]

# --- networkEndpointGroups.listNetworkEndpoints ---
# POST projects/{project}/zones/{zone}/networkEndpointGroups/{networkEndpointGroup}/listNetworkEndpoints
# Lists the network endpoints in the specified network endpoint group.
# Request: NetworkEndpointGroupsListEndpointsRequest
# Response: NetworkEndpointGroupsListNetworkEndpoints
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "networkEndpointGroups"
# discovery_method = "listNetworkEndpoints"
# rust_name = "listNetworkEndpoints_network_endpoint_group"
# list_response = { type_name = "NetworkEndpointGroupsListNetworkEndpoints", items_field = "items", item_type = "NetworkEndpointWithHealthStatus" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- networkEndpointGroups.aggregatedList ---
# GET projects/{project}/aggregated/networkEndpointGroups
# Retrieves the list of network endpoint groups and sorts them by zone. To prevent failure, Google rec
# Response: NetworkEndpointGroupAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "networkEndpointGroups"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_network_endpoint_group"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- networkEndpointGroups.attachNetworkEndpoints ---
# POST projects/{project}/zones/{zone}/networkEndpointGroups/{networkEndpointGroup}/attachNetworkEndpoints
# Attach a list of network endpoints to the specified network endpoint group.
# Request: NetworkEndpointGroupsAttachEndpointsRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "networkEndpointGroups"
# discovery_method = "attachNetworkEndpoints"
# rust_name = "attachNetworkEndpoints_network_endpoint_group"
# is_lro = true
# query_params = ["requestId"]

# --- networkEndpointGroups.testIamPermissions ---
# POST projects/{project}/zones/{zone}/networkEndpointGroups/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "networkEndpointGroups"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_network_endpoint_group"

# --- networkEndpointGroups.insert ---
# POST projects/{project}/zones/{zone}/networkEndpointGroups
# Creates a network endpoint group in the specified project using the parameters that are included in 
# Request: NetworkEndpointGroup
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "networkEndpointGroups"
# discovery_method = "insert"
# rust_name = "create_network_endpoint_group"
# is_lro = true
# query_params = ["requestId"]

# --- networkEndpointGroups.list ---
# GET projects/{project}/zones/{zone}/networkEndpointGroups
# Retrieves the list of network endpoint groups that are located in the specified project and zone.
# Response: NetworkEndpointGroupList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "networkEndpointGroups"
# discovery_method = "list"
# rust_name = "list_network_endpoint_groups"
# list_response = { type_name = "NetworkEndpointGroupList", items_field = "items", item_type = "NetworkEndpointGroup" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- networkEndpointGroups.get ---
# GET projects/{project}/zones/{zone}/networkEndpointGroups/{networkEndpointGroup}
# Returns the specified network endpoint group.
# Response: NetworkEndpointGroup
# [[operations]]
# discovery_resource = "networkEndpointGroups"
# discovery_method = "get"
# rust_name = "get_network_endpoint_group"

# --- networkEndpointGroups.delete ---
# DELETE projects/{project}/zones/{zone}/networkEndpointGroups/{networkEndpointGroup}
# Deletes the specified network endpoint group. The network endpoints in the NEG and the VM instances 
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "networkEndpointGroups"
# discovery_method = "delete"
# rust_name = "delete_network_endpoint_group"
# is_lro = true
# query_params = ["requestId"]

# --- snapshotSettings.patch ---
# PATCH projects/{project}/global/snapshotSettings
# Patch snapshot settings.
# Request: SnapshotSettings
# Response: Operation
# Query params: requestId, updateMask
# [[operations]]
# discovery_resource = "snapshotSettings"
# discovery_method = "patch"
# rust_name = "update_snapshot_setting"
# is_lro = true
# query_params = ["requestId", "updateMask"]

# --- snapshotSettings.get ---
# GET projects/{project}/global/snapshotSettings
# Get snapshot settings.
# Response: SnapshotSettings
# [[operations]]
# discovery_resource = "snapshotSettings"
# discovery_method = "get"
# rust_name = "get_snapshot_setting"

# --- regionUrlMaps.insert ---
# POST projects/{project}/regions/{region}/urlMaps
# Creates a UrlMap resource in the specified project using the data included in the request.
# Request: UrlMap
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionUrlMaps"
# discovery_method = "insert"
# rust_name = "create_region_url_map"
# is_lro = true
# query_params = ["requestId"]

# --- regionUrlMaps.update ---
# PUT projects/{project}/regions/{region}/urlMaps/{urlMap}
# Updates the specified UrlMap resource with the data included in the request.
# Request: UrlMap
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionUrlMaps"
# discovery_method = "update"
# rust_name = "update_region_url_map"
# is_lro = true
# query_params = ["requestId"]

# --- regionUrlMaps.validate ---
# POST projects/{project}/regions/{region}/urlMaps/{urlMap}/validate
# Runs static validation for the UrlMap. In particular, the tests of the provided UrlMap will be run. 
# Request: RegionUrlMapsValidateRequest
# Response: UrlMapsValidateResponse
# [[operations]]
# discovery_resource = "regionUrlMaps"
# discovery_method = "validate"
# rust_name = "validate_region_url_map"

# --- regionUrlMaps.patch ---
# PATCH projects/{project}/regions/{region}/urlMaps/{urlMap}
# Patches the specified UrlMap resource with the data included in the request. This method supportsPAT
# Request: UrlMap
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionUrlMaps"
# discovery_method = "patch"
# rust_name = "update_region_url_map"
# is_lro = true
# query_params = ["requestId"]

# --- regionUrlMaps.list ---
# GET projects/{project}/regions/{region}/urlMaps
# Retrieves the list of UrlMap resources available to the specified project in the specified region.
# Response: UrlMapList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionUrlMaps"
# discovery_method = "list"
# rust_name = "list_region_url_maps"
# list_response = { type_name = "UrlMapList", items_field = "items", item_type = "UrlMap" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionUrlMaps.get ---
# GET projects/{project}/regions/{region}/urlMaps/{urlMap}
# Returns the specified UrlMap resource.
# Response: UrlMap
# [[operations]]
# discovery_resource = "regionUrlMaps"
# discovery_method = "get"
# rust_name = "get_region_url_map"

# --- regionUrlMaps.delete ---
# DELETE projects/{project}/regions/{region}/urlMaps/{urlMap}
# Deletes the specified UrlMap resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionUrlMaps"
# discovery_method = "delete"
# rust_name = "delete_region_url_map"
# is_lro = true
# query_params = ["requestId"]

# --- regionAutoscalers.insert ---
# POST projects/{project}/regions/{region}/autoscalers
# Creates an autoscaler in the specified project using the data included in the request.
# Request: Autoscaler
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionAutoscalers"
# discovery_method = "insert"
# rust_name = "create_region_autoscaler"
# is_lro = true
# query_params = ["requestId"]

# --- regionAutoscalers.testIamPermissions ---
# POST projects/{project}/regions/{region}/autoscalers/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "regionAutoscalers"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_region_autoscaler"

# --- regionAutoscalers.get ---
# GET projects/{project}/regions/{region}/autoscalers/{autoscaler}
# Returns the specified autoscaler.
# Response: Autoscaler
# [[operations]]
# discovery_resource = "regionAutoscalers"
# discovery_method = "get"
# rust_name = "get_region_autoscaler"

# --- regionAutoscalers.patch ---
# PATCH projects/{project}/regions/{region}/autoscalers
# Updates an autoscaler in the specified project using the data included in the request. This method s
# Request: Autoscaler
# Response: Operation
# Query params: autoscaler, requestId
# [[operations]]
# discovery_resource = "regionAutoscalers"
# discovery_method = "patch"
# rust_name = "update_region_autoscaler"
# is_lro = true
# query_params = ["autoscaler", "requestId"]

# --- regionAutoscalers.update ---
# PUT projects/{project}/regions/{region}/autoscalers
# Updates an autoscaler in the specified project using the data included in the request.
# Request: Autoscaler
# Response: Operation
# Query params: autoscaler, requestId
# [[operations]]
# discovery_resource = "regionAutoscalers"
# discovery_method = "update"
# rust_name = "update_region_autoscaler"
# is_lro = true
# query_params = ["autoscaler", "requestId"]

# --- regionAutoscalers.list ---
# GET projects/{project}/regions/{region}/autoscalers
# Retrieves a list of autoscalers contained within the specified region.
# Response: RegionAutoscalerList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionAutoscalers"
# discovery_method = "list"
# rust_name = "list_region_autoscalers"
# list_response = { type_name = "RegionAutoscalerList", items_field = "items", item_type = "Autoscaler" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionAutoscalers.delete ---
# DELETE projects/{project}/regions/{region}/autoscalers/{autoscaler}
# Deletes the specified autoscaler.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionAutoscalers"
# discovery_method = "delete"
# rust_name = "delete_region_autoscaler"
# is_lro = true
# query_params = ["requestId"]

# --- regionSecurityPolicies.setLabels ---
# POST projects/{project}/regions/{region}/securityPolicies/{resource}/setLabels
# Sets the labels on a security policy. To learn more about labels, read the Labeling Resources docume
# Request: RegionSetLabelsRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionSecurityPolicies"
# discovery_method = "setLabels"
# rust_name = "setLabels_region_security_policie"
# is_lro = true
# query_params = ["requestId"]

# --- regionSecurityPolicies.delete ---
# DELETE projects/{project}/regions/{region}/securityPolicies/{securityPolicy}
# Deletes the specified policy.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionSecurityPolicies"
# discovery_method = "delete"
# rust_name = "delete_region_security_policie"
# is_lro = true
# query_params = ["requestId"]

# --- regionSecurityPolicies.getRule ---
# GET projects/{project}/regions/{region}/securityPolicies/{securityPolicy}/getRule
# Gets a rule at the specified priority.
# Response: SecurityPolicyRule
# Query params: priority
# [[operations]]
# discovery_resource = "regionSecurityPolicies"
# discovery_method = "getRule"
# rust_name = "getRule_region_security_policie"
# query_params = ["priority"]

# --- regionSecurityPolicies.patchRule ---
# POST projects/{project}/regions/{region}/securityPolicies/{securityPolicy}/patchRule
# Patches a rule at the specified priority. To clear fields in the rule, leave the fields empty and sp
# Request: SecurityPolicyRule
# Response: Operation
# Query params: priority, updateMask, validateOnly
# [[operations]]
# discovery_resource = "regionSecurityPolicies"
# discovery_method = "patchRule"
# rust_name = "patchRule_region_security_policie"
# is_lro = true
# query_params = ["priority", "updateMask", "validateOnly"]

# --- regionSecurityPolicies.addRule ---
# POST projects/{project}/regions/{region}/securityPolicies/{securityPolicy}/addRule
# Inserts a rule into a security policy.
# Request: SecurityPolicyRule
# Response: Operation
# Query params: validateOnly
# [[operations]]
# discovery_resource = "regionSecurityPolicies"
# discovery_method = "addRule"
# rust_name = "addRule_region_security_policie"
# is_lro = true
# query_params = ["validateOnly"]

# --- regionSecurityPolicies.insert ---
# POST projects/{project}/regions/{region}/securityPolicies
# Creates a new policy in the specified project using the data included in the request.
# Request: SecurityPolicy
# Response: Operation
# Query params: requestId, validateOnly
# [[operations]]
# discovery_resource = "regionSecurityPolicies"
# discovery_method = "insert"
# rust_name = "create_region_security_policie"
# is_lro = true
# query_params = ["requestId", "validateOnly"]

# --- regionSecurityPolicies.get ---
# GET projects/{project}/regions/{region}/securityPolicies/{securityPolicy}
# List all of the ordered rules present in a single specified policy.
# Response: SecurityPolicy
# [[operations]]
# discovery_resource = "regionSecurityPolicies"
# discovery_method = "get"
# rust_name = "get_region_security_policie"

# --- regionSecurityPolicies.patch ---
# PATCH projects/{project}/regions/{region}/securityPolicies/{securityPolicy}
# Patches the specified policy with the data included in the request. To clear fields in the policy, l
# Request: SecurityPolicy
# Response: Operation
# Query params: requestId, updateMask
# [[operations]]
# discovery_resource = "regionSecurityPolicies"
# discovery_method = "patch"
# rust_name = "update_region_security_policie"
# is_lro = true
# query_params = ["requestId", "updateMask"]

# --- regionSecurityPolicies.list ---
# GET projects/{project}/regions/{region}/securityPolicies
# List all the policies that have been configured for the specified project and region.
# Response: SecurityPolicyList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionSecurityPolicies"
# discovery_method = "list"
# rust_name = "list_region_security_policies"
# list_response = { type_name = "SecurityPolicyList", items_field = "items", item_type = "SecurityPolicy" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionSecurityPolicies.removeRule ---
# POST projects/{project}/regions/{region}/securityPolicies/{securityPolicy}/removeRule
# Deletes a rule at the specified priority.
# Response: Operation
# Query params: priority
# [[operations]]
# discovery_resource = "regionSecurityPolicies"
# discovery_method = "removeRule"
# rust_name = "removeRule_region_security_policie"
# is_lro = true
# query_params = ["priority"]

# --- publicDelegatedPrefixes.patch ---
# PATCH projects/{project}/regions/{region}/publicDelegatedPrefixes/{publicDelegatedPrefix}
# Patches the specified PublicDelegatedPrefix resource with the data included in the request. This met
# Request: PublicDelegatedPrefix
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "publicDelegatedPrefixes"
# discovery_method = "patch"
# rust_name = "update_public_delegated_prefixe"
# is_lro = true
# query_params = ["requestId"]

# --- publicDelegatedPrefixes.list ---
# GET projects/{project}/regions/{region}/publicDelegatedPrefixes
# Lists the PublicDelegatedPrefixes for a project in the given region.
# Response: PublicDelegatedPrefixList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "publicDelegatedPrefixes"
# discovery_method = "list"
# rust_name = "list_public_delegated_prefixes"
# list_response = { type_name = "PublicDelegatedPrefixList", items_field = "items", item_type = "PublicDelegatedPrefix" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- publicDelegatedPrefixes.aggregatedList ---
# GET projects/{project}/aggregated/publicDelegatedPrefixes
# Lists all PublicDelegatedPrefix resources owned by the specific project across all scopes. To preven
# Response: PublicDelegatedPrefixAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "publicDelegatedPrefixes"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_public_delegated_prefixe"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- publicDelegatedPrefixes.delete ---
# DELETE projects/{project}/regions/{region}/publicDelegatedPrefixes/{publicDelegatedPrefix}
# Deletes the specified PublicDelegatedPrefix in the given region.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "publicDelegatedPrefixes"
# discovery_method = "delete"
# rust_name = "delete_public_delegated_prefixe"
# is_lro = true
# query_params = ["requestId"]

# --- publicDelegatedPrefixes.insert ---
# POST projects/{project}/regions/{region}/publicDelegatedPrefixes
# Creates a PublicDelegatedPrefix in the specified project in the given region using the parameters th
# Request: PublicDelegatedPrefix
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "publicDelegatedPrefixes"
# discovery_method = "insert"
# rust_name = "create_public_delegated_prefixe"
# is_lro = true
# query_params = ["requestId"]

# --- publicDelegatedPrefixes.withdraw ---
# POST projects/{project}/regions/{region}/publicDelegatedPrefixes/{publicDelegatedPrefix}/withdraw
# Withdraws the specified PublicDelegatedPrefix in the given region.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "publicDelegatedPrefixes"
# discovery_method = "withdraw"
# rust_name = "withdraw_public_delegated_prefixe"
# is_lro = true
# query_params = ["requestId"]

# --- publicDelegatedPrefixes.get ---
# GET projects/{project}/regions/{region}/publicDelegatedPrefixes/{publicDelegatedPrefix}
# Returns the specified PublicDelegatedPrefix resource in the given region.
# Response: PublicDelegatedPrefix
# [[operations]]
# discovery_resource = "publicDelegatedPrefixes"
# discovery_method = "get"
# rust_name = "get_public_delegated_prefixe"

# --- publicDelegatedPrefixes.announce ---
# POST projects/{project}/regions/{region}/publicDelegatedPrefixes/{publicDelegatedPrefix}/announce
# Announces the specified PublicDelegatedPrefix in the given region.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "publicDelegatedPrefixes"
# discovery_method = "announce"
# rust_name = "announce_public_delegated_prefixe"
# is_lro = true
# query_params = ["requestId"]

# --- interconnects.patch ---
# PATCH projects/{project}/global/interconnects/{interconnect}
# Updates the specified Interconnect with the data included in the request. This method supportsPATCH 
# Request: Interconnect
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "interconnects"
# discovery_method = "patch"
# rust_name = "update_interconnect"
# is_lro = true
# query_params = ["requestId"]

# --- interconnects.getDiagnostics ---
# GET projects/{project}/global/interconnects/{interconnect}/getDiagnostics
# Returns the interconnectDiagnostics for the specified Interconnect. In the event of a global outage,
# Response: InterconnectsGetDiagnosticsResponse
# [[operations]]
# discovery_resource = "interconnects"
# discovery_method = "getDiagnostics"
# rust_name = "getDiagnostics_interconnect"

# --- interconnects.getMacsecConfig ---
# GET projects/{project}/global/interconnects/{interconnect}/getMacsecConfig
# Returns the interconnectMacsecConfig for the specified Interconnect.
# Response: InterconnectsGetMacsecConfigResponse
# [[operations]]
# discovery_resource = "interconnects"
# discovery_method = "getMacsecConfig"
# rust_name = "getMacsecConfig_interconnect"

# --- interconnects.setLabels ---
# POST projects/{project}/global/interconnects/{resource}/setLabels
# Sets the labels on an Interconnect. To learn more about labels, read the Labeling Resources document
# Request: GlobalSetLabelsRequest
# Response: Operation
# [[operations]]
# discovery_resource = "interconnects"
# discovery_method = "setLabels"
# rust_name = "setLabels_interconnect"
# is_lro = true

# --- interconnects.delete ---
# DELETE projects/{project}/global/interconnects/{interconnect}
# Deletes the specified Interconnect.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "interconnects"
# discovery_method = "delete"
# rust_name = "delete_interconnect"
# is_lro = true
# query_params = ["requestId"]

# --- interconnects.insert ---
# POST projects/{project}/global/interconnects
# Creates an Interconnect in the specified project using the data included in the request.
# Request: Interconnect
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "interconnects"
# discovery_method = "insert"
# rust_name = "create_interconnect"
# is_lro = true
# query_params = ["requestId"]

# --- interconnects.get ---
# GET projects/{project}/global/interconnects/{interconnect}
# Returns the specified Interconnect. Get a list of available Interconnects by making a list() request
# Response: Interconnect
# [[operations]]
# discovery_resource = "interconnects"
# discovery_method = "get"
# rust_name = "get_interconnect"

# --- interconnects.list ---
# GET projects/{project}/global/interconnects
# Retrieves the list of Interconnects available to the specified project.
# Response: InterconnectList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "interconnects"
# discovery_method = "list"
# rust_name = "list_interconnects"
# list_response = { type_name = "InterconnectList", items_field = "items", item_type = "Interconnect" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- reservationSubBlocks.getIamPolicy ---
# GET projects/{project}/zones/{zone}/{parentResource}/reservationSubBlocks/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "reservationSubBlocks"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_reservation_sub_block"
# query_params = ["optionsRequestedPolicyVersion"]

# --- reservationSubBlocks.testIamPermissions ---
# POST projects/{project}/zones/{zone}/{parentResource}/reservationSubBlocks/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "reservationSubBlocks"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_reservation_sub_block"

# --- reservationSubBlocks.list ---
# GET projects/{project}/zones/{zone}/{parentName}/reservationSubBlocks
# Retrieves a list of reservation subBlocks under a single reservation.
# Response: ReservationSubBlocksListResponse
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "reservationSubBlocks"
# discovery_method = "list"
# rust_name = "list_reservation_sub_blocks"
# list_response = { type_name = "ReservationSubBlocksListResponse", items_field = "items", item_type = "ReservationSubBlock" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- reservationSubBlocks.performMaintenance ---
# POST projects/{project}/zones/{zone}/{parentName}/reservationSubBlocks/{reservationSubBlock}/performMaintenance
# Allows customers to perform maintenance on a reservation subBlock
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "reservationSubBlocks"
# discovery_method = "performMaintenance"
# rust_name = "performMaintenance_reservation_sub_block"
# is_lro = true
# query_params = ["requestId"]

# --- reservationSubBlocks.reportFaulty ---
# POST projects/{project}/zones/{zone}/{parentName}/reservationSubBlocks/{reservationSubBlock}/reportFaulty
# Allows customers to report a faulty subBlock.
# Request: ReservationSubBlocksReportFaultyRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "reservationSubBlocks"
# discovery_method = "reportFaulty"
# rust_name = "reportFaulty_reservation_sub_block"
# is_lro = true
# query_params = ["requestId"]

# --- reservationSubBlocks.setIamPolicy ---
# POST projects/{project}/zones/{zone}/{parentResource}/reservationSubBlocks/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: ZoneSetNestedPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "reservationSubBlocks"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_reservation_sub_block"

# --- reservationSubBlocks.get ---
# GET projects/{project}/zones/{zone}/{parentName}/reservationSubBlocks/{reservationSubBlock}
# Retrieves information about the specified reservation subBlock.
# Response: ReservationSubBlocksGetResponse
# Query params: view
# [[operations]]
# discovery_resource = "reservationSubBlocks"
# discovery_method = "get"
# rust_name = "get_reservation_sub_block"
# query_params = ["view"]

# --- regionBackendServices.getHealth ---
# POST projects/{project}/regions/{region}/backendServices/{backendService}/getHealth
# Gets the most recent health check results for this regional BackendService.
# Request: ResourceGroupReference
# Response: BackendServiceGroupHealth
# [[operations]]
# discovery_resource = "regionBackendServices"
# discovery_method = "getHealth"
# rust_name = "getHealth_region_backend_service"

# --- regionBackendServices.testIamPermissions ---
# POST projects/{project}/regions/{region}/backendServices/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "regionBackendServices"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_region_backend_service"

# --- regionBackendServices.setSecurityPolicy ---
# POST projects/{project}/regions/{region}/backendServices/{backendService}/setSecurityPolicy
# Sets the Google Cloud Armor security policy for the specified backend service. For more information,
# Request: SecurityPolicyReference
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionBackendServices"
# discovery_method = "setSecurityPolicy"
# rust_name = "setSecurityPolicy_region_backend_service"
# is_lro = true
# query_params = ["requestId"]

# --- regionBackendServices.listUsable ---
# GET projects/{project}/regions/{region}/backendServices/listUsable
# Retrieves a list of all usable backend services in the specified project in the given region.
# Response: BackendServiceListUsable
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionBackendServices"
# discovery_method = "listUsable"
# rust_name = "listUsable_region_backend_service"
# list_response = { type_name = "BackendServiceListUsable", items_field = "items", item_type = "BackendService" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionBackendServices.patch ---
# PATCH projects/{project}/regions/{region}/backendServices/{backendService}
# Updates the specified regional BackendService resource with the data included in the request. For mo
# Request: BackendService
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionBackendServices"
# discovery_method = "patch"
# rust_name = "update_region_backend_service"
# is_lro = true
# query_params = ["requestId"]

# --- regionBackendServices.delete [IN MANIFEST] ---
# DELETE projects/{project}/regions/{region}/backendServices/{backendService}
# Deletes the specified regional BackendService resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionBackendServices"
# discovery_method = "delete"
# rust_name = "delete_region_backend_service"
# is_lro = true
# query_params = ["requestId"]

# --- regionBackendServices.setIamPolicy ---
# POST projects/{project}/regions/{region}/backendServices/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: RegionSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "regionBackendServices"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_region_backend_service"

# --- regionBackendServices.get [IN MANIFEST] ---
# GET projects/{project}/regions/{region}/backendServices/{backendService}
# Returns the specified regional BackendService resource.
# Response: BackendService
# [[operations]]
# discovery_resource = "regionBackendServices"
# discovery_method = "get"
# rust_name = "get_region_backend_service"

# --- regionBackendServices.insert ---
# POST projects/{project}/regions/{region}/backendServices
# Creates a regional BackendService resource in the specified project using the data included in the r
# Request: BackendService
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionBackendServices"
# discovery_method = "insert"
# rust_name = "create_region_backend_service"
# is_lro = true
# query_params = ["requestId"]

# --- regionBackendServices.update ---
# PUT projects/{project}/regions/{region}/backendServices/{backendService}
# Updates the specified regional BackendService resource with the data included in the request. For mo
# Request: BackendService
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionBackendServices"
# discovery_method = "update"
# rust_name = "update_region_backend_service"
# is_lro = true
# query_params = ["requestId"]

# --- regionBackendServices.getIamPolicy ---
# GET projects/{project}/regions/{region}/backendServices/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "regionBackendServices"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_region_backend_service"
# query_params = ["optionsRequestedPolicyVersion"]

# --- regionBackendServices.list [IN MANIFEST] ---
# GET projects/{project}/regions/{region}/backendServices
# Retrieves the list of regional BackendService resources available to the specified project in the gi
# Response: BackendServiceList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionBackendServices"
# discovery_method = "list"
# rust_name = "list_region_backend_services"
# list_response = { type_name = "BackendServiceList", items_field = "items", item_type = "BackendService" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- vpnTunnels.delete ---
# DELETE projects/{project}/regions/{region}/vpnTunnels/{vpnTunnel}
# Deletes the specified VpnTunnel resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "vpnTunnels"
# discovery_method = "delete"
# rust_name = "delete_vpn_tunnel"
# is_lro = true
# query_params = ["requestId"]

# --- vpnTunnels.setLabels ---
# POST projects/{project}/regions/{region}/vpnTunnels/{resource}/setLabels
# Sets the labels on a VpnTunnel. To learn more about labels, read theLabeling Resources documentation
# Request: RegionSetLabelsRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "vpnTunnels"
# discovery_method = "setLabels"
# rust_name = "setLabels_vpn_tunnel"
# is_lro = true
# query_params = ["requestId"]

# --- vpnTunnels.aggregatedList ---
# GET projects/{project}/aggregated/vpnTunnels
# Retrieves an aggregated list of VPN tunnels. To prevent failure, Google recommends that you set the 
# Response: VpnTunnelAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "vpnTunnels"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_vpn_tunnel"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- vpnTunnels.insert ---
# POST projects/{project}/regions/{region}/vpnTunnels
# Creates a VpnTunnel resource in the specified project and region using the data included in the requ
# Request: VpnTunnel
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "vpnTunnels"
# discovery_method = "insert"
# rust_name = "create_vpn_tunnel"
# is_lro = true
# query_params = ["requestId"]

# --- vpnTunnels.list ---
# GET projects/{project}/regions/{region}/vpnTunnels
# Retrieves a list of VpnTunnel resources contained in the specified project and region.
# Response: VpnTunnelList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "vpnTunnels"
# discovery_method = "list"
# rust_name = "list_vpn_tunnels"
# list_response = { type_name = "VpnTunnelList", items_field = "items", item_type = "VpnTunnel" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- vpnTunnels.get ---
# GET projects/{project}/regions/{region}/vpnTunnels/{vpnTunnel}
# Returns the specified VpnTunnel resource.
# Response: VpnTunnel
# [[operations]]
# discovery_resource = "vpnTunnels"
# discovery_method = "get"
# rust_name = "get_vpn_tunnel"

# --- interconnectLocations.list ---
# GET projects/{project}/global/interconnectLocations
# Retrieves the list of interconnect locations available to the specified project.
# Response: InterconnectLocationList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "interconnectLocations"
# discovery_method = "list"
# rust_name = "list_interconnect_locations"
# list_response = { type_name = "InterconnectLocationList", items_field = "items", item_type = "InterconnectLocation" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- interconnectLocations.get ---
# GET projects/{project}/global/interconnectLocations/{interconnectLocation}
# Returns the details for the specified interconnect location. Gets a list of available interconnect l
# Response: InterconnectLocation
# [[operations]]
# discovery_resource = "interconnectLocations"
# discovery_method = "get"
# rust_name = "get_interconnect_location"

# --- interconnectAttachmentGroups.setIamPolicy ---
# POST projects/{project}/global/interconnectAttachmentGroups/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: GlobalSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "interconnectAttachmentGroups"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_interconnect_attachment_group"

# --- interconnectAttachmentGroups.get ---
# GET projects/{project}/global/interconnectAttachmentGroups/{interconnectAttachmentGroup}
# Returns the specified InterconnectAttachmentGroup resource in the given scope.
# Response: InterconnectAttachmentGroup
# [[operations]]
# discovery_resource = "interconnectAttachmentGroups"
# discovery_method = "get"
# rust_name = "get_interconnect_attachment_group"

# --- interconnectAttachmentGroups.getOperationalStatus ---
# GET projects/{project}/global/interconnectAttachmentGroups/{interconnectAttachmentGroup}/getOperationalStatus
# Returns the InterconnectAttachmentStatuses for the specified InterconnectAttachmentGroup resource.
# Response: InterconnectAttachmentGroupsGetOperationalStatusResponse
# [[operations]]
# discovery_resource = "interconnectAttachmentGroups"
# discovery_method = "getOperationalStatus"
# rust_name = "getOperationalStatus_interconnect_attachment_group"

# --- interconnectAttachmentGroups.list ---
# GET projects/{project}/global/interconnectAttachmentGroups
# Lists the InterconnectAttachmentGroups for a project in the given scope.
# Response: InterconnectAttachmentGroupsListResponse
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "interconnectAttachmentGroups"
# discovery_method = "list"
# rust_name = "list_interconnect_attachment_groups"
# list_response = { type_name = "InterconnectAttachmentGroupsListResponse", items_field = "items", item_type = "InterconnectAttachmentGroup" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- interconnectAttachmentGroups.patch ---
# PATCH projects/{project}/global/interconnectAttachmentGroups/{interconnectAttachmentGroup}
# Patches the specified InterconnectAttachmentGroup resource with the data included in the request. Th
# Request: InterconnectAttachmentGroup
# Response: Operation
# Query params: requestId, updateMask
# [[operations]]
# discovery_resource = "interconnectAttachmentGroups"
# discovery_method = "patch"
# rust_name = "update_interconnect_attachment_group"
# is_lro = true
# query_params = ["requestId", "updateMask"]

# --- interconnectAttachmentGroups.delete ---
# DELETE projects/{project}/global/interconnectAttachmentGroups/{interconnectAttachmentGroup}
# Deletes the specified InterconnectAttachmentGroup in the given scope
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "interconnectAttachmentGroups"
# discovery_method = "delete"
# rust_name = "delete_interconnect_attachment_group"
# is_lro = true
# query_params = ["requestId"]

# --- interconnectAttachmentGroups.insert ---
# POST projects/{project}/global/interconnectAttachmentGroups
# Creates a InterconnectAttachmentGroup in the specified project in the given scope using the paramete
# Request: InterconnectAttachmentGroup
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "interconnectAttachmentGroups"
# discovery_method = "insert"
# rust_name = "create_interconnect_attachment_group"
# is_lro = true
# query_params = ["requestId"]

# --- interconnectAttachmentGroups.getIamPolicy ---
# GET projects/{project}/global/interconnectAttachmentGroups/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "interconnectAttachmentGroups"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_interconnect_attachment_group"
# query_params = ["optionsRequestedPolicyVersion"]

# --- interconnectAttachmentGroups.testIamPermissions ---
# POST projects/{project}/global/interconnectAttachmentGroups/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "interconnectAttachmentGroups"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_interconnect_attachment_group"

# --- licenseCodes.get ---
# GET projects/{project}/global/licenseCodes/{licenseCode}
# Return a specified license code. License codes are mirrored across all projects that have permission
# Response: LicenseCode
# [[operations]]
# discovery_resource = "licenseCodes"
# discovery_method = "get"
# rust_name = "get_license_code"

# --- licenseCodes.testIamPermissions ---
# POST projects/{project}/global/licenseCodes/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource. *Caution* This resource is intended
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "licenseCodes"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_license_code"

# --- regionTargetHttpsProxies.delete ---
# DELETE projects/{project}/regions/{region}/targetHttpsProxies/{targetHttpsProxy}
# Deletes the specified TargetHttpsProxy resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionTargetHttpsProxies"
# discovery_method = "delete"
# rust_name = "delete_region_target_https_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- regionTargetHttpsProxies.get ---
# GET projects/{project}/regions/{region}/targetHttpsProxies/{targetHttpsProxy}
# Returns the specified TargetHttpsProxy resource in the specified region.
# Response: TargetHttpsProxy
# [[operations]]
# discovery_resource = "regionTargetHttpsProxies"
# discovery_method = "get"
# rust_name = "get_region_target_https_proxie"

# --- regionTargetHttpsProxies.insert ---
# POST projects/{project}/regions/{region}/targetHttpsProxies
# Creates a TargetHttpsProxy resource in the specified project and region using the data included in t
# Request: TargetHttpsProxy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionTargetHttpsProxies"
# discovery_method = "insert"
# rust_name = "create_region_target_https_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- regionTargetHttpsProxies.setSslCertificates ---
# POST projects/{project}/regions/{region}/targetHttpsProxies/{targetHttpsProxy}/setSslCertificates
# Replaces SslCertificates for TargetHttpsProxy.
# Request: RegionTargetHttpsProxiesSetSslCertificatesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionTargetHttpsProxies"
# discovery_method = "setSslCertificates"
# rust_name = "setSslCertificates_region_target_https_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- regionTargetHttpsProxies.list ---
# GET projects/{project}/regions/{region}/targetHttpsProxies
# Retrieves the list of TargetHttpsProxy resources available to the specified project in the specified
# Response: TargetHttpsProxyList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionTargetHttpsProxies"
# discovery_method = "list"
# rust_name = "list_region_target_https_proxies"
# list_response = { type_name = "TargetHttpsProxyList", items_field = "items", item_type = "TargetHttpsProxy" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionTargetHttpsProxies.patch ---
# PATCH projects/{project}/regions/{region}/targetHttpsProxies/{targetHttpsProxy}
# Patches the specified regional TargetHttpsProxy resource with the data included in the request. This
# Request: TargetHttpsProxy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionTargetHttpsProxies"
# discovery_method = "patch"
# rust_name = "update_region_target_https_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- regionTargetHttpsProxies.setUrlMap ---
# POST projects/{project}/regions/{region}/targetHttpsProxies/{targetHttpsProxy}/setUrlMap
# Changes the URL map for TargetHttpsProxy.
# Request: UrlMapReference
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionTargetHttpsProxies"
# discovery_method = "setUrlMap"
# rust_name = "setUrlMap_region_target_https_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- instanceTemplates.list ---
# GET projects/{project}/global/instanceTemplates
# Retrieves a list of instance templates that are contained within the specified project.
# Response: InstanceTemplateList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "instanceTemplates"
# discovery_method = "list"
# rust_name = "list_instance_templates"
# list_response = { type_name = "InstanceTemplateList", items_field = "items", item_type = "InstanceTemplate" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- instanceTemplates.testIamPermissions ---
# POST projects/{project}/global/instanceTemplates/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "instanceTemplates"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_instance_template"

# --- instanceTemplates.aggregatedList ---
# GET projects/{project}/aggregated/instanceTemplates
# Retrieves the list of all InstanceTemplates resources, regional and global, available to the specifi
# Response: InstanceTemplateAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "instanceTemplates"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_instance_template"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- instanceTemplates.setIamPolicy ---
# POST projects/{project}/global/instanceTemplates/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: GlobalSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "instanceTemplates"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_instance_template"

# --- instanceTemplates.insert ---
# POST projects/{project}/global/instanceTemplates
# Creates an instance template in the specified project using the data that is included in the request
# Request: InstanceTemplate
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceTemplates"
# discovery_method = "insert"
# rust_name = "create_instance_template"
# is_lro = true
# query_params = ["requestId"]

# --- instanceTemplates.get ---
# GET projects/{project}/global/instanceTemplates/{instanceTemplate}
# Returns the specified instance template.
# Response: InstanceTemplate
# [[operations]]
# discovery_resource = "instanceTemplates"
# discovery_method = "get"
# rust_name = "get_instance_template"

# --- instanceTemplates.delete ---
# DELETE projects/{project}/global/instanceTemplates/{instanceTemplate}
# Deletes the specified instance template. Deleting an instance template is permanent and cannot be un
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceTemplates"
# discovery_method = "delete"
# rust_name = "delete_instance_template"
# is_lro = true
# query_params = ["requestId"]

# --- instanceTemplates.getIamPolicy ---
# GET projects/{project}/global/instanceTemplates/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "instanceTemplates"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_instance_template"
# query_params = ["optionsRequestedPolicyVersion"]

# --- regionSslCertificates.list ---
# GET projects/{project}/regions/{region}/sslCertificates
# Retrieves the list of SslCertificate resources available to the specified project in the specified r
# Response: SslCertificateList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionSslCertificates"
# discovery_method = "list"
# rust_name = "list_region_ssl_certificates"
# list_response = { type_name = "SslCertificateList", items_field = "items", item_type = "SslCertificate" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionSslCertificates.delete ---
# DELETE projects/{project}/regions/{region}/sslCertificates/{sslCertificate}
# Deletes the specified SslCertificate resource in the region.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionSslCertificates"
# discovery_method = "delete"
# rust_name = "delete_region_ssl_certificate"
# is_lro = true
# query_params = ["requestId"]

# --- regionSslCertificates.get ---
# GET projects/{project}/regions/{region}/sslCertificates/{sslCertificate}
# Returns the specified SslCertificate resource in the specified region. Get a list of available SSL c
# Response: SslCertificate
# [[operations]]
# discovery_resource = "regionSslCertificates"
# discovery_method = "get"
# rust_name = "get_region_ssl_certificate"

# --- regionSslCertificates.insert ---
# POST projects/{project}/regions/{region}/sslCertificates
# Creates a SslCertificate resource in the specified project and region using the data included in the
# Request: SslCertificate
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionSslCertificates"
# discovery_method = "insert"
# rust_name = "create_region_ssl_certificate"
# is_lro = true
# query_params = ["requestId"]

# --- snapshots.setIamPolicy ---
# POST projects/{project}/global/snapshots/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: GlobalSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "snapshots"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_snapshot"

# --- snapshots.list [IN MANIFEST] ---
# GET projects/{project}/global/snapshots
# Retrieves the list of Snapshot resources contained within the specified project.
# Response: SnapshotList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "snapshots"
# discovery_method = "list"
# rust_name = "list_snapshots"
# list_response = { type_name = "SnapshotList", items_field = "items", item_type = "Snapshot" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- snapshots.insert ---
# POST projects/{project}/global/snapshots
# Creates a snapshot in the specified project using the data included in the request. For regular snap
# Request: Snapshot
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "snapshots"
# discovery_method = "insert"
# rust_name = "create_snapshot"
# is_lro = true
# query_params = ["requestId"]

# --- snapshots.testIamPermissions ---
# POST projects/{project}/global/snapshots/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "snapshots"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_snapshot"

# --- snapshots.get [IN MANIFEST] ---
# GET projects/{project}/global/snapshots/{snapshot}
# Returns the specified Snapshot resource.
# Response: Snapshot
# [[operations]]
# discovery_resource = "snapshots"
# discovery_method = "get"
# rust_name = "get_snapshot"

# --- snapshots.getIamPolicy ---
# GET projects/{project}/global/snapshots/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "snapshots"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_snapshot"
# query_params = ["optionsRequestedPolicyVersion"]

# --- snapshots.setLabels ---
# POST projects/{project}/global/snapshots/{resource}/setLabels
# Sets the labels on a snapshot. To learn more about labels, read theLabeling Resources documentation.
# Request: GlobalSetLabelsRequest
# Response: Operation
# [[operations]]
# discovery_resource = "snapshots"
# discovery_method = "setLabels"
# rust_name = "setLabels_snapshot"
# is_lro = true

# --- snapshots.delete [IN MANIFEST] ---
# DELETE projects/{project}/global/snapshots/{snapshot}
# Deletes the specified Snapshot resource. Keep in mind that deleting a single snapshot might not nece
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "snapshots"
# discovery_method = "delete"
# rust_name = "delete_snapshot"
# is_lro = true
# query_params = ["requestId"]

# --- regionHealthChecks.patch ---
# PATCH projects/{project}/regions/{region}/healthChecks/{healthCheck}
# Updates a HealthCheck resource in the specified project using the data included in the request. This
# Request: HealthCheck
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionHealthChecks"
# discovery_method = "patch"
# rust_name = "update_region_health_check"
# is_lro = true
# query_params = ["requestId"]

# --- regionHealthChecks.delete ---
# DELETE projects/{project}/regions/{region}/healthChecks/{healthCheck}
# Deletes the specified HealthCheck resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionHealthChecks"
# discovery_method = "delete"
# rust_name = "delete_region_health_check"
# is_lro = true
# query_params = ["requestId"]

# --- regionHealthChecks.testIamPermissions ---
# POST projects/{project}/regions/{region}/healthChecks/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "regionHealthChecks"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_region_health_check"

# --- regionHealthChecks.update ---
# PUT projects/{project}/regions/{region}/healthChecks/{healthCheck}
# Updates a HealthCheck resource in the specified project using the data included in the request.
# Request: HealthCheck
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionHealthChecks"
# discovery_method = "update"
# rust_name = "update_region_health_check"
# is_lro = true
# query_params = ["requestId"]

# --- regionHealthChecks.list ---
# GET projects/{project}/regions/{region}/healthChecks
# Retrieves the list of HealthCheck resources available to the specified project.
# Response: HealthCheckList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionHealthChecks"
# discovery_method = "list"
# rust_name = "list_region_health_checks"
# list_response = { type_name = "HealthCheckList", items_field = "items", item_type = "HealthCheck" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionHealthChecks.insert ---
# POST projects/{project}/regions/{region}/healthChecks
# Creates a HealthCheck resource in the specified project using the data included in the request.
# Request: HealthCheck
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionHealthChecks"
# discovery_method = "insert"
# rust_name = "create_region_health_check"
# is_lro = true
# query_params = ["requestId"]

# --- regionHealthChecks.get ---
# GET projects/{project}/regions/{region}/healthChecks/{healthCheck}
# Returns the specified HealthCheck resource.
# Response: HealthCheck
# [[operations]]
# discovery_resource = "regionHealthChecks"
# discovery_method = "get"
# rust_name = "get_region_health_check"

# --- targetPools.aggregatedList ---
# GET projects/{project}/aggregated/targetPools
# Retrieves an aggregated list of target pools. To prevent failure, Google recommends that you set the
# Response: TargetPoolAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "targetPools"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_target_pool"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- targetPools.setSecurityPolicy ---
# POST projects/{project}/regions/{region}/targetPools/{targetPool}/setSecurityPolicy
# Sets the Google Cloud Armor security policy for the specified target pool. For more information, see
# Request: SecurityPolicyReference
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetPools"
# discovery_method = "setSecurityPolicy"
# rust_name = "setSecurityPolicy_target_pool"
# is_lro = true
# query_params = ["requestId"]

# --- targetPools.testIamPermissions ---
# POST projects/{project}/regions/{region}/targetPools/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "targetPools"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_target_pool"

# --- targetPools.setBackup ---
# POST projects/{project}/regions/{region}/targetPools/{targetPool}/setBackup
# Changes a backup target pool's configurations.
# Request: TargetReference
# Response: Operation
# Query params: failoverRatio, requestId
# [[operations]]
# discovery_resource = "targetPools"
# discovery_method = "setBackup"
# rust_name = "setBackup_target_pool"
# is_lro = true
# query_params = ["failoverRatio", "requestId"]

# --- targetPools.addInstance ---
# POST projects/{project}/regions/{region}/targetPools/{targetPool}/addInstance
# Adds an instance to a target pool.
# Request: TargetPoolsAddInstanceRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetPools"
# discovery_method = "addInstance"
# rust_name = "addInstance_target_pool"
# is_lro = true
# query_params = ["requestId"]

# --- targetPools.get ---
# GET projects/{project}/regions/{region}/targetPools/{targetPool}
# Returns the specified target pool.
# Response: TargetPool
# [[operations]]
# discovery_resource = "targetPools"
# discovery_method = "get"
# rust_name = "get_target_pool"

# --- targetPools.list ---
# GET projects/{project}/regions/{region}/targetPools
# Retrieves a list of target pools available to the specified project and region.
# Response: TargetPoolList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "targetPools"
# discovery_method = "list"
# rust_name = "list_target_pools"
# list_response = { type_name = "TargetPoolList", items_field = "items", item_type = "TargetPool" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- targetPools.getHealth ---
# POST projects/{project}/regions/{region}/targetPools/{targetPool}/getHealth
# Gets the most recent health check results for each IP for the instance that is referenced by the giv
# Request: InstanceReference
# Response: TargetPoolInstanceHealth
# [[operations]]
# discovery_resource = "targetPools"
# discovery_method = "getHealth"
# rust_name = "getHealth_target_pool"

# --- targetPools.addHealthCheck ---
# POST projects/{project}/regions/{region}/targetPools/{targetPool}/addHealthCheck
# Adds health check URLs to a target pool.
# Request: TargetPoolsAddHealthCheckRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetPools"
# discovery_method = "addHealthCheck"
# rust_name = "addHealthCheck_target_pool"
# is_lro = true
# query_params = ["requestId"]

# --- targetPools.removeHealthCheck ---
# POST projects/{project}/regions/{region}/targetPools/{targetPool}/removeHealthCheck
# Removes health check URL from a target pool.
# Request: TargetPoolsRemoveHealthCheckRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetPools"
# discovery_method = "removeHealthCheck"
# rust_name = "removeHealthCheck_target_pool"
# is_lro = true
# query_params = ["requestId"]

# --- targetPools.removeInstance ---
# POST projects/{project}/regions/{region}/targetPools/{targetPool}/removeInstance
# Removes instance URL from a target pool.
# Request: TargetPoolsRemoveInstanceRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetPools"
# discovery_method = "removeInstance"
# rust_name = "removeInstance_target_pool"
# is_lro = true
# query_params = ["requestId"]

# --- targetPools.insert ---
# POST projects/{project}/regions/{region}/targetPools
# Creates a target pool in the specified project and region using the data included in the request.
# Request: TargetPool
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetPools"
# discovery_method = "insert"
# rust_name = "create_target_pool"
# is_lro = true
# query_params = ["requestId"]

# --- targetPools.delete ---
# DELETE projects/{project}/regions/{region}/targetPools/{targetPool}
# Deletes the specified target pool.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetPools"
# discovery_method = "delete"
# rust_name = "delete_target_pool"
# is_lro = true
# query_params = ["requestId"]

# --- networkFirewallPolicies.testIamPermissions ---
# POST projects/{project}/global/firewallPolicies/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "networkFirewallPolicies"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_network_firewall_policie"

# --- networkFirewallPolicies.addPacketMirroringRule ---
# POST projects/{project}/global/firewallPolicies/{firewallPolicy}/addPacketMirroringRule
# Inserts a packet mirroring rule into a firewall policy.
# Request: FirewallPolicyRule
# Response: Operation
# Query params: maxPriority, minPriority, requestId
# [[operations]]
# discovery_resource = "networkFirewallPolicies"
# discovery_method = "addPacketMirroringRule"
# rust_name = "addPacketMirroringRule_network_firewall_policie"
# is_lro = true
# query_params = ["maxPriority", "minPriority", "requestId"]

# --- networkFirewallPolicies.insert ---
# POST projects/{project}/global/firewallPolicies
# Creates a new policy in the specified project using the data included in the request.
# Request: FirewallPolicy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "networkFirewallPolicies"
# discovery_method = "insert"
# rust_name = "create_network_firewall_policie"
# is_lro = true
# query_params = ["requestId"]

# --- networkFirewallPolicies.removeAssociation ---
# POST projects/{project}/global/firewallPolicies/{firewallPolicy}/removeAssociation
# Removes an association for the specified firewall policy.
# Response: Operation
# Query params: name, requestId
# [[operations]]
# discovery_resource = "networkFirewallPolicies"
# discovery_method = "removeAssociation"
# rust_name = "removeAssociation_network_firewall_policie"
# is_lro = true
# query_params = ["name", "requestId"]

# --- networkFirewallPolicies.list ---
# GET projects/{project}/global/firewallPolicies
# Lists all the policies that have been configured for the specified project.
# Response: FirewallPolicyList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "networkFirewallPolicies"
# discovery_method = "list"
# rust_name = "list_network_firewall_policies"
# list_response = { type_name = "FirewallPolicyList", items_field = "items", item_type = "FirewallPolicy" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- networkFirewallPolicies.getIamPolicy ---
# GET projects/{project}/global/firewallPolicies/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "networkFirewallPolicies"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_network_firewall_policie"
# query_params = ["optionsRequestedPolicyVersion"]

# --- networkFirewallPolicies.patch ---
# PATCH projects/{project}/global/firewallPolicies/{firewallPolicy}
# Patches the specified policy with the data included in the request.
# Request: FirewallPolicy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "networkFirewallPolicies"
# discovery_method = "patch"
# rust_name = "update_network_firewall_policie"
# is_lro = true
# query_params = ["requestId"]

# --- networkFirewallPolicies.getAssociation ---
# GET projects/{project}/global/firewallPolicies/{firewallPolicy}/getAssociation
# Gets an association with the specified name.
# Response: FirewallPolicyAssociation
# Query params: name
# [[operations]]
# discovery_resource = "networkFirewallPolicies"
# discovery_method = "getAssociation"
# rust_name = "getAssociation_network_firewall_policie"
# query_params = ["name"]

# --- networkFirewallPolicies.removePacketMirroringRule ---
# POST projects/{project}/global/firewallPolicies/{firewallPolicy}/removePacketMirroringRule
# Deletes a packet mirroring rule of the specified priority.
# Response: Operation
# Query params: priority, requestId
# [[operations]]
# discovery_resource = "networkFirewallPolicies"
# discovery_method = "removePacketMirroringRule"
# rust_name = "removePacketMirroringRule_network_firewall_policie"
# is_lro = true
# query_params = ["priority", "requestId"]

# --- networkFirewallPolicies.addRule ---
# POST projects/{project}/global/firewallPolicies/{firewallPolicy}/addRule
# Inserts a rule into a firewall policy.
# Request: FirewallPolicyRule
# Response: Operation
# Query params: maxPriority, minPriority, requestId
# [[operations]]
# discovery_resource = "networkFirewallPolicies"
# discovery_method = "addRule"
# rust_name = "addRule_network_firewall_policie"
# is_lro = true
# query_params = ["maxPriority", "minPriority", "requestId"]

# --- networkFirewallPolicies.aggregatedList ---
# GET projects/{project}/aggregated/firewallPolicies
# Retrieves an aggregated list of network firewall policies, listing network firewall policies from al
# Response: NetworkFirewallPolicyAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "networkFirewallPolicies"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_network_firewall_policie"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- networkFirewallPolicies.getPacketMirroringRule ---
# GET projects/{project}/global/firewallPolicies/{firewallPolicy}/getPacketMirroringRule
# Gets a packet mirroring rule of the specified priority.
# Response: FirewallPolicyRule
# Query params: priority
# [[operations]]
# discovery_resource = "networkFirewallPolicies"
# discovery_method = "getPacketMirroringRule"
# rust_name = "getPacketMirroringRule_network_firewall_policie"
# query_params = ["priority"]

# --- networkFirewallPolicies.setIamPolicy ---
# POST projects/{project}/global/firewallPolicies/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: GlobalSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "networkFirewallPolicies"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_network_firewall_policie"

# --- networkFirewallPolicies.addAssociation ---
# POST projects/{project}/global/firewallPolicies/{firewallPolicy}/addAssociation
# Inserts an association for the specified firewall policy.
# Request: FirewallPolicyAssociation
# Response: Operation
# Query params: replaceExistingAssociation, requestId
# [[operations]]
# discovery_resource = "networkFirewallPolicies"
# discovery_method = "addAssociation"
# rust_name = "addAssociation_network_firewall_policie"
# is_lro = true
# query_params = ["replaceExistingAssociation", "requestId"]

# --- networkFirewallPolicies.removeRule ---
# POST projects/{project}/global/firewallPolicies/{firewallPolicy}/removeRule
# Deletes a rule of the specified priority.
# Response: Operation
# Query params: priority, requestId
# [[operations]]
# discovery_resource = "networkFirewallPolicies"
# discovery_method = "removeRule"
# rust_name = "removeRule_network_firewall_policie"
# is_lro = true
# query_params = ["priority", "requestId"]

# --- networkFirewallPolicies.get ---
# GET projects/{project}/global/firewallPolicies/{firewallPolicy}
# Returns the specified network firewall policy.
# Response: FirewallPolicy
# [[operations]]
# discovery_resource = "networkFirewallPolicies"
# discovery_method = "get"
# rust_name = "get_network_firewall_policie"

# --- networkFirewallPolicies.patchRule ---
# POST projects/{project}/global/firewallPolicies/{firewallPolicy}/patchRule
# Patches a rule of the specified priority.
# Request: FirewallPolicyRule
# Response: Operation
# Query params: priority, requestId
# [[operations]]
# discovery_resource = "networkFirewallPolicies"
# discovery_method = "patchRule"
# rust_name = "patchRule_network_firewall_policie"
# is_lro = true
# query_params = ["priority", "requestId"]

# --- networkFirewallPolicies.delete ---
# DELETE projects/{project}/global/firewallPolicies/{firewallPolicy}
# Deletes the specified policy.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "networkFirewallPolicies"
# discovery_method = "delete"
# rust_name = "delete_network_firewall_policie"
# is_lro = true
# query_params = ["requestId"]

# --- networkFirewallPolicies.patchPacketMirroringRule ---
# POST projects/{project}/global/firewallPolicies/{firewallPolicy}/patchPacketMirroringRule
# Patches a packet mirroring rule of the specified priority.
# Request: FirewallPolicyRule
# Response: Operation
# Query params: priority, requestId
# [[operations]]
# discovery_resource = "networkFirewallPolicies"
# discovery_method = "patchPacketMirroringRule"
# rust_name = "patchPacketMirroringRule_network_firewall_policie"
# is_lro = true
# query_params = ["priority", "requestId"]

# --- networkFirewallPolicies.cloneRules ---
# POST projects/{project}/global/firewallPolicies/{firewallPolicy}/cloneRules
# Copies rules to the specified firewall policy.
# Response: Operation
# Query params: requestId, sourceFirewallPolicy
# [[operations]]
# discovery_resource = "networkFirewallPolicies"
# discovery_method = "cloneRules"
# rust_name = "cloneRules_network_firewall_policie"
# is_lro = true
# query_params = ["requestId", "sourceFirewallPolicy"]

# --- networkFirewallPolicies.getRule ---
# GET projects/{project}/global/firewallPolicies/{firewallPolicy}/getRule
# Gets a rule of the specified priority.
# Response: FirewallPolicyRule
# Query params: priority
# [[operations]]
# discovery_resource = "networkFirewallPolicies"
# discovery_method = "getRule"
# rust_name = "getRule_network_firewall_policie"
# query_params = ["priority"]

# --- regionNetworkEndpointGroups.get ---
# GET projects/{project}/regions/{region}/networkEndpointGroups/{networkEndpointGroup}
# Returns the specified network endpoint group.
# Response: NetworkEndpointGroup
# [[operations]]
# discovery_resource = "regionNetworkEndpointGroups"
# discovery_method = "get"
# rust_name = "get_region_network_endpoint_group"

# --- regionNetworkEndpointGroups.list ---
# GET projects/{project}/regions/{region}/networkEndpointGroups
# Retrieves the list of regional network endpoint groups available to the specified project in the giv
# Response: NetworkEndpointGroupList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionNetworkEndpointGroups"
# discovery_method = "list"
# rust_name = "list_region_network_endpoint_groups"
# list_response = { type_name = "NetworkEndpointGroupList", items_field = "items", item_type = "NetworkEndpointGroup" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionNetworkEndpointGroups.insert ---
# POST projects/{project}/regions/{region}/networkEndpointGroups
# Creates a network endpoint group in the specified project using the parameters that are included in 
# Request: NetworkEndpointGroup
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionNetworkEndpointGroups"
# discovery_method = "insert"
# rust_name = "create_region_network_endpoint_group"
# is_lro = true
# query_params = ["requestId"]

# --- regionNetworkEndpointGroups.listNetworkEndpoints ---
# POST projects/{project}/regions/{region}/networkEndpointGroups/{networkEndpointGroup}/listNetworkEndpoints
# Lists the network endpoints in the specified network endpoint group.
# Response: NetworkEndpointGroupsListNetworkEndpoints
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionNetworkEndpointGroups"
# discovery_method = "listNetworkEndpoints"
# rust_name = "listNetworkEndpoints_region_network_endpoint_group"
# list_response = { type_name = "NetworkEndpointGroupsListNetworkEndpoints", items_field = "items", item_type = "NetworkEndpointWithHealthStatus" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionNetworkEndpointGroups.detachNetworkEndpoints ---
# POST projects/{project}/regions/{region}/networkEndpointGroups/{networkEndpointGroup}/detachNetworkEndpoints
# Detach the network endpoint from the specified network endpoint group.
# Request: RegionNetworkEndpointGroupsDetachEndpointsRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionNetworkEndpointGroups"
# discovery_method = "detachNetworkEndpoints"
# rust_name = "detachNetworkEndpoints_region_network_endpoint_group"
# is_lro = true
# query_params = ["requestId"]

# --- regionNetworkEndpointGroups.delete ---
# DELETE projects/{project}/regions/{region}/networkEndpointGroups/{networkEndpointGroup}
# Deletes the specified network endpoint group. Note that the NEG cannot be deleted if it is configure
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionNetworkEndpointGroups"
# discovery_method = "delete"
# rust_name = "delete_region_network_endpoint_group"
# is_lro = true
# query_params = ["requestId"]

# --- regionNetworkEndpointGroups.attachNetworkEndpoints ---
# POST projects/{project}/regions/{region}/networkEndpointGroups/{networkEndpointGroup}/attachNetworkEndpoints
# Attach a list of network endpoints to the specified network endpoint group.
# Request: RegionNetworkEndpointGroupsAttachEndpointsRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionNetworkEndpointGroups"
# discovery_method = "attachNetworkEndpoints"
# rust_name = "attachNetworkEndpoints_region_network_endpoint_group"
# is_lro = true
# query_params = ["requestId"]

# --- interconnectRemoteLocations.get ---
# GET projects/{project}/global/interconnectRemoteLocations/{interconnectRemoteLocation}
# Returns the details for the specified interconnect remote location. Gets a list of available interco
# Response: InterconnectRemoteLocation
# [[operations]]
# discovery_resource = "interconnectRemoteLocations"
# discovery_method = "get"
# rust_name = "get_interconnect_remote_location"

# --- interconnectRemoteLocations.list ---
# GET projects/{project}/global/interconnectRemoteLocations
# Retrieves the list of interconnect remote locations available to the specified project.
# Response: InterconnectRemoteLocationList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "interconnectRemoteLocations"
# discovery_method = "list"
# rust_name = "list_interconnect_remote_locations"
# list_response = { type_name = "InterconnectRemoteLocationList", items_field = "items", item_type = "InterconnectRemoteLocation" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- storagePools.insert ---
# POST projects/{project}/zones/{zone}/storagePools
# Creates a storage pool in the specified project using the data in the request.
# Request: StoragePool
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "storagePools"
# discovery_method = "insert"
# rust_name = "create_storage_pool"
# is_lro = true
# query_params = ["requestId"]

# --- storagePools.aggregatedList ---
# GET projects/{project}/aggregated/storagePools
# Retrieves an aggregated list of storage pools. To prevent failure, Google recommends that you set th
# Response: StoragePoolAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "storagePools"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_storage_pool"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- storagePools.listDisks ---
# GET projects/{project}/zones/{zone}/storagePools/{storagePool}/listDisks
# Lists the disks in a specified storage pool.
# Response: StoragePoolListDisks
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "storagePools"
# discovery_method = "listDisks"
# rust_name = "listDisks_storage_pool"
# list_response = { type_name = "StoragePoolListDisks", items_field = "items", item_type = "StoragePoolDisk" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- storagePools.get ---
# GET projects/{project}/zones/{zone}/storagePools/{storagePool}
# Returns a specified storage pool. Gets a list of available storage pools by making a list() request.
# Response: StoragePool
# [[operations]]
# discovery_resource = "storagePools"
# discovery_method = "get"
# rust_name = "get_storage_pool"

# --- storagePools.setIamPolicy ---
# POST projects/{project}/zones/{zone}/storagePools/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: ZoneSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "storagePools"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_storage_pool"

# --- storagePools.testIamPermissions ---
# POST projects/{project}/zones/{zone}/storagePools/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "storagePools"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_storage_pool"

# --- storagePools.delete ---
# DELETE projects/{project}/zones/{zone}/storagePools/{storagePool}
# Deletes the specified storage pool. Deleting a storagePool removes its data permanently and is irrev
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "storagePools"
# discovery_method = "delete"
# rust_name = "delete_storage_pool"
# is_lro = true
# query_params = ["requestId"]

# --- storagePools.getIamPolicy ---
# GET projects/{project}/zones/{zone}/storagePools/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "storagePools"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_storage_pool"
# query_params = ["optionsRequestedPolicyVersion"]

# --- storagePools.update ---
# PATCH projects/{project}/zones/{zone}/storagePools/{storagePool}
# Updates the specified storagePool with the data included in the request. The update is performed onl
# Request: StoragePool
# Response: Operation
# Query params: requestId, updateMask
# [[operations]]
# discovery_resource = "storagePools"
# discovery_method = "update"
# rust_name = "update_storage_pool"
# is_lro = true
# query_params = ["requestId", "updateMask"]

# --- storagePools.list ---
# GET projects/{project}/zones/{zone}/storagePools
# Retrieves a list of storage pools contained within the specified zone.
# Response: StoragePoolList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "storagePools"
# discovery_method = "list"
# rust_name = "list_storage_pools"
# list_response = { type_name = "StoragePoolList", items_field = "items", item_type = "StoragePool" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- previewFeatures.get ---
# GET projects/{project}/global/previewFeatures/{previewFeature}
# Returns the details of the given PreviewFeature.
# Response: PreviewFeature
# [[operations]]
# discovery_resource = "previewFeatures"
# discovery_method = "get"
# rust_name = "get_preview_feature"

# --- previewFeatures.update ---
# PATCH projects/{project}/global/previewFeatures/{previewFeature}
# Patches the given PreviewFeature. This method is used to enable or disable a PreviewFeature.
# Request: PreviewFeature
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "previewFeatures"
# discovery_method = "update"
# rust_name = "update_preview_feature"
# is_lro = true
# query_params = ["requestId"]

# --- previewFeatures.list ---
# GET projects/{project}/global/previewFeatures
# Returns the details of the given PreviewFeature.
# Response: PreviewFeatureList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "previewFeatures"
# discovery_method = "list"
# rust_name = "list_preview_features"
# list_response = { type_name = "PreviewFeatureList", items_field = "items", item_type = "PreviewFeature" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionTargetHttpProxies.list ---
# GET projects/{project}/regions/{region}/targetHttpProxies
# Retrieves the list of TargetHttpProxy resources available to the specified project in the specified 
# Response: TargetHttpProxyList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionTargetHttpProxies"
# discovery_method = "list"
# rust_name = "list_region_target_http_proxies"
# list_response = { type_name = "TargetHttpProxyList", items_field = "items", item_type = "TargetHttpProxy" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionTargetHttpProxies.delete ---
# DELETE projects/{project}/regions/{region}/targetHttpProxies/{targetHttpProxy}
# Deletes the specified TargetHttpProxy resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionTargetHttpProxies"
# discovery_method = "delete"
# rust_name = "delete_region_target_http_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- regionTargetHttpProxies.setUrlMap ---
# POST projects/{project}/regions/{region}/targetHttpProxies/{targetHttpProxy}/setUrlMap
# Changes the URL map for TargetHttpProxy.
# Request: UrlMapReference
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionTargetHttpProxies"
# discovery_method = "setUrlMap"
# rust_name = "setUrlMap_region_target_http_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- regionTargetHttpProxies.get ---
# GET projects/{project}/regions/{region}/targetHttpProxies/{targetHttpProxy}
# Returns the specified TargetHttpProxy resource in the specified region.
# Response: TargetHttpProxy
# [[operations]]
# discovery_resource = "regionTargetHttpProxies"
# discovery_method = "get"
# rust_name = "get_region_target_http_proxie"

# --- regionTargetHttpProxies.insert ---
# POST projects/{project}/regions/{region}/targetHttpProxies
# Creates a TargetHttpProxy resource in the specified project and region using the data included in th
# Request: TargetHttpProxy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionTargetHttpProxies"
# discovery_method = "insert"
# rust_name = "create_region_target_http_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetHttpsProxies.get ---
# GET projects/{project}/global/targetHttpsProxies/{targetHttpsProxy}
# Returns the specified TargetHttpsProxy resource.
# Response: TargetHttpsProxy
# [[operations]]
# discovery_resource = "targetHttpsProxies"
# discovery_method = "get"
# rust_name = "get_target_https_proxie"

# --- targetHttpsProxies.list ---
# GET projects/{project}/global/targetHttpsProxies
# Retrieves the list of TargetHttpsProxy resources available to the specified project.
# Response: TargetHttpsProxyList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "targetHttpsProxies"
# discovery_method = "list"
# rust_name = "list_target_https_proxies"
# list_response = { type_name = "TargetHttpsProxyList", items_field = "items", item_type = "TargetHttpsProxy" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- targetHttpsProxies.setSslPolicy ---
# POST projects/{project}/global/targetHttpsProxies/{targetHttpsProxy}/setSslPolicy
# Sets the SSL policy for TargetHttpsProxy. The SSL policy specifies the server-side support for SSL f
# Request: SslPolicyReference
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetHttpsProxies"
# discovery_method = "setSslPolicy"
# rust_name = "setSslPolicy_target_https_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetHttpsProxies.insert ---
# POST projects/{project}/global/targetHttpsProxies
# Creates a TargetHttpsProxy resource in the specified project using the data included in the request.
# Request: TargetHttpsProxy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetHttpsProxies"
# discovery_method = "insert"
# rust_name = "create_target_https_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetHttpsProxies.delete ---
# DELETE projects/{project}/global/targetHttpsProxies/{targetHttpsProxy}
# Deletes the specified TargetHttpsProxy resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetHttpsProxies"
# discovery_method = "delete"
# rust_name = "delete_target_https_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetHttpsProxies.setSslCertificates ---
# POST projects/{project}/targetHttpsProxies/{targetHttpsProxy}/setSslCertificates
# Replaces SslCertificates for TargetHttpsProxy.
# Request: TargetHttpsProxiesSetSslCertificatesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetHttpsProxies"
# discovery_method = "setSslCertificates"
# rust_name = "setSslCertificates_target_https_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetHttpsProxies.setQuicOverride ---
# POST projects/{project}/global/targetHttpsProxies/{targetHttpsProxy}/setQuicOverride
# Sets the QUIC override policy for TargetHttpsProxy.
# Request: TargetHttpsProxiesSetQuicOverrideRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetHttpsProxies"
# discovery_method = "setQuicOverride"
# rust_name = "setQuicOverride_target_https_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetHttpsProxies.setCertificateMap ---
# POST projects/{project}/global/targetHttpsProxies/{targetHttpsProxy}/setCertificateMap
# Changes the Certificate Map for TargetHttpsProxy.
# Request: TargetHttpsProxiesSetCertificateMapRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetHttpsProxies"
# discovery_method = "setCertificateMap"
# rust_name = "setCertificateMap_target_https_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetHttpsProxies.setUrlMap ---
# POST projects/{project}/targetHttpsProxies/{targetHttpsProxy}/setUrlMap
# Changes the URL map for TargetHttpsProxy.
# Request: UrlMapReference
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetHttpsProxies"
# discovery_method = "setUrlMap"
# rust_name = "setUrlMap_target_https_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetHttpsProxies.aggregatedList ---
# GET projects/{project}/aggregated/targetHttpsProxies
# Retrieves the list of all TargetHttpsProxy resources, regional and global, available to the specifie
# Response: TargetHttpsProxyAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "targetHttpsProxies"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_target_https_proxie"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- targetHttpsProxies.patch ---
# PATCH projects/{project}/global/targetHttpsProxies/{targetHttpsProxy}
# Patches the specified TargetHttpsProxy resource with the data included in the request. This method s
# Request: TargetHttpsProxy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetHttpsProxies"
# discovery_method = "patch"
# rust_name = "update_target_https_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- resourcePolicies.patch ---
# PATCH projects/{project}/regions/{region}/resourcePolicies/{resourcePolicy}
# Modify the specified resource policy.
# Request: ResourcePolicy
# Response: Operation
# Query params: requestId, updateMask
# [[operations]]
# discovery_resource = "resourcePolicies"
# discovery_method = "patch"
# rust_name = "update_resource_policie"
# is_lro = true
# query_params = ["requestId", "updateMask"]

# --- resourcePolicies.setIamPolicy ---
# POST projects/{project}/regions/{region}/resourcePolicies/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: RegionSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "resourcePolicies"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_resource_policie"

# --- resourcePolicies.list ---
# GET projects/{project}/regions/{region}/resourcePolicies
# A list all the resource policies that have been configured for the specified project in specified re
# Response: ResourcePolicyList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "resourcePolicies"
# discovery_method = "list"
# rust_name = "list_resource_policies"
# list_response = { type_name = "ResourcePolicyList", items_field = "items", item_type = "ResourcePolicy" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- resourcePolicies.getIamPolicy ---
# GET projects/{project}/regions/{region}/resourcePolicies/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "resourcePolicies"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_resource_policie"
# query_params = ["optionsRequestedPolicyVersion"]

# --- resourcePolicies.get ---
# GET projects/{project}/regions/{region}/resourcePolicies/{resourcePolicy}
# Retrieves all information of the specified resource policy.
# Response: ResourcePolicy
# [[operations]]
# discovery_resource = "resourcePolicies"
# discovery_method = "get"
# rust_name = "get_resource_policie"

# --- resourcePolicies.delete ---
# DELETE projects/{project}/regions/{region}/resourcePolicies/{resourcePolicy}
# Deletes the specified resource policy.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "resourcePolicies"
# discovery_method = "delete"
# rust_name = "delete_resource_policie"
# is_lro = true
# query_params = ["requestId"]

# --- resourcePolicies.testIamPermissions ---
# POST projects/{project}/regions/{region}/resourcePolicies/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "resourcePolicies"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_resource_policie"

# --- resourcePolicies.insert ---
# POST projects/{project}/regions/{region}/resourcePolicies
# Creates a new resource policy.
# Request: ResourcePolicy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "resourcePolicies"
# discovery_method = "insert"
# rust_name = "create_resource_policie"
# is_lro = true
# query_params = ["requestId"]

# --- resourcePolicies.aggregatedList ---
# GET projects/{project}/aggregated/resourcePolicies
# Retrieves an aggregated list of resource policies. To prevent failure, Google recommends that you se
# Response: ResourcePolicyAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "resourcePolicies"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_resource_policie"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- licenses.insert ---
# POST projects/{project}/global/licenses
# Create a License resource in the specified project. *Caution* This resource is intended for use only
# Request: License
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "licenses"
# discovery_method = "insert"
# rust_name = "create_license"
# is_lro = true
# query_params = ["requestId"]

# --- licenses.list ---
# GET projects/{project}/global/licenses
# Retrieves the list of licenses available in the specified project. This method does not get any lice
# Response: LicensesListResponse
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "licenses"
# discovery_method = "list"
# rust_name = "list_licenses"
# list_response = { type_name = "LicensesListResponse", items_field = "items", item_type = "License" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- licenses.get ---
# GET projects/{project}/global/licenses/{license}
# Returns the specified License resource. *Caution* This resource is intended for use only by third-pa
# Response: License
# [[operations]]
# discovery_resource = "licenses"
# discovery_method = "get"
# rust_name = "get_license"

# --- licenses.setIamPolicy ---
# POST projects/{project}/global/licenses/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy. *Caution* Th
# Request: GlobalSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "licenses"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_license"

# --- licenses.update ---
# PATCH projects/{project}/global/licenses/{license}
# Updates a License resource in the specified project. *Caution* This resource is intended for use onl
# Request: License
# Response: Operation
# Query params: requestId, updateMask
# [[operations]]
# discovery_resource = "licenses"
# discovery_method = "update"
# rust_name = "update_license"
# is_lro = true
# query_params = ["requestId", "updateMask"]

# --- licenses.delete ---
# DELETE projects/{project}/global/licenses/{license}
# Deletes the specified license. *Caution* This resource is intended for use only by third-party partn
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "licenses"
# discovery_method = "delete"
# rust_name = "delete_license"
# is_lro = true
# query_params = ["requestId"]

# --- licenses.testIamPermissions ---
# POST projects/{project}/global/licenses/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource. *Caution* This resource is intended
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "licenses"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_license"

# --- licenses.getIamPolicy ---
# GET projects/{project}/global/licenses/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists. *C
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "licenses"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_license"
# query_params = ["optionsRequestedPolicyVersion"]

# --- publicAdvertisedPrefixes.list ---
# GET projects/{project}/global/publicAdvertisedPrefixes
# Lists the PublicAdvertisedPrefixes for a project.
# Response: PublicAdvertisedPrefixList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "publicAdvertisedPrefixes"
# discovery_method = "list"
# rust_name = "list_public_advertised_prefixes"
# list_response = { type_name = "PublicAdvertisedPrefixList", items_field = "items", item_type = "PublicAdvertisedPrefix" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- publicAdvertisedPrefixes.announce ---
# POST projects/{project}/global/publicAdvertisedPrefixes/{publicAdvertisedPrefix}/announce
# Announces the specified PublicAdvertisedPrefix
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "publicAdvertisedPrefixes"
# discovery_method = "announce"
# rust_name = "announce_public_advertised_prefixe"
# is_lro = true
# query_params = ["requestId"]

# --- publicAdvertisedPrefixes.patch ---
# PATCH projects/{project}/global/publicAdvertisedPrefixes/{publicAdvertisedPrefix}
# Patches the specified Router resource with the data included in the request. This method supportsPAT
# Request: PublicAdvertisedPrefix
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "publicAdvertisedPrefixes"
# discovery_method = "patch"
# rust_name = "update_public_advertised_prefixe"
# is_lro = true
# query_params = ["requestId"]

# --- publicAdvertisedPrefixes.withdraw ---
# POST projects/{project}/global/publicAdvertisedPrefixes/{publicAdvertisedPrefix}/withdraw
# Withdraws the specified PublicAdvertisedPrefix
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "publicAdvertisedPrefixes"
# discovery_method = "withdraw"
# rust_name = "withdraw_public_advertised_prefixe"
# is_lro = true
# query_params = ["requestId"]

# --- publicAdvertisedPrefixes.insert ---
# POST projects/{project}/global/publicAdvertisedPrefixes
# Creates a PublicAdvertisedPrefix in the specified project using the parameters that are included in 
# Request: PublicAdvertisedPrefix
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "publicAdvertisedPrefixes"
# discovery_method = "insert"
# rust_name = "create_public_advertised_prefixe"
# is_lro = true
# query_params = ["requestId"]

# --- publicAdvertisedPrefixes.get ---
# GET projects/{project}/global/publicAdvertisedPrefixes/{publicAdvertisedPrefix}
# Returns the specified PublicAdvertisedPrefix resource.
# Response: PublicAdvertisedPrefix
# [[operations]]
# discovery_resource = "publicAdvertisedPrefixes"
# discovery_method = "get"
# rust_name = "get_public_advertised_prefixe"

# --- publicAdvertisedPrefixes.delete ---
# DELETE projects/{project}/global/publicAdvertisedPrefixes/{publicAdvertisedPrefix}
# Deletes the specified PublicAdvertisedPrefix
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "publicAdvertisedPrefixes"
# discovery_method = "delete"
# rust_name = "delete_public_advertised_prefixe"
# is_lro = true
# query_params = ["requestId"]

# --- backendBuckets.getIamPolicy ---
# GET projects/{project}/global/backendBuckets/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "backendBuckets"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_backend_bucket"
# query_params = ["optionsRequestedPolicyVersion"]

# --- backendBuckets.get ---
# GET projects/{project}/global/backendBuckets/{backendBucket}
# Returns the specified BackendBucket resource.
# Response: BackendBucket
# [[operations]]
# discovery_resource = "backendBuckets"
# discovery_method = "get"
# rust_name = "get_backend_bucket"

# --- backendBuckets.insert ---
# POST projects/{project}/global/backendBuckets
# Creates a BackendBucket resource in the specified project using the data included in the request.
# Request: BackendBucket
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "backendBuckets"
# discovery_method = "insert"
# rust_name = "create_backend_bucket"
# is_lro = true
# query_params = ["requestId"]

# --- backendBuckets.delete ---
# DELETE projects/{project}/global/backendBuckets/{backendBucket}
# Deletes the specified BackendBucket resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "backendBuckets"
# discovery_method = "delete"
# rust_name = "delete_backend_bucket"
# is_lro = true
# query_params = ["requestId"]

# --- backendBuckets.setIamPolicy ---
# POST projects/{project}/global/backendBuckets/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: GlobalSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "backendBuckets"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_backend_bucket"

# --- backendBuckets.deleteSignedUrlKey ---
# POST projects/{project}/global/backendBuckets/{backendBucket}/deleteSignedUrlKey
# Deletes a key for validating requests with signed URLs for this backend bucket.
# Response: Operation
# Query params: keyName, requestId
# [[operations]]
# discovery_resource = "backendBuckets"
# discovery_method = "deleteSignedUrlKey"
# rust_name = "deleteSignedUrlKey_backend_bucket"
# is_lro = true
# query_params = ["keyName", "requestId"]

# --- backendBuckets.testIamPermissions ---
# POST projects/{project}/global/backendBuckets/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "backendBuckets"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_backend_bucket"

# --- backendBuckets.update ---
# PUT projects/{project}/global/backendBuckets/{backendBucket}
# Updates the specified BackendBucket resource with the data included in the request.
# Request: BackendBucket
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "backendBuckets"
# discovery_method = "update"
# rust_name = "update_backend_bucket"
# is_lro = true
# query_params = ["requestId"]

# --- backendBuckets.list ---
# GET projects/{project}/global/backendBuckets
# Retrieves the list of BackendBucket resources available to the specified project.
# Response: BackendBucketList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "backendBuckets"
# discovery_method = "list"
# rust_name = "list_backend_buckets"
# list_response = { type_name = "BackendBucketList", items_field = "items", item_type = "BackendBucket" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- backendBuckets.setEdgeSecurityPolicy ---
# POST projects/{project}/global/backendBuckets/{backendBucket}/setEdgeSecurityPolicy
# Sets the edge security policy for the specified backend bucket.
# Request: SecurityPolicyReference
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "backendBuckets"
# discovery_method = "setEdgeSecurityPolicy"
# rust_name = "setEdgeSecurityPolicy_backend_bucket"
# is_lro = true
# query_params = ["requestId"]

# --- backendBuckets.patch ---
# PATCH projects/{project}/global/backendBuckets/{backendBucket}
# Updates the specified BackendBucket resource with the data included in the request. This method supp
# Request: BackendBucket
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "backendBuckets"
# discovery_method = "patch"
# rust_name = "update_backend_bucket"
# is_lro = true
# query_params = ["requestId"]

# --- backendBuckets.addSignedUrlKey ---
# POST projects/{project}/global/backendBuckets/{backendBucket}/addSignedUrlKey
# Adds a key for validating requests with signed URLs for this backend bucket.
# Request: SignedUrlKey
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "backendBuckets"
# discovery_method = "addSignedUrlKey"
# rust_name = "addSignedUrlKey_backend_bucket"
# is_lro = true
# query_params = ["requestId"]

# --- disks.aggregatedList ---
# GET projects/{project}/aggregated/disks
# Retrieves an aggregated list of persistent disks. To prevent failure, it is recommended that you set
# Response: DiskAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "disks"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_disk"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- disks.bulkSetLabels ---
# POST projects/{project}/zones/{zone}/disks/bulkSetLabels
# Sets the labels on many disks at once. To learn more about labels, read theLabeling Resources docume
# Request: BulkZoneSetLabelsRequest
# Response: Operation
# Query params: requestId, resource
# [[operations]]
# discovery_resource = "disks"
# discovery_method = "bulkSetLabels"
# rust_name = "bulkSetLabels_disk"
# is_lro = true
# query_params = ["requestId", "resource"]

# --- disks.get [IN MANIFEST] ---
# GET projects/{project}/zones/{zone}/disks/{disk}
# Returns the specified persistent disk.
# Response: Disk
# [[operations]]
# discovery_resource = "disks"
# discovery_method = "get"
# rust_name = "get_disk"

# --- disks.testIamPermissions ---
# POST projects/{project}/zones/{zone}/disks/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "disks"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_disk"

# --- disks.list [IN MANIFEST] ---
# GET projects/{project}/zones/{zone}/disks
# Retrieves a list of persistent disks contained within the specified zone.
# Response: DiskList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "disks"
# discovery_method = "list"
# rust_name = "list_disks"
# list_response = { type_name = "DiskList", items_field = "items", item_type = "Disk" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- disks.resize [IN MANIFEST] ---
# POST projects/{project}/zones/{zone}/disks/{disk}/resize
# Resizes the specified persistent disk. You can only increase the size of the disk.
# Request: DisksResizeRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "disks"
# discovery_method = "resize"
# rust_name = "resize_disk"
# is_lro = true
# query_params = ["requestId"]

# --- disks.createSnapshot [IN MANIFEST] ---
# POST projects/{project}/zones/{zone}/disks/{disk}/createSnapshot
# Creates a snapshot of a specified persistent disk. For regular snapshot creation, consider using sna
# Request: Snapshot
# Response: Operation
# Query params: guestFlush, requestId
# [[operations]]
# discovery_resource = "disks"
# discovery_method = "createSnapshot"
# rust_name = "createSnapshot_disk"
# is_lro = true
# query_params = ["guestFlush", "requestId"]

# --- disks.stopAsyncReplication ---
# POST projects/{project}/zones/{zone}/disks/{disk}/stopAsyncReplication
# Stops asynchronous replication. Can be invoked either on the primary or on the secondary disk.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "disks"
# discovery_method = "stopAsyncReplication"
# rust_name = "stopAsyncReplication_disk"
# is_lro = true
# query_params = ["requestId"]

# --- disks.removeResourcePolicies ---
# POST projects/{project}/zones/{zone}/disks/{disk}/removeResourcePolicies
# Removes resource policies from a disk.
# Request: DisksRemoveResourcePoliciesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "disks"
# discovery_method = "removeResourcePolicies"
# rust_name = "removeResourcePolicies_disk"
# is_lro = true
# query_params = ["requestId"]

# --- disks.stopGroupAsyncReplication ---
# POST projects/{project}/zones/{zone}/disks/stopGroupAsyncReplication
# Stops asynchronous replication for a consistency group of disks. Can be invoked either in the primar
# Request: DisksStopGroupAsyncReplicationResource
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "disks"
# discovery_method = "stopGroupAsyncReplication"
# rust_name = "stopGroupAsyncReplication_disk"
# is_lro = true
# query_params = ["requestId"]

# --- disks.bulkInsert ---
# POST projects/{project}/zones/{zone}/disks/bulkInsert
# Bulk create a set of disks.
# Request: BulkInsertDiskResource
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "disks"
# discovery_method = "bulkInsert"
# rust_name = "bulkInsert_disk"
# is_lro = true
# query_params = ["requestId"]

# --- disks.addResourcePolicies ---
# POST projects/{project}/zones/{zone}/disks/{disk}/addResourcePolicies
# Adds existing resource policies to a disk. You can only add one policy which will be applied to this
# Request: DisksAddResourcePoliciesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "disks"
# discovery_method = "addResourcePolicies"
# rust_name = "addResourcePolicies_disk"
# is_lro = true
# query_params = ["requestId"]

# --- disks.insert [IN MANIFEST] ---
# POST projects/{project}/zones/{zone}/disks
# Creates a persistent disk in the specified project using the data in the request. You can create a d
# Request: Disk
# Response: Operation
# Query params: requestId, sourceImage
# [[operations]]
# discovery_resource = "disks"
# discovery_method = "insert"
# rust_name = "create_disk"
# is_lro = true
# query_params = ["requestId", "sourceImage"]

# --- disks.startAsyncReplication ---
# POST projects/{project}/zones/{zone}/disks/{disk}/startAsyncReplication
# Starts asynchronous replication. Must be invoked on the primary disk.
# Request: DisksStartAsyncReplicationRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "disks"
# discovery_method = "startAsyncReplication"
# rust_name = "startAsyncReplication_disk"
# is_lro = true
# query_params = ["requestId"]

# --- disks.update ---
# PATCH projects/{project}/zones/{zone}/disks/{disk}
# Updates the specified disk with the data included in the request. The update is performed only on se
# Request: Disk
# Response: Operation
# Query params: paths (repeated), requestId, updateMask
# [[operations]]
# discovery_resource = "disks"
# discovery_method = "update"
# rust_name = "update_disk"
# is_lro = true
# query_params = ["paths", "requestId", "updateMask"]

# --- disks.getIamPolicy ---
# GET projects/{project}/zones/{zone}/disks/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "disks"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_disk"
# query_params = ["optionsRequestedPolicyVersion"]

# --- disks.delete [IN MANIFEST] ---
# DELETE projects/{project}/zones/{zone}/disks/{disk}
# Deletes the specified persistent disk. Deleting a disk removes its data permanently and is irreversi
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "disks"
# discovery_method = "delete"
# rust_name = "delete_disk"
# is_lro = true
# query_params = ["requestId"]

# --- disks.setLabels ---
# POST projects/{project}/zones/{zone}/disks/{resource}/setLabels
# Sets the labels on a disk. To learn more about labels, read theLabeling Resources documentation.
# Request: ZoneSetLabelsRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "disks"
# discovery_method = "setLabels"
# rust_name = "setLabels_disk"
# is_lro = true
# query_params = ["requestId"]

# --- disks.setIamPolicy ---
# POST projects/{project}/zones/{zone}/disks/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: ZoneSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "disks"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_disk"

# --- regionCommitments.list ---
# GET projects/{project}/regions/{region}/commitments
# Retrieves a list of commitments contained within the specified region.
# Response: CommitmentList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionCommitments"
# discovery_method = "list"
# rust_name = "list_region_commitments"
# list_response = { type_name = "CommitmentList", items_field = "items", item_type = "Commitment" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionCommitments.update ---
# PATCH projects/{project}/regions/{region}/commitments/{commitment}
# Updates the specified commitment with the data included in the request. Update is performed only on 
# Request: Commitment
# Response: Operation
# Query params: paths (repeated), requestId, updateMask
# [[operations]]
# discovery_resource = "regionCommitments"
# discovery_method = "update"
# rust_name = "update_region_commitment"
# is_lro = true
# query_params = ["paths", "requestId", "updateMask"]

# --- regionCommitments.insert ---
# POST projects/{project}/regions/{region}/commitments
# Creates a commitment in the specified project using the data included in the request.
# Request: Commitment
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionCommitments"
# discovery_method = "insert"
# rust_name = "create_region_commitment"
# is_lro = true
# query_params = ["requestId"]

# --- regionCommitments.get ---
# GET projects/{project}/regions/{region}/commitments/{commitment}
# Returns the specified commitment resource.
# Response: Commitment
# [[operations]]
# discovery_resource = "regionCommitments"
# discovery_method = "get"
# rust_name = "get_region_commitment"

# --- regionCommitments.aggregatedList ---
# GET projects/{project}/aggregated/commitments
# Retrieves an aggregated list of commitments by region. To prevent failure, it is recommended that yo
# Response: CommitmentAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "regionCommitments"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_region_commitment"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- healthChecks.testIamPermissions ---
# POST projects/{project}/global/healthChecks/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "healthChecks"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_health_check"

# --- healthChecks.aggregatedList ---
# GET projects/{project}/aggregated/healthChecks
# Retrieves the list of all HealthCheck resources, regional and global, available to the specified pro
# Response: HealthChecksAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "healthChecks"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_health_check"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- healthChecks.patch ---
# PATCH projects/{project}/global/healthChecks/{healthCheck}
# Updates a HealthCheck resource in the specified project using the data included in the request. This
# Request: HealthCheck
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "healthChecks"
# discovery_method = "patch"
# rust_name = "update_health_check"
# is_lro = true
# query_params = ["requestId"]

# --- healthChecks.insert ---
# POST projects/{project}/global/healthChecks
# Creates a HealthCheck resource in the specified project using the data included in the request.
# Request: HealthCheck
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "healthChecks"
# discovery_method = "insert"
# rust_name = "create_health_check"
# is_lro = true
# query_params = ["requestId"]

# --- healthChecks.get ---
# GET projects/{project}/global/healthChecks/{healthCheck}
# Returns the specified HealthCheck resource.
# Response: HealthCheck
# [[operations]]
# discovery_resource = "healthChecks"
# discovery_method = "get"
# rust_name = "get_health_check"

# --- healthChecks.update ---
# PUT projects/{project}/global/healthChecks/{healthCheck}
# Updates a HealthCheck resource in the specified project using the data included in the request.
# Request: HealthCheck
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "healthChecks"
# discovery_method = "update"
# rust_name = "update_health_check"
# is_lro = true
# query_params = ["requestId"]

# --- healthChecks.delete ---
# DELETE projects/{project}/global/healthChecks/{healthCheck}
# Deletes the specified HealthCheck resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "healthChecks"
# discovery_method = "delete"
# rust_name = "delete_health_check"
# is_lro = true
# query_params = ["requestId"]

# --- healthChecks.list ---
# GET projects/{project}/global/healthChecks
# Retrieves the list of HealthCheck resources available to the specified project.
# Response: HealthCheckList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "healthChecks"
# discovery_method = "list"
# rust_name = "list_health_checks"
# list_response = { type_name = "HealthCheckList", items_field = "items", item_type = "HealthCheck" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- networkEdgeSecurityServices.delete ---
# DELETE projects/{project}/regions/{region}/networkEdgeSecurityServices/{networkEdgeSecurityService}
# Deletes the specified service.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "networkEdgeSecurityServices"
# discovery_method = "delete"
# rust_name = "delete_network_edge_security_service"
# is_lro = true
# query_params = ["requestId"]

# --- networkEdgeSecurityServices.get ---
# GET projects/{project}/regions/{region}/networkEdgeSecurityServices/{networkEdgeSecurityService}
# Gets a specified NetworkEdgeSecurityService.
# Response: NetworkEdgeSecurityService
# [[operations]]
# discovery_resource = "networkEdgeSecurityServices"
# discovery_method = "get"
# rust_name = "get_network_edge_security_service"

# --- networkEdgeSecurityServices.aggregatedList ---
# GET projects/{project}/aggregated/networkEdgeSecurityServices
# Retrieves the list of all NetworkEdgeSecurityService resources available to the specified project. T
# Response: NetworkEdgeSecurityServiceAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "networkEdgeSecurityServices"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_network_edge_security_service"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- networkEdgeSecurityServices.insert ---
# POST projects/{project}/regions/{region}/networkEdgeSecurityServices
# Creates a new service in the specified project using the data included in the request.
# Request: NetworkEdgeSecurityService
# Response: Operation
# Query params: requestId, validateOnly
# [[operations]]
# discovery_resource = "networkEdgeSecurityServices"
# discovery_method = "insert"
# rust_name = "create_network_edge_security_service"
# is_lro = true
# query_params = ["requestId", "validateOnly"]

# --- networkEdgeSecurityServices.patch ---
# PATCH projects/{project}/regions/{region}/networkEdgeSecurityServices/{networkEdgeSecurityService}
# Patches the specified policy with the data included in the request.
# Request: NetworkEdgeSecurityService
# Response: Operation
# Query params: paths (repeated), requestId, updateMask
# [[operations]]
# discovery_resource = "networkEdgeSecurityServices"
# discovery_method = "patch"
# rust_name = "update_network_edge_security_service"
# is_lro = true
# query_params = ["paths", "requestId", "updateMask"]

# --- targetSslProxies.setProxyHeader ---
# POST projects/{project}/global/targetSslProxies/{targetSslProxy}/setProxyHeader
# Changes the ProxyHeaderType for TargetSslProxy.
# Request: TargetSslProxiesSetProxyHeaderRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetSslProxies"
# discovery_method = "setProxyHeader"
# rust_name = "setProxyHeader_target_ssl_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetSslProxies.setSslPolicy ---
# POST projects/{project}/global/targetSslProxies/{targetSslProxy}/setSslPolicy
# Sets the SSL policy for TargetSslProxy. The SSL policy specifies the server-side support for SSL fea
# Request: SslPolicyReference
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetSslProxies"
# discovery_method = "setSslPolicy"
# rust_name = "setSslPolicy_target_ssl_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetSslProxies.testIamPermissions ---
# POST projects/{project}/global/targetSslProxies/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "targetSslProxies"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_target_ssl_proxie"

# --- targetSslProxies.delete ---
# DELETE projects/{project}/global/targetSslProxies/{targetSslProxy}
# Deletes the specified TargetSslProxy resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetSslProxies"
# discovery_method = "delete"
# rust_name = "delete_target_ssl_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetSslProxies.get ---
# GET projects/{project}/global/targetSslProxies/{targetSslProxy}
# Returns the specified TargetSslProxy resource.
# Response: TargetSslProxy
# [[operations]]
# discovery_resource = "targetSslProxies"
# discovery_method = "get"
# rust_name = "get_target_ssl_proxie"

# --- targetSslProxies.list ---
# GET projects/{project}/global/targetSslProxies
# Retrieves the list of TargetSslProxy resources available to the specified project.
# Response: TargetSslProxyList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "targetSslProxies"
# discovery_method = "list"
# rust_name = "list_target_ssl_proxies"
# list_response = { type_name = "TargetSslProxyList", items_field = "items", item_type = "TargetSslProxy" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- targetSslProxies.insert ---
# POST projects/{project}/global/targetSslProxies
# Creates a TargetSslProxy resource in the specified project using the data included in the request.
# Request: TargetSslProxy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetSslProxies"
# discovery_method = "insert"
# rust_name = "create_target_ssl_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetSslProxies.setSslCertificates ---
# POST projects/{project}/global/targetSslProxies/{targetSslProxy}/setSslCertificates
# Changes SslCertificates for TargetSslProxy.
# Request: TargetSslProxiesSetSslCertificatesRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetSslProxies"
# discovery_method = "setSslCertificates"
# rust_name = "setSslCertificates_target_ssl_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetSslProxies.setBackendService ---
# POST projects/{project}/global/targetSslProxies/{targetSslProxy}/setBackendService
# Changes the BackendService for TargetSslProxy.
# Request: TargetSslProxiesSetBackendServiceRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetSslProxies"
# discovery_method = "setBackendService"
# rust_name = "setBackendService_target_ssl_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- targetSslProxies.setCertificateMap ---
# POST projects/{project}/global/targetSslProxies/{targetSslProxy}/setCertificateMap
# Changes the Certificate Map for TargetSslProxy.
# Request: TargetSslProxiesSetCertificateMapRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "targetSslProxies"
# discovery_method = "setCertificateMap"
# rust_name = "setCertificateMap_target_ssl_proxie"
# is_lro = true
# query_params = ["requestId"]

# --- machineImages.setIamPolicy ---
# POST projects/{project}/global/machineImages/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: GlobalSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "machineImages"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_machine_image"

# --- machineImages.getIamPolicy ---
# GET projects/{project}/global/machineImages/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "machineImages"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_machine_image"
# query_params = ["optionsRequestedPolicyVersion"]

# --- machineImages.get ---
# GET projects/{project}/global/machineImages/{machineImage}
# Returns the specified machine image.
# Response: MachineImage
# [[operations]]
# discovery_resource = "machineImages"
# discovery_method = "get"
# rust_name = "get_machine_image"

# --- machineImages.setLabels ---
# POST projects/{project}/global/machineImages/{resource}/setLabels
# Sets the labels on a machine image. To learn more about labels, read theLabeling Resources documenta
# Request: GlobalSetLabelsRequest
# Response: Operation
# [[operations]]
# discovery_resource = "machineImages"
# discovery_method = "setLabels"
# rust_name = "setLabels_machine_image"
# is_lro = true

# --- machineImages.testIamPermissions ---
# POST projects/{project}/global/machineImages/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "machineImages"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_machine_image"

# --- machineImages.list ---
# GET projects/{project}/global/machineImages
# Retrieves a list of machine images that are contained within the specified project.
# Response: MachineImageList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "machineImages"
# discovery_method = "list"
# rust_name = "list_machine_images"
# list_response = { type_name = "MachineImageList", items_field = "items", item_type = "MachineImage" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- machineImages.insert ---
# POST projects/{project}/global/machineImages
# Creates a machine image in the specified project using the data that is included in the request. If 
# Request: MachineImage
# Response: Operation
# Query params: requestId, sourceInstance
# [[operations]]
# discovery_resource = "machineImages"
# discovery_method = "insert"
# rust_name = "create_machine_image"
# is_lro = true
# query_params = ["requestId", "sourceInstance"]

# --- machineImages.delete ---
# DELETE projects/{project}/global/machineImages/{machineImage}
# Deletes the specified machine image. Deleting a machine image is permanent and cannot be undone.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "machineImages"
# discovery_method = "delete"
# rust_name = "delete_machine_image"
# is_lro = true
# query_params = ["requestId"]

# --- securityPolicies.delete ---
# DELETE projects/{project}/global/securityPolicies/{securityPolicy}
# Deletes the specified policy.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "securityPolicies"
# discovery_method = "delete"
# rust_name = "delete_security_policie"
# is_lro = true
# query_params = ["requestId"]

# --- securityPolicies.patch ---
# PATCH projects/{project}/global/securityPolicies/{securityPolicy}
# Patches the specified policy with the data included in the request. To clear fields in the policy, l
# Request: SecurityPolicy
# Response: Operation
# Query params: requestId, updateMask
# [[operations]]
# discovery_resource = "securityPolicies"
# discovery_method = "patch"
# rust_name = "update_security_policie"
# is_lro = true
# query_params = ["requestId", "updateMask"]

# --- securityPolicies.getRule ---
# GET projects/{project}/global/securityPolicies/{securityPolicy}/getRule
# Gets a rule at the specified priority.
# Response: SecurityPolicyRule
# Query params: priority
# [[operations]]
# discovery_resource = "securityPolicies"
# discovery_method = "getRule"
# rust_name = "getRule_security_policie"
# query_params = ["priority"]

# --- securityPolicies.aggregatedList ---
# GET projects/{project}/aggregated/securityPolicies
# Retrieves the list of all SecurityPolicy resources, regional and global, available to the specified 
# Response: SecurityPoliciesAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "securityPolicies"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_security_policie"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- securityPolicies.addRule ---
# POST projects/{project}/global/securityPolicies/{securityPolicy}/addRule
# Inserts a rule into a security policy.
# Request: SecurityPolicyRule
# Response: Operation
# Query params: validateOnly
# [[operations]]
# discovery_resource = "securityPolicies"
# discovery_method = "addRule"
# rust_name = "addRule_security_policie"
# is_lro = true
# query_params = ["validateOnly"]

# --- securityPolicies.list ---
# GET projects/{project}/global/securityPolicies
# List all the policies that have been configured for the specified project.
# Response: SecurityPolicyList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "securityPolicies"
# discovery_method = "list"
# rust_name = "list_security_policies"
# list_response = { type_name = "SecurityPolicyList", items_field = "items", item_type = "SecurityPolicy" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- securityPolicies.patchRule ---
# POST projects/{project}/global/securityPolicies/{securityPolicy}/patchRule
# Patches a rule at the specified priority. To clear fields in the rule, leave the fields empty and sp
# Request: SecurityPolicyRule
# Response: Operation
# Query params: priority, updateMask, validateOnly
# [[operations]]
# discovery_resource = "securityPolicies"
# discovery_method = "patchRule"
# rust_name = "patchRule_security_policie"
# is_lro = true
# query_params = ["priority", "updateMask", "validateOnly"]

# --- securityPolicies.setLabels ---
# POST projects/{project}/global/securityPolicies/{resource}/setLabels
# Sets the labels on a security policy. To learn more about labels, read the Labeling Resources docume
# Request: GlobalSetLabelsRequest
# Response: Operation
# [[operations]]
# discovery_resource = "securityPolicies"
# discovery_method = "setLabels"
# rust_name = "setLabels_security_policie"
# is_lro = true

# --- securityPolicies.listPreconfiguredExpressionSets ---
# GET projects/{project}/global/securityPolicies/listPreconfiguredExpressionSets
# Gets the current list of preconfigured Web Application Firewall (WAF) expressions.
# Response: SecurityPoliciesListPreconfiguredExpressionSetsResponse
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "securityPolicies"
# discovery_method = "listPreconfiguredExpressionSets"
# rust_name = "listPreconfiguredExpressionSets_security_policie"
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- securityPolicies.get ---
# GET projects/{project}/global/securityPolicies/{securityPolicy}
# List all of the ordered rules present in a single specified policy.
# Response: SecurityPolicy
# [[operations]]
# discovery_resource = "securityPolicies"
# discovery_method = "get"
# rust_name = "get_security_policie"

# --- securityPolicies.insert ---
# POST projects/{project}/global/securityPolicies
# Creates a new policy in the specified project using the data included in the request.
# Request: SecurityPolicy
# Response: Operation
# Query params: requestId, validateOnly
# [[operations]]
# discovery_resource = "securityPolicies"
# discovery_method = "insert"
# rust_name = "create_security_policie"
# is_lro = true
# query_params = ["requestId", "validateOnly"]

# --- securityPolicies.removeRule ---
# POST projects/{project}/global/securityPolicies/{securityPolicy}/removeRule
# Deletes a rule at the specified priority.
# Response: Operation
# Query params: priority
# [[operations]]
# discovery_resource = "securityPolicies"
# discovery_method = "removeRule"
# rust_name = "removeRule_security_policie"
# is_lro = true
# query_params = ["priority"]

# --- projects.get ---
# GET projects/{project}
# Returns the specified Project resource. To decrease latency for this method, you can optionally omit
# Response: Project
# [[operations]]
# discovery_resource = "projects"
# discovery_method = "get"
# rust_name = "get_project"

# --- projects.setCommonInstanceMetadata ---
# POST projects/{project}/setCommonInstanceMetadata
# Sets metadata common to all instances within the specified project using the data included in the re
# Request: Metadata
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "projects"
# discovery_method = "setCommonInstanceMetadata"
# rust_name = "setCommonInstanceMetadata_project"
# is_lro = true
# query_params = ["requestId"]

# --- projects.disableXpnResource ---
# POST projects/{project}/disableXpnResource
# Disable a service resource (also known as service project) associated with this host project.
# Request: ProjectsDisableXpnResourceRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "projects"
# discovery_method = "disableXpnResource"
# rust_name = "disableXpnResource_project"
# is_lro = true
# query_params = ["requestId"]

# --- projects.listXpnHosts ---
# POST projects/{project}/listXpnHosts
# Lists all shared VPC host projects visible to the user in an organization.
# Request: ProjectsListXpnHostsRequest
# Response: XpnHostList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "projects"
# discovery_method = "listXpnHosts"
# rust_name = "listXpnHosts_project"
# list_response = { type_name = "XpnHostList", items_field = "items", item_type = "Project" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- projects.setCloudArmorTier ---
# POST projects/{project}/setCloudArmorTier
# Sets the Cloud Armor tier of the project. To set ENTERPRISE or above the billing account of the proj
# Request: ProjectsSetCloudArmorTierRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "projects"
# discovery_method = "setCloudArmorTier"
# rust_name = "setCloudArmorTier_project"
# is_lro = true
# query_params = ["requestId"]

# --- projects.moveInstance ---
# POST projects/{project}/moveInstance
# Moves an instance and its attached persistent disks from one zone to another. *Note*: Moving VMs or 
# Request: InstanceMoveRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "projects"
# discovery_method = "moveInstance"
# rust_name = "moveInstance_project"
# is_lro = true
# query_params = ["requestId"]

# --- projects.moveDisk ---
# POST projects/{project}/moveDisk
# Moves a persistent disk from one zone to another. *Note*: The moveDisk API will be deprecated on Sep
# Request: DiskMoveRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "projects"
# discovery_method = "moveDisk"
# rust_name = "moveDisk_project"
# is_lro = true
# query_params = ["requestId"]

# --- projects.enableXpnHost ---
# POST projects/{project}/enableXpnHost
# Enable this project as a shared VPC host project.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "projects"
# discovery_method = "enableXpnHost"
# rust_name = "enableXpnHost_project"
# is_lro = true
# query_params = ["requestId"]

# --- projects.getXpnResources ---
# GET projects/{project}/getXpnResources
# Gets service resources (a.k.a service project) associated with this host project.
# Response: ProjectsGetXpnResources
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "projects"
# discovery_method = "getXpnResources"
# rust_name = "getXpnResources_project"
# list_response = { type_name = "ProjectsGetXpnResources", items_field = "resources", item_type = "XpnResourceId" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- projects.setDefaultNetworkTier ---
# POST projects/{project}/setDefaultNetworkTier
# Sets the default network tier of the project. The default network tier is used when an address/forwa
# Request: ProjectsSetDefaultNetworkTierRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "projects"
# discovery_method = "setDefaultNetworkTier"
# rust_name = "setDefaultNetworkTier_project"
# is_lro = true
# query_params = ["requestId"]

# --- projects.getXpnHost ---
# GET projects/{project}/getXpnHost
# Gets the shared VPC host project that this project links to. May be empty if no link exists.
# Response: Project
# [[operations]]
# discovery_resource = "projects"
# discovery_method = "getXpnHost"
# rust_name = "getXpnHost_project"

# --- projects.disableXpnHost ---
# POST projects/{project}/disableXpnHost
# Disable this project as a shared VPC host project.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "projects"
# discovery_method = "disableXpnHost"
# rust_name = "disableXpnHost_project"
# is_lro = true
# query_params = ["requestId"]

# --- projects.enableXpnResource ---
# POST projects/{project}/enableXpnResource
# Enable service resource (a.k.a service project) for a host project, so that subnets in the host proj
# Request: ProjectsEnableXpnResourceRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "projects"
# discovery_method = "enableXpnResource"
# rust_name = "enableXpnResource_project"
# is_lro = true
# query_params = ["requestId"]

# --- projects.setUsageExportBucket ---
# POST projects/{project}/setUsageExportBucket
# Enables the usage export feature and sets theusage export bucket where reports are stored. If you pr
# Request: UsageExportLocation
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "projects"
# discovery_method = "setUsageExportBucket"
# rust_name = "setUsageExportBucket_project"
# is_lro = true
# query_params = ["requestId"]

# --- regionInstances.bulkInsert ---
# POST projects/{project}/regions/{region}/instances/bulkInsert
# Creates multiple instances in a given region. Count specifies the number of instances to create.
# Request: BulkInsertInstanceResource
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionInstances"
# discovery_method = "bulkInsert"
# rust_name = "bulkInsert_region_instance"
# is_lro = true
# query_params = ["requestId"]

# --- httpsHealthChecks.update ---
# PUT projects/{project}/global/httpsHealthChecks/{httpsHealthCheck}
# Updates a HttpsHealthCheck resource in the specified project using the data included in the request.
# Request: HttpsHealthCheck
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "httpsHealthChecks"
# discovery_method = "update"
# rust_name = "update_https_health_check"
# is_lro = true
# query_params = ["requestId"]

# --- httpsHealthChecks.list ---
# GET projects/{project}/global/httpsHealthChecks
# Retrieves the list of HttpsHealthCheck resources available to the specified project.
# Response: HttpsHealthCheckList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "httpsHealthChecks"
# discovery_method = "list"
# rust_name = "list_https_health_checks"
# list_response = { type_name = "HttpsHealthCheckList", items_field = "items", item_type = "HttpsHealthCheck" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- httpsHealthChecks.testIamPermissions ---
# POST projects/{project}/global/httpsHealthChecks/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "httpsHealthChecks"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_https_health_check"

# --- httpsHealthChecks.insert ---
# POST projects/{project}/global/httpsHealthChecks
# Creates a HttpsHealthCheck resource in the specified project using the data included in the request.
# Request: HttpsHealthCheck
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "httpsHealthChecks"
# discovery_method = "insert"
# rust_name = "create_https_health_check"
# is_lro = true
# query_params = ["requestId"]

# --- httpsHealthChecks.delete ---
# DELETE projects/{project}/global/httpsHealthChecks/{httpsHealthCheck}
# Deletes the specified HttpsHealthCheck resource.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "httpsHealthChecks"
# discovery_method = "delete"
# rust_name = "delete_https_health_check"
# is_lro = true
# query_params = ["requestId"]

# --- httpsHealthChecks.patch ---
# PATCH projects/{project}/global/httpsHealthChecks/{httpsHealthCheck}
# Updates a HttpsHealthCheck resource in the specified project using the data included in the request.
# Request: HttpsHealthCheck
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "httpsHealthChecks"
# discovery_method = "patch"
# rust_name = "update_https_health_check"
# is_lro = true
# query_params = ["requestId"]

# --- httpsHealthChecks.get ---
# GET projects/{project}/global/httpsHealthChecks/{httpsHealthCheck}
# Returns the specified HttpsHealthCheck resource.
# Response: HttpsHealthCheck
# [[operations]]
# discovery_resource = "httpsHealthChecks"
# discovery_method = "get"
# rust_name = "get_https_health_check"

# --- regionZones.list ---
# GET projects/{project}/regions/{region}/zones
# Retrieves the list of Zone resources under the specific region available to the specified project.
# Response: ZoneList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionZones"
# discovery_method = "list"
# rust_name = "list_region_zones"
# list_response = { type_name = "ZoneList", items_field = "items", item_type = "Zone" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- globalOrganizationOperations.get ---
# GET locations/global/operations/{operation}
# Retrieves the specified Operations resource. Gets a list of operations by making a `list()` request.
# Response: Operation
# Query params: parentId
# [[operations]]
# discovery_resource = "globalOrganizationOperations"
# discovery_method = "get"
# rust_name = "get_global_organization_operation"
# is_lro = true
# query_params = ["parentId"]

# --- globalOrganizationOperations.delete ---
# DELETE locations/global/operations/{operation}
# Deletes the specified Operations resource.
# Query params: parentId
# [[operations]]
# discovery_resource = "globalOrganizationOperations"
# discovery_method = "delete"
# rust_name = "delete_global_organization_operation"
# query_params = ["parentId"]

# --- globalOrganizationOperations.list ---
# GET locations/global/operations
# Retrieves a list of Operation resources contained within the specified organization.
# Response: OperationList
# Query params: filter, maxResults, orderBy, pageToken, parentId, returnPartialSuccess
# [[operations]]
# discovery_resource = "globalOrganizationOperations"
# discovery_method = "list"
# rust_name = "list_global_organization_operations"
# list_response = { type_name = "OperationList", items_field = "items", item_type = "Operation" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "parentId", "returnPartialSuccess"]

# --- globalPublicDelegatedPrefixes.get ---
# GET projects/{project}/global/publicDelegatedPrefixes/{publicDelegatedPrefix}
# Returns the specified global PublicDelegatedPrefix resource.
# Response: PublicDelegatedPrefix
# [[operations]]
# discovery_resource = "globalPublicDelegatedPrefixes"
# discovery_method = "get"
# rust_name = "get_global_public_delegated_prefixe"

# --- globalPublicDelegatedPrefixes.list ---
# GET projects/{project}/global/publicDelegatedPrefixes
# Lists the global PublicDelegatedPrefixes for a project.
# Response: PublicDelegatedPrefixList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "globalPublicDelegatedPrefixes"
# discovery_method = "list"
# rust_name = "list_global_public_delegated_prefixes"
# list_response = { type_name = "PublicDelegatedPrefixList", items_field = "items", item_type = "PublicDelegatedPrefix" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- globalPublicDelegatedPrefixes.delete ---
# DELETE projects/{project}/global/publicDelegatedPrefixes/{publicDelegatedPrefix}
# Deletes the specified global PublicDelegatedPrefix.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "globalPublicDelegatedPrefixes"
# discovery_method = "delete"
# rust_name = "delete_global_public_delegated_prefixe"
# is_lro = true
# query_params = ["requestId"]

# --- globalPublicDelegatedPrefixes.patch ---
# PATCH projects/{project}/global/publicDelegatedPrefixes/{publicDelegatedPrefix}
# Patches the specified global PublicDelegatedPrefix resource with the data included in the request. T
# Request: PublicDelegatedPrefix
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "globalPublicDelegatedPrefixes"
# discovery_method = "patch"
# rust_name = "update_global_public_delegated_prefixe"
# is_lro = true
# query_params = ["requestId"]

# --- globalPublicDelegatedPrefixes.insert ---
# POST projects/{project}/global/publicDelegatedPrefixes
# Creates a global PublicDelegatedPrefix in the specified project using the parameters that are includ
# Request: PublicDelegatedPrefix
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "globalPublicDelegatedPrefixes"
# discovery_method = "insert"
# rust_name = "create_global_public_delegated_prefixe"
# is_lro = true
# query_params = ["requestId"]

# --- firewalls.patch ---
# PATCH projects/{project}/global/firewalls/{firewall}
# Updates the specified firewall rule with the data included in the request. This method supportsPATCH
# Request: Firewall
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "firewalls"
# discovery_method = "patch"
# rust_name = "update_firewall"
# is_lro = true
# query_params = ["requestId"]

# --- firewalls.update ---
# PUT projects/{project}/global/firewalls/{firewall}
# Updates the specified firewall rule with the data included in the request. Note that all fields will
# Request: Firewall
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "firewalls"
# discovery_method = "update"
# rust_name = "update_firewall"
# is_lro = true
# query_params = ["requestId"]

# --- firewalls.delete ---
# DELETE projects/{project}/global/firewalls/{firewall}
# Deletes the specified firewall.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "firewalls"
# discovery_method = "delete"
# rust_name = "delete_firewall"
# is_lro = true
# query_params = ["requestId"]

# --- firewalls.get ---
# GET projects/{project}/global/firewalls/{firewall}
# Returns the specified firewall.
# Response: Firewall
# [[operations]]
# discovery_resource = "firewalls"
# discovery_method = "get"
# rust_name = "get_firewall"

# --- firewalls.list ---
# GET projects/{project}/global/firewalls
# Retrieves the list of firewall rules available to the specified project.
# Response: FirewallList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "firewalls"
# discovery_method = "list"
# rust_name = "list_firewalls"
# list_response = { type_name = "FirewallList", items_field = "items", item_type = "Firewall" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- firewalls.testIamPermissions ---
# POST projects/{project}/global/firewalls/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "firewalls"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_firewall"

# --- firewalls.insert ---
# POST projects/{project}/global/firewalls
# Creates a firewall rule in the specified project using the data included in the request.
# Request: Firewall
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "firewalls"
# discovery_method = "insert"
# rust_name = "create_firewall"
# is_lro = true
# query_params = ["requestId"]

# --- regionNetworkFirewallPolicies.getRule ---
# GET projects/{project}/regions/{region}/firewallPolicies/{firewallPolicy}/getRule
# Gets a rule of the specified priority.
# Response: FirewallPolicyRule
# Query params: priority
# [[operations]]
# discovery_resource = "regionNetworkFirewallPolicies"
# discovery_method = "getRule"
# rust_name = "getRule_region_network_firewall_policie"
# query_params = ["priority"]

# --- regionNetworkFirewallPolicies.patchRule ---
# POST projects/{project}/regions/{region}/firewallPolicies/{firewallPolicy}/patchRule
# Patches a rule of the specified priority.
# Request: FirewallPolicyRule
# Response: Operation
# Query params: priority, requestId
# [[operations]]
# discovery_resource = "regionNetworkFirewallPolicies"
# discovery_method = "patchRule"
# rust_name = "patchRule_region_network_firewall_policie"
# is_lro = true
# query_params = ["priority", "requestId"]

# --- regionNetworkFirewallPolicies.delete ---
# DELETE projects/{project}/regions/{region}/firewallPolicies/{firewallPolicy}
# Deletes the specified network firewall policy.
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionNetworkFirewallPolicies"
# discovery_method = "delete"
# rust_name = "delete_region_network_firewall_policie"
# is_lro = true
# query_params = ["requestId"]

# --- regionNetworkFirewallPolicies.addAssociation ---
# POST projects/{project}/regions/{region}/firewallPolicies/{firewallPolicy}/addAssociation
# Inserts an association for the specified network firewall policy.
# Request: FirewallPolicyAssociation
# Response: Operation
# Query params: replaceExistingAssociation, requestId
# [[operations]]
# discovery_resource = "regionNetworkFirewallPolicies"
# discovery_method = "addAssociation"
# rust_name = "addAssociation_region_network_firewall_policie"
# is_lro = true
# query_params = ["replaceExistingAssociation", "requestId"]

# --- regionNetworkFirewallPolicies.cloneRules ---
# POST projects/{project}/regions/{region}/firewallPolicies/{firewallPolicy}/cloneRules
# Copies rules to the specified network firewall policy.
# Response: Operation
# Query params: requestId, sourceFirewallPolicy
# [[operations]]
# discovery_resource = "regionNetworkFirewallPolicies"
# discovery_method = "cloneRules"
# rust_name = "cloneRules_region_network_firewall_policie"
# is_lro = true
# query_params = ["requestId", "sourceFirewallPolicy"]

# --- regionNetworkFirewallPolicies.getIamPolicy ---
# GET projects/{project}/regions/{region}/firewallPolicies/{resource}/getIamPolicy
# Gets the access control policy for a resource. May be empty if no such policy or resource exists.
# Response: Policy
# Query params: optionsRequestedPolicyVersion
# [[operations]]
# discovery_resource = "regionNetworkFirewallPolicies"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_region_network_firewall_policie"
# query_params = ["optionsRequestedPolicyVersion"]

# --- regionNetworkFirewallPolicies.patch ---
# PATCH projects/{project}/regions/{region}/firewallPolicies/{firewallPolicy}
# Patches the specified network firewall policy.
# Request: FirewallPolicy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionNetworkFirewallPolicies"
# discovery_method = "patch"
# rust_name = "update_region_network_firewall_policie"
# is_lro = true
# query_params = ["requestId"]

# --- regionNetworkFirewallPolicies.addRule ---
# POST projects/{project}/regions/{region}/firewallPolicies/{firewallPolicy}/addRule
# Inserts a rule into a network firewall policy.
# Request: FirewallPolicyRule
# Response: Operation
# Query params: maxPriority, minPriority, requestId
# [[operations]]
# discovery_resource = "regionNetworkFirewallPolicies"
# discovery_method = "addRule"
# rust_name = "addRule_region_network_firewall_policie"
# is_lro = true
# query_params = ["maxPriority", "minPriority", "requestId"]

# --- regionNetworkFirewallPolicies.get ---
# GET projects/{project}/regions/{region}/firewallPolicies/{firewallPolicy}
# Returns the specified network firewall policy.
# Response: FirewallPolicy
# [[operations]]
# discovery_resource = "regionNetworkFirewallPolicies"
# discovery_method = "get"
# rust_name = "get_region_network_firewall_policie"

# --- regionNetworkFirewallPolicies.getEffectiveFirewalls ---
# GET projects/{project}/regions/{region}/firewallPolicies/getEffectiveFirewalls
# Returns the effective firewalls on a given network.
# Response: RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponse
# Query params: network
# [[operations]]
# discovery_resource = "regionNetworkFirewallPolicies"
# discovery_method = "getEffectiveFirewalls"
# rust_name = "getEffectiveFirewalls_region_network_firewall_policie"
# query_params = ["network"]

# --- regionNetworkFirewallPolicies.removeAssociation ---
# POST projects/{project}/regions/{region}/firewallPolicies/{firewallPolicy}/removeAssociation
# Removes an association for the specified network firewall policy.
# Response: Operation
# Query params: name, requestId
# [[operations]]
# discovery_resource = "regionNetworkFirewallPolicies"
# discovery_method = "removeAssociation"
# rust_name = "removeAssociation_region_network_firewall_policie"
# is_lro = true
# query_params = ["name", "requestId"]

# --- regionNetworkFirewallPolicies.list ---
# GET projects/{project}/regions/{region}/firewallPolicies
# Lists all the network firewall policies that have been configured for the specified project in the g
# Response: FirewallPolicyList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "regionNetworkFirewallPolicies"
# discovery_method = "list"
# rust_name = "list_region_network_firewall_policies"
# list_response = { type_name = "FirewallPolicyList", items_field = "items", item_type = "FirewallPolicy" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- regionNetworkFirewallPolicies.removeRule ---
# POST projects/{project}/regions/{region}/firewallPolicies/{firewallPolicy}/removeRule
# Deletes a rule of the specified priority.
# Response: Operation
# Query params: priority, requestId
# [[operations]]
# discovery_resource = "regionNetworkFirewallPolicies"
# discovery_method = "removeRule"
# rust_name = "removeRule_region_network_firewall_policie"
# is_lro = true
# query_params = ["priority", "requestId"]

# --- regionNetworkFirewallPolicies.testIamPermissions ---
# POST projects/{project}/regions/{region}/firewallPolicies/{resource}/testIamPermissions
# Returns permissions that a caller has on the specified resource.
# Request: TestPermissionsRequest
# Response: TestPermissionsResponse
# [[operations]]
# discovery_resource = "regionNetworkFirewallPolicies"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_region_network_firewall_policie"

# --- regionNetworkFirewallPolicies.setIamPolicy ---
# POST projects/{project}/regions/{region}/firewallPolicies/{resource}/setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy.
# Request: RegionSetPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "regionNetworkFirewallPolicies"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_region_network_firewall_policie"

# --- regionNetworkFirewallPolicies.getAssociation ---
# GET projects/{project}/regions/{region}/firewallPolicies/{firewallPolicy}/getAssociation
# Gets an association with the specified name.
# Response: FirewallPolicyAssociation
# Query params: name
# [[operations]]
# discovery_resource = "regionNetworkFirewallPolicies"
# discovery_method = "getAssociation"
# rust_name = "getAssociation_region_network_firewall_policie"
# query_params = ["name"]

# --- regionNetworkFirewallPolicies.insert ---
# POST projects/{project}/regions/{region}/firewallPolicies
# Creates a new network firewall policy in the specified project and region.
# Request: FirewallPolicy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "regionNetworkFirewallPolicies"
# discovery_method = "insert"
# rust_name = "create_region_network_firewall_policie"
# is_lro = true
# query_params = ["requestId"]

# --- sslPolicies.aggregatedList ---
# GET projects/{project}/aggregated/sslPolicies
# Retrieves the list of all SslPolicy resources, regional and global, available to the specified proje
# Response: SslPoliciesAggregatedList
# Query params: filter, includeAllScopes, maxResults, orderBy, pageToken, returnPartialSuccess, serviceProjectNumber
# [[operations]]
# discovery_resource = "sslPolicies"
# discovery_method = "aggregatedList"
# rust_name = "aggregatedList_ssl_policie"
# query_params = ["filter", "includeAllScopes", "maxResults", "orderBy", "pageToken", "returnPartialSuccess", "serviceProjectNumber"]

# --- sslPolicies.insert ---
# POST projects/{project}/global/sslPolicies
# Returns the specified SSL policy resource.
# Request: SslPolicy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "sslPolicies"
# discovery_method = "insert"
# rust_name = "create_ssl_policie"
# is_lro = true
# query_params = ["requestId"]

# --- sslPolicies.patch ---
# PATCH projects/{project}/global/sslPolicies/{sslPolicy}
# Patches the specified SSL policy with the data included in the request.
# Request: SslPolicy
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "sslPolicies"
# discovery_method = "patch"
# rust_name = "update_ssl_policie"
# is_lro = true
# query_params = ["requestId"]

# --- sslPolicies.list ---
# GET projects/{project}/global/sslPolicies
# Lists all the SSL policies that have been configured for the specified project.
# Response: SslPoliciesList
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "sslPolicies"
# discovery_method = "list"
# rust_name = "list_ssl_policies"
# list_response = { type_name = "SslPoliciesList", items_field = "items", item_type = "SslPolicy" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- sslPolicies.delete ---
# DELETE projects/{project}/global/sslPolicies/{sslPolicy}
# Deletes the specified SSL policy. The SSL policy resource can be deleted only if it is not in use by
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "sslPolicies"
# discovery_method = "delete"
# rust_name = "delete_ssl_policie"
# is_lro = true
# query_params = ["requestId"]

# --- sslPolicies.listAvailableFeatures ---
# GET projects/{project}/global/sslPolicies/listAvailableFeatures
# Lists all features that can be specified in the SSL policy when using custom profile.
# Response: SslPoliciesListAvailableFeaturesResponse
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "sslPolicies"
# discovery_method = "listAvailableFeatures"
# rust_name = "listAvailableFeatures_ssl_policie"
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# --- sslPolicies.get ---
# GET projects/{project}/global/sslPolicies/{sslPolicy}
# Lists all of the ordered rules present in a single specified policy.
# Response: SslPolicy
# [[operations]]
# discovery_resource = "sslPolicies"
# discovery_method = "get"
# rust_name = "get_ssl_policie"

# --- instanceGroupManagerResizeRequests.delete ---
# DELETE projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/resizeRequests/{resizeRequest}
# Deletes the specified, inactive resize request. Requests that are still active cannot be deleted. De
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroupManagerResizeRequests"
# discovery_method = "delete"
# rust_name = "delete_instance_group_manager_resize_request"
# is_lro = true
# query_params = ["requestId"]

# --- instanceGroupManagerResizeRequests.get ---
# GET projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/resizeRequests/{resizeRequest}
# Returns all of the details about the specified resize request.
# Response: InstanceGroupManagerResizeRequest
# [[operations]]
# discovery_resource = "instanceGroupManagerResizeRequests"
# discovery_method = "get"
# rust_name = "get_instance_group_manager_resize_request"

# --- instanceGroupManagerResizeRequests.insert ---
# POST projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/resizeRequests
# Creates a new resize request that starts provisioning VMs immediately or queues VM creation.
# Request: InstanceGroupManagerResizeRequest
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroupManagerResizeRequests"
# discovery_method = "insert"
# rust_name = "create_instance_group_manager_resize_request"
# is_lro = true
# query_params = ["requestId"]

# --- instanceGroupManagerResizeRequests.cancel ---
# POST projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/resizeRequests/{resizeRequest}/cancel
# Cancels the specified resize request and removes it from the queue. Cancelled resize request does no
# Response: Operation
# Query params: requestId
# [[operations]]
# discovery_resource = "instanceGroupManagerResizeRequests"
# discovery_method = "cancel"
# rust_name = "cancel_instance_group_manager_resize_request"
# is_lro = true
# query_params = ["requestId"]

# --- instanceGroupManagerResizeRequests.list ---
# GET projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/resizeRequests
# Retrieves a list of resize requests that are contained in the managed instance group.
# Response: InstanceGroupManagerResizeRequestsListResponse
# Query params: filter, maxResults, orderBy, pageToken, returnPartialSuccess
# [[operations]]
# discovery_resource = "instanceGroupManagerResizeRequests"
# discovery_method = "list"
# rust_name = "list_instance_group_manager_resize_requests"
# list_response = { type_name = "InstanceGroupManagerResizeRequestsListResponse", items_field = "items", item_type = "InstanceGroupManagerResizeRequest" }
# query_params = ["filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess"]

# ======================================================================
# COVERAGE SUMMARY
# ======================================================================
# Schemas in discovery: 907
# Schemas in manifest:  24
# Coverage: 24/907 (2%)
#
# Operations in discovery: 901
# Operations in manifest:  31
# Coverage: 31/901 (3%)
#
# format:"byte" fields in manifest types: 9
# Unhandled (missing format="bytes"): 9