module Google::Cloud::Compute

Constants

VERSION

Public Class Methods

accelerator_types(version: :v1, &block) click to toggle source

Create a new client object for AcceleratorTypes.

By default, this returns an instance of [Google::Cloud::Compute::V1::AcceleratorTypes::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/AcceleratorTypes/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the AcceleratorTypes service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About AcceleratorTypes

Services

The AcceleratorTypes API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [AcceleratorTypes::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 65
def self.accelerator_types version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:AcceleratorTypes).const_get(:Rest).const_get(:Client).new(&block)
end
addresses(version: :v1, &block) click to toggle source

Create a new client object for Addresses.

By default, this returns an instance of [Google::Cloud::Compute::V1::Addresses::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/Addresses/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the Addresses service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About Addresses

The Addresses API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [Addresses::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 95
def self.addresses version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:Addresses).const_get(:Rest).const_get(:Client).new(&block)
end
autoscalers(version: :v1, &block) click to toggle source

Create a new client object for Autoscalers.

By default, this returns an instance of [Google::Cloud::Compute::V1::Autoscalers::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/Autoscalers/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the Autoscalers service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About Autoscalers

The Autoscalers API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [Autoscalers::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 125
def self.autoscalers version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:Autoscalers).const_get(:Rest).const_get(:Client).new(&block)
end
backend_buckets(version: :v1, &block) click to toggle source

Create a new client object for BackendBuckets.

By default, this returns an instance of [Google::Cloud::Compute::V1::BackendBuckets::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/BackendBuckets/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the BackendBuckets service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About BackendBuckets

The BackendBuckets API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [BackendBuckets::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 155
def self.backend_buckets version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:BackendBuckets).const_get(:Rest).const_get(:Client).new(&block)
end
backend_services(version: :v1, &block) click to toggle source

Create a new client object for BackendServices.

By default, this returns an instance of [Google::Cloud::Compute::V1::BackendServices::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/BackendServices/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the BackendServices service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About BackendServices

The BackendServices API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [BackendServices::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 185
def self.backend_services version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:BackendServices).const_get(:Rest).const_get(:Client).new(&block)
end
configure() { |configure.compute| ... } click to toggle source

Configure the google-cloud-compute library.

The following configuration parameters are supported:

  • `credentials` (type: `String, Hash, Google::Auth::Credentials`) - The path to the keyfile as a String, the contents of the keyfile as a Hash, or a Google::Auth::Credentials object.

  • `lib_name` (type: `String`) - The library name as recorded in instrumentation and logging.

  • `lib_version` (type: `String`) - The library version as recorded in instrumentation and logging.

  • `timeout` (type: `Numeric`) - Default timeout in seconds.

  • `metadata` (type: `Hash{Symbol=>String}`) - Additional REST headers to be sent with the call.

@return [::Google::Cloud::Config] The default configuration used by this library

# File lib/google/cloud/compute.rb, line 2675
def self.configure
  yield ::Google::Cloud.configure.compute if block_given?

  ::Google::Cloud.configure.compute
end
disk_types(version: :v1, &block) click to toggle source

Create a new client object for DiskTypes.

By default, this returns an instance of [Google::Cloud::Compute::V1::DiskTypes::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/DiskTypes/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the DiskTypes service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About DiskTypes

The DiskTypes API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [DiskTypes::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 215
def self.disk_types version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:DiskTypes).const_get(:Rest).const_get(:Client).new(&block)
end
disks(version: :v1, &block) click to toggle source

Create a new client object for Disks.

By default, this returns an instance of [Google::Cloud::Compute::V1::Disks::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/Disks/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the Disks service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About Disks

The Disks API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [Disks::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 245
def self.disks version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:Disks).const_get(:Rest).const_get(:Client).new(&block)
end
external_vpn_gateways(version: :v1, &block) click to toggle source

Create a new client object for ExternalVpnGateways.

By default, this returns an instance of [Google::Cloud::Compute::V1::ExternalVpnGateways::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/ExternalVpnGateways/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the ExternalVpnGateways service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About ExternalVpnGateways

The ExternalVpnGateways API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [ExternalVpnGateways::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 275
def self.external_vpn_gateways version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:ExternalVpnGateways).const_get(:Rest).const_get(:Client).new(&block)
end
firewall_policies(version: :v1, &block) click to toggle source

Create a new client object for FirewallPolicies.

By default, this returns an instance of [Google::Cloud::Compute::V1::FirewallPolicies::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/FirewallPolicies/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the FirewallPolicies service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About FirewallPolicies

The FirewallPolicies API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [FirewallPolicies::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 305
def self.firewall_policies version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:FirewallPolicies).const_get(:Rest).const_get(:Client).new(&block)
end
firewalls(version: :v1, &block) click to toggle source

Create a new client object for Firewalls.

By default, this returns an instance of [Google::Cloud::Compute::V1::Firewalls::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/Firewalls/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the Firewalls service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About Firewalls

The Firewalls API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [Firewalls::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 335
def self.firewalls version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:Firewalls).const_get(:Rest).const_get(:Client).new(&block)
end
forwarding_rules(version: :v1, &block) click to toggle source

Create a new client object for ForwardingRules.

By default, this returns an instance of [Google::Cloud::Compute::V1::ForwardingRules::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/ForwardingRules/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the ForwardingRules service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About ForwardingRules

The ForwardingRules API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [ForwardingRules::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 365
def self.forwarding_rules version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:ForwardingRules).const_get(:Rest).const_get(:Client).new(&block)
end
global_addresses(version: :v1, &block) click to toggle source

Create a new client object for GlobalAddresses.

By default, this returns an instance of [Google::Cloud::Compute::V1::GlobalAddresses::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/GlobalAddresses/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the GlobalAddresses service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About GlobalAddresses

The GlobalAddresses API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [GlobalAddresses::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 395
def self.global_addresses version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:GlobalAddresses).const_get(:Rest).const_get(:Client).new(&block)
end
global_forwarding_rules(version: :v1, &block) click to toggle source

Create a new client object for GlobalForwardingRules.

By default, this returns an instance of [Google::Cloud::Compute::V1::GlobalForwardingRules::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/GlobalForwardingRules/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the GlobalForwardingRules service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About GlobalForwardingRules

The GlobalForwardingRules API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [GlobalForwardingRules::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 425
def self.global_forwarding_rules version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:GlobalForwardingRules).const_get(:Rest).const_get(:Client).new(&block)
end
global_network_endpoint_groups(version: :v1, &block) click to toggle source

Create a new client object for GlobalNetworkEndpointGroups.

By default, this returns an instance of [Google::Cloud::Compute::V1::GlobalNetworkEndpointGroups::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/GlobalNetworkEndpointGroups/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the GlobalNetworkEndpointGroups service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About GlobalNetworkEndpointGroups

The GlobalNetworkEndpointGroups API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [GlobalNetworkEndpointGroups::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 455
def self.global_network_endpoint_groups version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:GlobalNetworkEndpointGroups).const_get(:Rest).const_get(:Client).new(&block)
end
global_operations(version: :v1, &block) click to toggle source

Create a new client object for GlobalOperations.

By default, this returns an instance of [Google::Cloud::Compute::V1::GlobalOperations::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/GlobalOperations/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the GlobalOperations service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About GlobalOperations

The GlobalOperations API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [GlobalOperations::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 485
def self.global_operations version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:GlobalOperations).const_get(:Rest).const_get(:Client).new(&block)
end
global_organization_operations(version: :v1, &block) click to toggle source

Create a new client object for GlobalOrganizationOperations.

By default, this returns an instance of [Google::Cloud::Compute::V1::GlobalOrganizationOperations::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/GlobalOrganizationOperations/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the GlobalOrganizationOperations service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About GlobalOrganizationOperations

The GlobalOrganizationOperations API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [GlobalOrganizationOperations::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 515
def self.global_organization_operations version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:GlobalOrganizationOperations).const_get(:Rest).const_get(:Client).new(&block)
end
global_public_delegated_prefixes(version: :v1, &block) click to toggle source

Create a new client object for GlobalPublicDelegatedPrefixes.

By default, this returns an instance of [Google::Cloud::Compute::V1::GlobalPublicDelegatedPrefixes::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/GlobalPublicDelegatedPrefixes/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the GlobalPublicDelegatedPrefixes service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About GlobalPublicDelegatedPrefixes

The GlobalPublicDelegatedPrefixes API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [GlobalPublicDelegatedPrefixes::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 545
def self.global_public_delegated_prefixes version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:GlobalPublicDelegatedPrefixes).const_get(:Rest).const_get(:Client).new(&block)
end
health_checks(version: :v1, &block) click to toggle source

Create a new client object for HealthChecks.

By default, this returns an instance of [Google::Cloud::Compute::V1::HealthChecks::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/HealthChecks/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the HealthChecks service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About HealthChecks

The HealthChecks API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [HealthChecks::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 575
def self.health_checks version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:HealthChecks).const_get(:Rest).const_get(:Client).new(&block)
end
image_family_views(version: :v1, &block) click to toggle source

Create a new client object for ImageFamilyViews.

By default, this returns an instance of [Google::Cloud::Compute::V1::ImageFamilyViews::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/ImageFamilyViews/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the ImageFamilyViews service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About ImageFamilyViews

The ImageFamilyViews API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [ImageFamilyViews::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 605
def self.image_family_views version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:ImageFamilyViews).const_get(:Rest).const_get(:Client).new(&block)
end
images(version: :v1, &block) click to toggle source

Create a new client object for Images.

By default, this returns an instance of [Google::Cloud::Compute::V1::Images::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/Images/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the Images service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About Images

The Images API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [Images::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 635
def self.images version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:Images).const_get(:Rest).const_get(:Client).new(&block)
end
instance_group_managers(version: :v1, &block) click to toggle source

Create a new client object for InstanceGroupManagers.

By default, this returns an instance of [Google::Cloud::Compute::V1::InstanceGroupManagers::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/InstanceGroupManagers/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the InstanceGroupManagers service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About InstanceGroupManagers

The InstanceGroupManagers API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [InstanceGroupManagers::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 665
def self.instance_group_managers version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:InstanceGroupManagers).const_get(:Rest).const_get(:Client).new(&block)
end
instance_groups(version: :v1, &block) click to toggle source

Create a new client object for InstanceGroups.

By default, this returns an instance of [Google::Cloud::Compute::V1::InstanceGroups::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/InstanceGroups/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the InstanceGroups service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About InstanceGroups

The InstanceGroups API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [InstanceGroups::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 695
def self.instance_groups version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:InstanceGroups).const_get(:Rest).const_get(:Client).new(&block)
end
instance_templates(version: :v1, &block) click to toggle source

Create a new client object for InstanceTemplates.

By default, this returns an instance of [Google::Cloud::Compute::V1::InstanceTemplates::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/InstanceTemplates/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the InstanceTemplates service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About InstanceTemplates

The InstanceTemplates API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [InstanceTemplates::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 725
def self.instance_templates version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:InstanceTemplates).const_get(:Rest).const_get(:Client).new(&block)
end
instances(version: :v1, &block) click to toggle source

Create a new client object for Instances.

By default, this returns an instance of [Google::Cloud::Compute::V1::Instances::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/Instances/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the Instances service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About Instances

The Instances API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [Instances::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 755
def self.instances version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:Instances).const_get(:Rest).const_get(:Client).new(&block)
end
interconnect_attachments(version: :v1, &block) click to toggle source

Create a new client object for InterconnectAttachments.

By default, this returns an instance of [Google::Cloud::Compute::V1::InterconnectAttachments::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/InterconnectAttachments/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the InterconnectAttachments service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About InterconnectAttachments

The InterconnectAttachments API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [InterconnectAttachments::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 785
def self.interconnect_attachments version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:InterconnectAttachments).const_get(:Rest).const_get(:Client).new(&block)
end
interconnect_locations(version: :v1, &block) click to toggle source

Create a new client object for InterconnectLocations.

By default, this returns an instance of [Google::Cloud::Compute::V1::InterconnectLocations::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/InterconnectLocations/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the InterconnectLocations service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About InterconnectLocations

The InterconnectLocations API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [InterconnectLocations::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 815
def self.interconnect_locations version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:InterconnectLocations).const_get(:Rest).const_get(:Client).new(&block)
end
interconnects(version: :v1, &block) click to toggle source

Create a new client object for Interconnects.

By default, this returns an instance of [Google::Cloud::Compute::V1::Interconnects::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/Interconnects/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the Interconnects service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About Interconnects

The Interconnects API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [Interconnects::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 845
def self.interconnects version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:Interconnects).const_get(:Rest).const_get(:Client).new(&block)
end
license_codes(version: :v1, &block) click to toggle source

Create a new client object for LicenseCodes.

By default, this returns an instance of [Google::Cloud::Compute::V1::LicenseCodes::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/LicenseCodes/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the LicenseCodes service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About LicenseCodes

The LicenseCodes API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [LicenseCodes::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 875
def self.license_codes version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:LicenseCodes).const_get(:Rest).const_get(:Client).new(&block)
end
licenses(version: :v1, &block) click to toggle source

Create a new client object for Licenses.

By default, this returns an instance of [Google::Cloud::Compute::V1::Licenses::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/Licenses/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the Licenses service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About Licenses

The Licenses API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [Licenses::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 905
def self.licenses version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:Licenses).const_get(:Rest).const_get(:Client).new(&block)
end
machine_images(version: :v1, &block) click to toggle source

Create a new client object for MachineImages.

By default, this returns an instance of [Google::Cloud::Compute::V1::MachineImages::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/MachineImages/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the MachineImages service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About MachineImages

The MachineImages API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [MachineImages::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 935
def self.machine_images version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:MachineImages).const_get(:Rest).const_get(:Client).new(&block)
end
machine_types(version: :v1, &block) click to toggle source

Create a new client object for MachineTypes.

By default, this returns an instance of [Google::Cloud::Compute::V1::MachineTypes::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/MachineTypes/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the MachineTypes service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About MachineTypes

The MachineTypes API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [MachineTypes::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 965
def self.machine_types version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:MachineTypes).const_get(:Rest).const_get(:Client).new(&block)
end
network_edge_security_services(version: :v1, &block) click to toggle source

Create a new client object for NetworkEdgeSecurityServices.

By default, this returns an instance of [Google::Cloud::Compute::V1::NetworkEdgeSecurityServices::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/NetworkEdgeSecurityServices/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the NetworkEdgeSecurityServices service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About NetworkEdgeSecurityServices

The NetworkEdgeSecurityServices API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [NetworkEdgeSecurityServices::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 995
def self.network_edge_security_services version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:NetworkEdgeSecurityServices).const_get(:Rest).const_get(:Client).new(&block)
end
network_endpoint_groups(version: :v1, &block) click to toggle source

Create a new client object for NetworkEndpointGroups.

By default, this returns an instance of [Google::Cloud::Compute::V1::NetworkEndpointGroups::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/NetworkEndpointGroups/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the NetworkEndpointGroups service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About NetworkEndpointGroups

The NetworkEndpointGroups API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [NetworkEndpointGroups::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1025
def self.network_endpoint_groups version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:NetworkEndpointGroups).const_get(:Rest).const_get(:Client).new(&block)
end
network_firewall_policies(version: :v1, &block) click to toggle source

Create a new client object for NetworkFirewallPolicies.

By default, this returns an instance of [Google::Cloud::Compute::V1::NetworkFirewallPolicies::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/NetworkFirewallPolicies/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the NetworkFirewallPolicies service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About NetworkFirewallPolicies

The NetworkFirewallPolicies API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [NetworkFirewallPolicies::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1055
def self.network_firewall_policies version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:NetworkFirewallPolicies).const_get(:Rest).const_get(:Client).new(&block)
end
networks(version: :v1, &block) click to toggle source

Create a new client object for Networks.

By default, this returns an instance of [Google::Cloud::Compute::V1::Networks::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/Networks/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the Networks service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About Networks

The Networks API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [Networks::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1085
def self.networks version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:Networks).const_get(:Rest).const_get(:Client).new(&block)
end
node_groups(version: :v1, &block) click to toggle source

Create a new client object for NodeGroups.

By default, this returns an instance of [Google::Cloud::Compute::V1::NodeGroups::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/NodeGroups/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the NodeGroups service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About NodeGroups

The NodeGroups API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [NodeGroups::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1115
def self.node_groups version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:NodeGroups).const_get(:Rest).const_get(:Client).new(&block)
end
node_templates(version: :v1, &block) click to toggle source

Create a new client object for NodeTemplates.

By default, this returns an instance of [Google::Cloud::Compute::V1::NodeTemplates::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/NodeTemplates/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the NodeTemplates service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About NodeTemplates

The NodeTemplates API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [NodeTemplates::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1145
def self.node_templates version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:NodeTemplates).const_get(:Rest).const_get(:Client).new(&block)
end
node_types(version: :v1, &block) click to toggle source

Create a new client object for NodeTypes.

By default, this returns an instance of [Google::Cloud::Compute::V1::NodeTypes::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/NodeTypes/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the NodeTypes service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About NodeTypes

The NodeTypes API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [NodeTypes::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1175
def self.node_types version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:NodeTypes).const_get(:Rest).const_get(:Client).new(&block)
end
packet_mirrorings(version: :v1, &block) click to toggle source

Create a new client object for PacketMirrorings.

By default, this returns an instance of [Google::Cloud::Compute::V1::PacketMirrorings::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/PacketMirrorings/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the PacketMirrorings service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About PacketMirrorings

The PacketMirrorings API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [PacketMirrorings::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1205
def self.packet_mirrorings version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:PacketMirrorings).const_get(:Rest).const_get(:Client).new(&block)
end
projects(version: :v1, &block) click to toggle source

Create a new client object for Projects.

By default, this returns an instance of [Google::Cloud::Compute::V1::Projects::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/Projects/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the Projects service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About Projects

The Projects API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [Projects::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1235
def self.projects version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:Projects).const_get(:Rest).const_get(:Client).new(&block)
end
public_advertised_prefixes(version: :v1, &block) click to toggle source

Create a new client object for PublicAdvertisedPrefixes.

By default, this returns an instance of [Google::Cloud::Compute::V1::PublicAdvertisedPrefixes::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/PublicAdvertisedPrefixes/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the PublicAdvertisedPrefixes service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About PublicAdvertisedPrefixes

The PublicAdvertisedPrefixes API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [PublicAdvertisedPrefixes::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1265
def self.public_advertised_prefixes version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:PublicAdvertisedPrefixes).const_get(:Rest).const_get(:Client).new(&block)
end
public_delegated_prefixes(version: :v1, &block) click to toggle source

Create a new client object for PublicDelegatedPrefixes.

By default, this returns an instance of [Google::Cloud::Compute::V1::PublicDelegatedPrefixes::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/PublicDelegatedPrefixes/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the PublicDelegatedPrefixes service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About PublicDelegatedPrefixes

The PublicDelegatedPrefixes API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [PublicDelegatedPrefixes::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1295
def self.public_delegated_prefixes version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:PublicDelegatedPrefixes).const_get(:Rest).const_get(:Client).new(&block)
end
region_autoscalers(version: :v1, &block) click to toggle source

Create a new client object for RegionAutoscalers.

By default, this returns an instance of [Google::Cloud::Compute::V1::RegionAutoscalers::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/RegionAutoscalers/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the RegionAutoscalers service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About RegionAutoscalers

The RegionAutoscalers API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [RegionAutoscalers::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1325
def self.region_autoscalers version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:RegionAutoscalers).const_get(:Rest).const_get(:Client).new(&block)
end
region_backend_services(version: :v1, &block) click to toggle source

Create a new client object for RegionBackendServices.

By default, this returns an instance of [Google::Cloud::Compute::V1::RegionBackendServices::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/RegionBackendServices/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the RegionBackendServices service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About RegionBackendServices

The RegionBackendServices API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [RegionBackendServices::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1355
def self.region_backend_services version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:RegionBackendServices).const_get(:Rest).const_get(:Client).new(&block)
end
region_commitments(version: :v1, &block) click to toggle source

Create a new client object for RegionCommitments.

By default, this returns an instance of [Google::Cloud::Compute::V1::RegionCommitments::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/RegionCommitments/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the RegionCommitments service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About RegionCommitments

The RegionCommitments API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [RegionCommitments::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1385
def self.region_commitments version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:RegionCommitments).const_get(:Rest).const_get(:Client).new(&block)
end
region_disk_types(version: :v1, &block) click to toggle source

Create a new client object for RegionDiskTypes.

By default, this returns an instance of [Google::Cloud::Compute::V1::RegionDiskTypes::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/RegionDiskTypes/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the RegionDiskTypes service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About RegionDiskTypes

The RegionDiskTypes API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [RegionDiskTypes::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1415
def self.region_disk_types version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:RegionDiskTypes).const_get(:Rest).const_get(:Client).new(&block)
end
region_disks(version: :v1, &block) click to toggle source

Create a new client object for RegionDisks.

By default, this returns an instance of [Google::Cloud::Compute::V1::RegionDisks::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/RegionDisks/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the RegionDisks service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About RegionDisks

The RegionDisks API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [RegionDisks::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1445
def self.region_disks version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:RegionDisks).const_get(:Rest).const_get(:Client).new(&block)
end
region_health_check_services(version: :v1, &block) click to toggle source

Create a new client object for RegionHealthCheckServices.

By default, this returns an instance of [Google::Cloud::Compute::V1::RegionHealthCheckServices::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/RegionHealthCheckServices/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the RegionHealthCheckServices service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About RegionHealthCheckServices

The RegionHealthCheckServices API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [RegionHealthCheckServices::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1475
def self.region_health_check_services version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:RegionHealthCheckServices).const_get(:Rest).const_get(:Client).new(&block)
end
region_health_checks(version: :v1, &block) click to toggle source

Create a new client object for RegionHealthChecks.

By default, this returns an instance of [Google::Cloud::Compute::V1::RegionHealthChecks::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/RegionHealthChecks/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the RegionHealthChecks service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About RegionHealthChecks

The RegionHealthChecks API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [RegionHealthChecks::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1505
def self.region_health_checks version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:RegionHealthChecks).const_get(:Rest).const_get(:Client).new(&block)
end
region_instance_group_managers(version: :v1, &block) click to toggle source

Create a new client object for RegionInstanceGroupManagers.

By default, this returns an instance of [Google::Cloud::Compute::V1::RegionInstanceGroupManagers::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/RegionInstanceGroupManagers/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the RegionInstanceGroupManagers service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About RegionInstanceGroupManagers

The RegionInstanceGroupManagers API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [RegionInstanceGroupManagers::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1535
def self.region_instance_group_managers version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:RegionInstanceGroupManagers).const_get(:Rest).const_get(:Client).new(&block)
end
region_instance_groups(version: :v1, &block) click to toggle source

Create a new client object for RegionInstanceGroups.

By default, this returns an instance of [Google::Cloud::Compute::V1::RegionInstanceGroups::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/RegionInstanceGroups/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the RegionInstanceGroups service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About RegionInstanceGroups

The RegionInstanceGroups API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [RegionInstanceGroups::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1565
def self.region_instance_groups version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:RegionInstanceGroups).const_get(:Rest).const_get(:Client).new(&block)
end
region_instances(version: :v1, &block) click to toggle source

Create a new client object for RegionInstances.

By default, this returns an instance of [Google::Cloud::Compute::V1::RegionInstances::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/RegionInstances/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the RegionInstances service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About RegionInstances

The RegionInstances API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [RegionInstances::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1595
def self.region_instances version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:RegionInstances).const_get(:Rest).const_get(:Client).new(&block)
end
region_network_endpoint_groups(version: :v1, &block) click to toggle source

Create a new client object for RegionNetworkEndpointGroups.

By default, this returns an instance of [Google::Cloud::Compute::V1::RegionNetworkEndpointGroups::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/RegionNetworkEndpointGroups/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the RegionNetworkEndpointGroups service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About RegionNetworkEndpointGroups

The RegionNetworkEndpointGroups API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [RegionNetworkEndpointGroups::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1625
def self.region_network_endpoint_groups version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:RegionNetworkEndpointGroups).const_get(:Rest).const_get(:Client).new(&block)
end
region_network_firewall_policies(version: :v1, &block) click to toggle source

Create a new client object for RegionNetworkFirewallPolicies.

By default, this returns an instance of [Google::Cloud::Compute::V1::RegionNetworkFirewallPolicies::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/RegionNetworkFirewallPolicies/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the RegionNetworkFirewallPolicies service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About RegionNetworkFirewallPolicies

The RegionNetworkFirewallPolicies API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [RegionNetworkFirewallPolicies::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1655
def self.region_network_firewall_policies version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:RegionNetworkFirewallPolicies).const_get(:Rest).const_get(:Client).new(&block)
end
region_notification_endpoints(version: :v1, &block) click to toggle source

Create a new client object for RegionNotificationEndpoints.

By default, this returns an instance of [Google::Cloud::Compute::V1::RegionNotificationEndpoints::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/RegionNotificationEndpoints/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the RegionNotificationEndpoints service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About RegionNotificationEndpoints

The RegionNotificationEndpoints API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [RegionNotificationEndpoints::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1685
def self.region_notification_endpoints version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:RegionNotificationEndpoints).const_get(:Rest).const_get(:Client).new(&block)
end
region_operations(version: :v1, &block) click to toggle source

Create a new client object for RegionOperations.

By default, this returns an instance of [Google::Cloud::Compute::V1::RegionOperations::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/RegionOperations/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the RegionOperations service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About RegionOperations

The RegionOperations API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [RegionOperations::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1715
def self.region_operations version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:RegionOperations).const_get(:Rest).const_get(:Client).new(&block)
end
region_security_policies(version: :v1, &block) click to toggle source

Create a new client object for RegionSecurityPolicies.

By default, this returns an instance of [Google::Cloud::Compute::V1::RegionSecurityPolicies::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/RegionSecurityPolicies/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the RegionSecurityPolicies service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About RegionSecurityPolicies

The RegionSecurityPolicies API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [RegionSecurityPolicies::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1745
def self.region_security_policies version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:RegionSecurityPolicies).const_get(:Rest).const_get(:Client).new(&block)
end
region_ssl_certificates(version: :v1, &block) click to toggle source

Create a new client object for RegionSslCertificates.

By default, this returns an instance of [Google::Cloud::Compute::V1::RegionSslCertificates::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/RegionSslCertificates/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the RegionSslCertificates service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About RegionSslCertificates

The RegionSslCertificates API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [RegionSslCertificates::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1775
def self.region_ssl_certificates version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:RegionSslCertificates).const_get(:Rest).const_get(:Client).new(&block)
end
region_ssl_policies(version: :v1, &block) click to toggle source

Create a new client object for RegionSslPolicies.

By default, this returns an instance of [Google::Cloud::Compute::V1::RegionSslPolicies::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/RegionSslPolicies/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the RegionSslPolicies service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About RegionSslPolicies

The RegionSslPolicies API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [RegionSslPolicies::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1805
def self.region_ssl_policies version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:RegionSslPolicies).const_get(:Rest).const_get(:Client).new(&block)
end
region_target_http_proxies(version: :v1, &block) click to toggle source

Create a new client object for RegionTargetHttpProxies.

By default, this returns an instance of [Google::Cloud::Compute::V1::RegionTargetHttpProxies::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/RegionTargetHttpProxies/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the RegionTargetHttpProxies service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About RegionTargetHttpProxies

The RegionTargetHttpProxies API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [RegionTargetHttpProxies::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1835
def self.region_target_http_proxies version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:RegionTargetHttpProxies).const_get(:Rest).const_get(:Client).new(&block)
end
region_target_https_proxies(version: :v1, &block) click to toggle source

Create a new client object for RegionTargetHttpsProxies.

By default, this returns an instance of [Google::Cloud::Compute::V1::RegionTargetHttpsProxies::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/RegionTargetHttpsProxies/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the RegionTargetHttpsProxies service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About RegionTargetHttpsProxies

The RegionTargetHttpsProxies API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [RegionTargetHttpsProxies::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1865
def self.region_target_https_proxies version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:RegionTargetHttpsProxies).const_get(:Rest).const_get(:Client).new(&block)
end
region_target_tcp_proxies(version: :v1, &block) click to toggle source

Create a new client object for RegionTargetTcpProxies.

By default, this returns an instance of [Google::Cloud::Compute::V1::RegionTargetTcpProxies::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/RegionTargetTcpProxies/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the RegionTargetTcpProxies service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About RegionTargetTcpProxies

The RegionTargetTcpProxies API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [RegionTargetTcpProxies::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1895
def self.region_target_tcp_proxies version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:RegionTargetTcpProxies).const_get(:Rest).const_get(:Client).new(&block)
end
region_url_maps(version: :v1, &block) click to toggle source

Create a new client object for RegionUrlMaps.

By default, this returns an instance of [Google::Cloud::Compute::V1::RegionUrlMaps::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/RegionUrlMaps/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the RegionUrlMaps service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About RegionUrlMaps

The RegionUrlMaps API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [RegionUrlMaps::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1925
def self.region_url_maps version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:RegionUrlMaps).const_get(:Rest).const_get(:Client).new(&block)
end
regions(version: :v1, &block) click to toggle source

Create a new client object for Regions.

By default, this returns an instance of [Google::Cloud::Compute::V1::Regions::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/Regions/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the Regions service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About Regions

The Regions API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [Regions::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1955
def self.regions version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:Regions).const_get(:Rest).const_get(:Client).new(&block)
end
reservations(version: :v1, &block) click to toggle source

Create a new client object for Reservations.

By default, this returns an instance of [Google::Cloud::Compute::V1::Reservations::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/Reservations/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the Reservations service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About Reservations

The Reservations API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [Reservations::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 1985
def self.reservations version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:Reservations).const_get(:Rest).const_get(:Client).new(&block)
end
resource_policies(version: :v1, &block) click to toggle source

Create a new client object for ResourcePolicies.

By default, this returns an instance of [Google::Cloud::Compute::V1::ResourcePolicies::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/ResourcePolicies/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the ResourcePolicies service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About ResourcePolicies

The ResourcePolicies API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [ResourcePolicies::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 2015
def self.resource_policies version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:ResourcePolicies).const_get(:Rest).const_get(:Client).new(&block)
end
routers(version: :v1, &block) click to toggle source

Create a new client object for Routers.

By default, this returns an instance of [Google::Cloud::Compute::V1::Routers::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/Routers/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the Routers service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About Routers

The Routers API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [Routers::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 2045
def self.routers version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:Routers).const_get(:Rest).const_get(:Client).new(&block)
end
routes(version: :v1, &block) click to toggle source

Create a new client object for Routes.

By default, this returns an instance of [Google::Cloud::Compute::V1::Routes::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/Routes/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the Routes service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About Routes

The Routes API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [Routes::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 2075
def self.routes version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:Routes).const_get(:Rest).const_get(:Client).new(&block)
end
security_policies(version: :v1, &block) click to toggle source

Create a new client object for SecurityPolicies.

By default, this returns an instance of [Google::Cloud::Compute::V1::SecurityPolicies::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/SecurityPolicies/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the SecurityPolicies service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About SecurityPolicies

The SecurityPolicies API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [SecurityPolicies::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 2105
def self.security_policies version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:SecurityPolicies).const_get(:Rest).const_get(:Client).new(&block)
end
service_attachments(version: :v1, &block) click to toggle source

Create a new client object for ServiceAttachments.

By default, this returns an instance of [Google::Cloud::Compute::V1::ServiceAttachments::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/ServiceAttachments/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the ServiceAttachments service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About ServiceAttachments

The ServiceAttachments API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [ServiceAttachments::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 2135
def self.service_attachments version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:ServiceAttachments).const_get(:Rest).const_get(:Client).new(&block)
end
snapshots(version: :v1, &block) click to toggle source

Create a new client object for Snapshots.

By default, this returns an instance of [Google::Cloud::Compute::V1::Snapshots::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/Snapshots/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the Snapshots service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About Snapshots

The Snapshots API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [Snapshots::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 2165
def self.snapshots version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:Snapshots).const_get(:Rest).const_get(:Client).new(&block)
end
ssl_certificates(version: :v1, &block) click to toggle source

Create a new client object for SslCertificates.

By default, this returns an instance of [Google::Cloud::Compute::V1::SslCertificates::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/SslCertificates/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the SslCertificates service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About SslCertificates

The SslCertificates API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [SslCertificates::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 2195
def self.ssl_certificates version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:SslCertificates).const_get(:Rest).const_get(:Client).new(&block)
end
ssl_policies(version: :v1, &block) click to toggle source

Create a new client object for SslPolicies.

By default, this returns an instance of [Google::Cloud::Compute::V1::SslPolicies::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/SslPolicies/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the SslPolicies service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About SslPolicies

The SslPolicies API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [SslPolicies::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 2225
def self.ssl_policies version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:SslPolicies).const_get(:Rest).const_get(:Client).new(&block)
end
subnetworks(version: :v1, &block) click to toggle source

Create a new client object for Subnetworks.

By default, this returns an instance of [Google::Cloud::Compute::V1::Subnetworks::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/Subnetworks/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the Subnetworks service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About Subnetworks

The Subnetworks API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [Subnetworks::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 2255
def self.subnetworks version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:Subnetworks).const_get(:Rest).const_get(:Client).new(&block)
end
target_grpc_proxies(version: :v1, &block) click to toggle source

Create a new client object for TargetGrpcProxies.

By default, this returns an instance of [Google::Cloud::Compute::V1::TargetGrpcProxies::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/TargetGrpcProxies/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the TargetGrpcProxies service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About TargetGrpcProxies

The TargetGrpcProxies API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [TargetGrpcProxies::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 2285
def self.target_grpc_proxies version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:TargetGrpcProxies).const_get(:Rest).const_get(:Client).new(&block)
end
target_http_proxies(version: :v1, &block) click to toggle source

Create a new client object for TargetHttpProxies.

By default, this returns an instance of [Google::Cloud::Compute::V1::TargetHttpProxies::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/TargetHttpProxies/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the TargetHttpProxies service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About TargetHttpProxies

The TargetHttpProxies API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [TargetHttpProxies::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 2315
def self.target_http_proxies version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:TargetHttpProxies).const_get(:Rest).const_get(:Client).new(&block)
end
target_https_proxies(version: :v1, &block) click to toggle source

Create a new client object for TargetHttpsProxies.

By default, this returns an instance of [Google::Cloud::Compute::V1::TargetHttpsProxies::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/TargetHttpsProxies/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the TargetHttpsProxies service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About TargetHttpsProxies

The TargetHttpsProxies API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [TargetHttpsProxies::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 2345
def self.target_https_proxies version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:TargetHttpsProxies).const_get(:Rest).const_get(:Client).new(&block)
end
target_instances(version: :v1, &block) click to toggle source

Create a new client object for TargetInstances.

By default, this returns an instance of [Google::Cloud::Compute::V1::TargetInstances::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/TargetInstances/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the TargetInstances service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About TargetInstances

The TargetInstances API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [TargetInstances::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 2375
def self.target_instances version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:TargetInstances).const_get(:Rest).const_get(:Client).new(&block)
end
target_pools(version: :v1, &block) click to toggle source

Create a new client object for TargetPools.

By default, this returns an instance of [Google::Cloud::Compute::V1::TargetPools::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/TargetPools/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the TargetPools service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About TargetPools

The TargetPools API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [TargetPools::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 2405
def self.target_pools version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:TargetPools).const_get(:Rest).const_get(:Client).new(&block)
end
target_ssl_proxies(version: :v1, &block) click to toggle source

Create a new client object for TargetSslProxies.

By default, this returns an instance of [Google::Cloud::Compute::V1::TargetSslProxies::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/TargetSslProxies/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the TargetSslProxies service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About TargetSslProxies

The TargetSslProxies API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [TargetSslProxies::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 2435
def self.target_ssl_proxies version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:TargetSslProxies).const_get(:Rest).const_get(:Client).new(&block)
end
target_tcp_proxies(version: :v1, &block) click to toggle source

Create a new client object for TargetTcpProxies.

By default, this returns an instance of [Google::Cloud::Compute::V1::TargetTcpProxies::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/TargetTcpProxies/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the TargetTcpProxies service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About TargetTcpProxies

The TargetTcpProxies API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [TargetTcpProxies::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 2465
def self.target_tcp_proxies version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:TargetTcpProxies).const_get(:Rest).const_get(:Client).new(&block)
end
target_vpn_gateways(version: :v1, &block) click to toggle source

Create a new client object for TargetVpnGateways.

By default, this returns an instance of [Google::Cloud::Compute::V1::TargetVpnGateways::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/TargetVpnGateways/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the TargetVpnGateways service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About TargetVpnGateways

The TargetVpnGateways API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [TargetVpnGateways::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 2495
def self.target_vpn_gateways version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:TargetVpnGateways).const_get(:Rest).const_get(:Client).new(&block)
end
url_maps(version: :v1, &block) click to toggle source

Create a new client object for UrlMaps.

By default, this returns an instance of [Google::Cloud::Compute::V1::UrlMaps::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/UrlMaps/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the UrlMaps service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About UrlMaps

The UrlMaps API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [UrlMaps::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 2525
def self.url_maps version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:UrlMaps).const_get(:Rest).const_get(:Client).new(&block)
end
vpn_gateways(version: :v1, &block) click to toggle source

Create a new client object for VpnGateways.

By default, this returns an instance of [Google::Cloud::Compute::V1::VpnGateways::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/VpnGateways/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the VpnGateways service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About VpnGateways

The VpnGateways API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [VpnGateways::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 2555
def self.vpn_gateways version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:VpnGateways).const_get(:Rest).const_get(:Client).new(&block)
end
vpn_tunnels(version: :v1, &block) click to toggle source

Create a new client object for VpnTunnels.

By default, this returns an instance of [Google::Cloud::Compute::V1::VpnTunnels::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/VpnTunnels/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the VpnTunnels service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About VpnTunnels

The VpnTunnels API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [VpnTunnels::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 2585
def self.vpn_tunnels version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:VpnTunnels).const_get(:Rest).const_get(:Client).new(&block)
end
zone_operations(version: :v1, &block) click to toggle source

Create a new client object for ZoneOperations.

By default, this returns an instance of [Google::Cloud::Compute::V1::ZoneOperations::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/ZoneOperations/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the ZoneOperations service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About ZoneOperations

The ZoneOperations API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [ZoneOperations::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 2615
def self.zone_operations version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:ZoneOperations).const_get(:Rest).const_get(:Client).new(&block)
end
zones(version: :v1, &block) click to toggle source

Create a new client object for Zones.

By default, this returns an instance of [Google::Cloud::Compute::V1::Zones::Rest::Client](googleapis.dev/ruby/google-cloud-compute-v1/latest/Google/Cloud/Compute/V1/Zones/Rest/Client.html) for version V1 of the API. However, you can specify specify a different API version by passing it in the `version` parameter. If the Zones service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned.

## About Zones

The Zones API.

@param version [::String, ::Symbol] The API version to connect to. Optional.

Defaults to `:v1`.

@return [Zones::Rest::Client] A client object for the specified version.

# File lib/google/cloud/compute.rb, line 2645
def self.zones version: :v1, &block
  require "google/cloud/compute/#{version.to_s.downcase}"

  package_name = Google::Cloud::Compute
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  package_module = Google::Cloud::Compute.const_get package_name
  package_module.const_get(:Zones).const_get(:Rest).const_get(:Client).new(&block)
end