google-cloud-compute 1.9.0 → 1.10.0

data/lib/google/cloud/compute.rb

@@ -55,6 +55,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the AcceleratorTypes service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.accelerator_types_available?}.
+      #
       # ## About AcceleratorTypes
       #
       # Services
@@ -76,6 +81,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the AcceleratorTypes service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.accelerator_types}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the AcceleratorTypes service,
+      # or if the versioned client gem needs an update to support the AcceleratorTypes service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.accelerator_types_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :AcceleratorTypes
+        service_module = service_module.const_get :AcceleratorTypes
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for Addresses.
       #
@@ -87,6 +120,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the Addresses service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.addresses_available?}.
+      #
       # ## About Addresses
       #
       # The Addresses API.
@@ -106,6 +144,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the Addresses service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.addresses}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the Addresses service,
+      # or if the versioned client gem needs an update to support the Addresses service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.addresses_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :Addresses
+        service_module = service_module.const_get :Addresses
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for Autoscalers.
       #
@@ -117,6 +183,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the Autoscalers service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.autoscalers_available?}.
+      #
       # ## About Autoscalers
       #
       # The Autoscalers API.
@@ -136,6 +207,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the Autoscalers service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.autoscalers}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the Autoscalers service,
+      # or if the versioned client gem needs an update to support the Autoscalers service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.autoscalers_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :Autoscalers
+        service_module = service_module.const_get :Autoscalers
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for BackendBuckets.
       #
@@ -147,6 +246,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the BackendBuckets service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.backend_buckets_available?}.
+      #
       # ## About BackendBuckets
       #
       # The BackendBuckets API.
@@ -166,6 +270,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the BackendBuckets service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.backend_buckets}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the BackendBuckets service,
+      # or if the versioned client gem needs an update to support the BackendBuckets service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.backend_buckets_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :BackendBuckets
+        service_module = service_module.const_get :BackendBuckets
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for BackendServices.
       #
@@ -177,6 +309,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the BackendServices service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.backend_services_available?}.
+      #
       # ## About BackendServices
       #
       # The BackendServices API.
@@ -196,6 +333,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the BackendServices service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.backend_services}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the BackendServices service,
+      # or if the versioned client gem needs an update to support the BackendServices service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.backend_services_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :BackendServices
+        service_module = service_module.const_get :BackendServices
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for DiskTypes.
       #
@@ -207,6 +372,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the DiskTypes service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.disk_types_available?}.
+      #
       # ## About DiskTypes
       #
       # The DiskTypes API.
@@ -226,6 +396,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the DiskTypes service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.disk_types}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the DiskTypes service,
+      # or if the versioned client gem needs an update to support the DiskTypes service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.disk_types_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :DiskTypes
+        service_module = service_module.const_get :DiskTypes
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for Disks.
       #
@@ -237,6 +435,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the Disks service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.disks_available?}.
+      #
       # ## About Disks
       #
       # The Disks API.
@@ -256,6 +459,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the Disks service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.disks}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the Disks service,
+      # or if the versioned client gem needs an update to support the Disks service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.disks_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :Disks
+        service_module = service_module.const_get :Disks
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for ExternalVpnGateways.
       #
@@ -267,6 +498,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the ExternalVpnGateways service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.external_vpn_gateways_available?}.
+      #
       # ## About ExternalVpnGateways
       #
       # The ExternalVpnGateways API.
@@ -286,6 +522,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the ExternalVpnGateways service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.external_vpn_gateways}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the ExternalVpnGateways service,
+      # or if the versioned client gem needs an update to support the ExternalVpnGateways service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.external_vpn_gateways_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :ExternalVpnGateways
+        service_module = service_module.const_get :ExternalVpnGateways
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for FirewallPolicies.
       #
@@ -297,6 +561,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the FirewallPolicies service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.firewall_policies_available?}.
+      #
       # ## About FirewallPolicies
       #
       # The FirewallPolicies API.
@@ -316,6 +585,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the FirewallPolicies service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.firewall_policies}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the FirewallPolicies service,
+      # or if the versioned client gem needs an update to support the FirewallPolicies service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.firewall_policies_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :FirewallPolicies
+        service_module = service_module.const_get :FirewallPolicies
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for Firewalls.
       #
@@ -327,6 +624,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the Firewalls service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.firewalls_available?}.
+      #
       # ## About Firewalls
       #
       # The Firewalls API.
@@ -346,6 +648,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the Firewalls service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.firewalls}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the Firewalls service,
+      # or if the versioned client gem needs an update to support the Firewalls service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.firewalls_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :Firewalls
+        service_module = service_module.const_get :Firewalls
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for ForwardingRules.
       #
@@ -357,6 +687,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the ForwardingRules service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.forwarding_rules_available?}.
+      #
       # ## About ForwardingRules
       #
       # The ForwardingRules API.
@@ -376,6 +711,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the ForwardingRules service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.forwarding_rules}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the ForwardingRules service,
+      # or if the versioned client gem needs an update to support the ForwardingRules service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.forwarding_rules_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :ForwardingRules
+        service_module = service_module.const_get :ForwardingRules
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for GlobalAddresses.
       #
@@ -387,6 +750,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the GlobalAddresses service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.global_addresses_available?}.
+      #
       # ## About GlobalAddresses
       #
       # The GlobalAddresses API.
@@ -406,6 +774,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the GlobalAddresses service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.global_addresses}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the GlobalAddresses service,
+      # or if the versioned client gem needs an update to support the GlobalAddresses service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.global_addresses_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :GlobalAddresses
+        service_module = service_module.const_get :GlobalAddresses
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for GlobalForwardingRules.
       #
@@ -417,6 +813,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the GlobalForwardingRules service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.global_forwarding_rules_available?}.
+      #
       # ## About GlobalForwardingRules
       #
       # The GlobalForwardingRules API.
@@ -436,6 +837,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the GlobalForwardingRules service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.global_forwarding_rules}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the GlobalForwardingRules service,
+      # or if the versioned client gem needs an update to support the GlobalForwardingRules service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.global_forwarding_rules_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :GlobalForwardingRules
+        service_module = service_module.const_get :GlobalForwardingRules
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for GlobalNetworkEndpointGroups.
       #
@@ -447,6 +876,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the GlobalNetworkEndpointGroups service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.global_network_endpoint_groups_available?}.
+      #
       # ## About GlobalNetworkEndpointGroups
       #
       # The GlobalNetworkEndpointGroups API.
@@ -466,6 +900,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the GlobalNetworkEndpointGroups service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.global_network_endpoint_groups}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the GlobalNetworkEndpointGroups service,
+      # or if the versioned client gem needs an update to support the GlobalNetworkEndpointGroups service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.global_network_endpoint_groups_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :GlobalNetworkEndpointGroups
+        service_module = service_module.const_get :GlobalNetworkEndpointGroups
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for GlobalOperations.
       #
@@ -477,6 +939,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the GlobalOperations service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.global_operations_available?}.
+      #
       # ## About GlobalOperations
       #
       # The GlobalOperations API.
@@ -496,6 +963,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the GlobalOperations service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.global_operations}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the GlobalOperations service,
+      # or if the versioned client gem needs an update to support the GlobalOperations service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.global_operations_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :GlobalOperations
+        service_module = service_module.const_get :GlobalOperations
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for GlobalOrganizationOperations.
       #
@@ -507,6 +1002,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the GlobalOrganizationOperations service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.global_organization_operations_available?}.
+      #
       # ## About GlobalOrganizationOperations
       #
       # The GlobalOrganizationOperations API.
@@ -526,6 +1026,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the GlobalOrganizationOperations service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.global_organization_operations}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the GlobalOrganizationOperations service,
+      # or if the versioned client gem needs an update to support the GlobalOrganizationOperations service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.global_organization_operations_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :GlobalOrganizationOperations
+        service_module = service_module.const_get :GlobalOrganizationOperations
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for GlobalPublicDelegatedPrefixes.
       #
@@ -537,6 +1065,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the GlobalPublicDelegatedPrefixes service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.global_public_delegated_prefixes_available?}.
+      #
       # ## About GlobalPublicDelegatedPrefixes
       #
       # The GlobalPublicDelegatedPrefixes API.
@@ -556,6 +1089,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the GlobalPublicDelegatedPrefixes service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.global_public_delegated_prefixes}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the GlobalPublicDelegatedPrefixes service,
+      # or if the versioned client gem needs an update to support the GlobalPublicDelegatedPrefixes service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.global_public_delegated_prefixes_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :GlobalPublicDelegatedPrefixes
+        service_module = service_module.const_get :GlobalPublicDelegatedPrefixes
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for HealthChecks.
       #
@@ -567,6 +1128,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the HealthChecks service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.health_checks_available?}.
+      #
       # ## About HealthChecks
       #
       # The HealthChecks API.
@@ -586,6 +1152,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the HealthChecks service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.health_checks}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the HealthChecks service,
+      # or if the versioned client gem needs an update to support the HealthChecks service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.health_checks_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :HealthChecks
+        service_module = service_module.const_get :HealthChecks
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for ImageFamilyViews.
       #
@@ -597,6 +1191,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the ImageFamilyViews service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.image_family_views_available?}.
+      #
       # ## About ImageFamilyViews
       #
       # The ImageFamilyViews API.
@@ -616,6 +1215,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the ImageFamilyViews service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.image_family_views}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the ImageFamilyViews service,
+      # or if the versioned client gem needs an update to support the ImageFamilyViews service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.image_family_views_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :ImageFamilyViews
+        service_module = service_module.const_get :ImageFamilyViews
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for Images.
       #
@@ -627,6 +1254,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the Images service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.images_available?}.
+      #
       # ## About Images
       #
       # The Images API.
@@ -647,15 +1279,48 @@ module Google
       end
 
       ##
-      # Create a new client object for InstanceGroupManagerResizeRequests.
+      # Determines whether the Images service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.images}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the Images service,
+      # or if the versioned client gem needs an update to support the Images service.
       #
-      # By default, this returns an instance of
-      # [Google::Cloud::Compute::V1::InstanceGroupManagerResizeRequests::Rest::Client](https://cloud.google.com/ruby/docs/reference/google-cloud-compute-v1/latest/Google-Cloud-Compute-V1-InstanceGroupManagerResizeRequests-Rest-Client)
-      # for a REST client for version V1 of the API.
-      # However, you can specify a different API version by passing it in the
-      # `version` parameter. If the InstanceGroupManagerResizeRequests service is
-      # supported by that API version, and the corresponding gem is available, the
-      # appropriate versioned client will be returned.
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.images_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :Images
+        service_module = service_module.const_get :Images
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
+      ##
+      # Create a new client object for InstanceGroupManagerResizeRequests.
+      #
+      # By default, this returns an instance of
+      # [Google::Cloud::Compute::V1::InstanceGroupManagerResizeRequests::Rest::Client](https://cloud.google.com/ruby/docs/reference/google-cloud-compute-v1/latest/Google-Cloud-Compute-V1-InstanceGroupManagerResizeRequests-Rest-Client)
+      # for a REST client for version V1 of the API.
+      # However, you can specify a different API version by passing it in the
+      # `version` parameter. If the InstanceGroupManagerResizeRequests service is
+      # supported by that API version, and the corresponding gem is available, the
+      # appropriate versioned client will be returned.
+      #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the InstanceGroupManagerResizeRequests service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.instance_group_manager_resize_requests_available?}.
       #
       # ## About InstanceGroupManagerResizeRequests
       #
@@ -676,6 +1341,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the InstanceGroupManagerResizeRequests service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.instance_group_manager_resize_requests}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the InstanceGroupManagerResizeRequests service,
+      # or if the versioned client gem needs an update to support the InstanceGroupManagerResizeRequests service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.instance_group_manager_resize_requests_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :InstanceGroupManagerResizeRequests
+        service_module = service_module.const_get :InstanceGroupManagerResizeRequests
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for InstanceGroupManagers.
       #
@@ -687,6 +1380,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the InstanceGroupManagers service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.instance_group_managers_available?}.
+      #
       # ## About InstanceGroupManagers
       #
       # The InstanceGroupManagers API.
@@ -706,6 +1404,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the InstanceGroupManagers service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.instance_group_managers}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the InstanceGroupManagers service,
+      # or if the versioned client gem needs an update to support the InstanceGroupManagers service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.instance_group_managers_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :InstanceGroupManagers
+        service_module = service_module.const_get :InstanceGroupManagers
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for InstanceGroups.
       #
@@ -717,6 +1443,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the InstanceGroups service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.instance_groups_available?}.
+      #
       # ## About InstanceGroups
       #
       # The InstanceGroups API.
@@ -736,6 +1467,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the InstanceGroups service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.instance_groups}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the InstanceGroups service,
+      # or if the versioned client gem needs an update to support the InstanceGroups service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.instance_groups_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :InstanceGroups
+        service_module = service_module.const_get :InstanceGroups
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for InstanceSettingsService.
       #
@@ -747,6 +1506,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the InstanceSettingsService service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.instance_settings_service_available?}.
+      #
       # ## About InstanceSettingsService
       #
       # The InstanceSettings API.
@@ -766,6 +1530,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the InstanceSettingsService service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.instance_settings_service}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the InstanceSettingsService service,
+      # or if the versioned client gem needs an update to support the InstanceSettingsService service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.instance_settings_service_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :InstanceSettingsService
+        service_module = service_module.const_get :InstanceSettingsService
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for InstanceTemplates.
       #
@@ -777,6 +1569,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the InstanceTemplates service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.instance_templates_available?}.
+      #
       # ## About InstanceTemplates
       #
       # The InstanceTemplates API.
@@ -796,6 +1593,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the InstanceTemplates service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.instance_templates}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the InstanceTemplates service,
+      # or if the versioned client gem needs an update to support the InstanceTemplates service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.instance_templates_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :InstanceTemplates
+        service_module = service_module.const_get :InstanceTemplates
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for Instances.
       #
@@ -807,6 +1632,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the Instances service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.instances_available?}.
+      #
       # ## About Instances
       #
       # The Instances API.
@@ -826,6 +1656,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the Instances service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.instances}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the Instances service,
+      # or if the versioned client gem needs an update to support the Instances service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.instances_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :Instances
+        service_module = service_module.const_get :Instances
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for InstantSnapshots.
       #
@@ -837,6 +1695,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the InstantSnapshots service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.instant_snapshots_available?}.
+      #
       # ## About InstantSnapshots
       #
       # The InstantSnapshots API.
@@ -856,6 +1719,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the InstantSnapshots service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.instant_snapshots}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the InstantSnapshots service,
+      # or if the versioned client gem needs an update to support the InstantSnapshots service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.instant_snapshots_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :InstantSnapshots
+        service_module = service_module.const_get :InstantSnapshots
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for InterconnectAttachments.
       #
@@ -867,6 +1758,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the InterconnectAttachments service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.interconnect_attachments_available?}.
+      #
       # ## About InterconnectAttachments
       #
       # The InterconnectAttachments API.
@@ -886,6 +1782,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the InterconnectAttachments service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.interconnect_attachments}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the InterconnectAttachments service,
+      # or if the versioned client gem needs an update to support the InterconnectAttachments service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.interconnect_attachments_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :InterconnectAttachments
+        service_module = service_module.const_get :InterconnectAttachments
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for InterconnectLocations.
       #
@@ -897,6 +1821,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the InterconnectLocations service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.interconnect_locations_available?}.
+      #
       # ## About InterconnectLocations
       #
       # The InterconnectLocations API.
@@ -916,6 +1845,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the InterconnectLocations service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.interconnect_locations}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the InterconnectLocations service,
+      # or if the versioned client gem needs an update to support the InterconnectLocations service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.interconnect_locations_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :InterconnectLocations
+        service_module = service_module.const_get :InterconnectLocations
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for InterconnectRemoteLocations.
       #
@@ -927,6 +1884,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the InterconnectRemoteLocations service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.interconnect_remote_locations_available?}.
+      #
       # ## About InterconnectRemoteLocations
       #
       # The InterconnectRemoteLocations API.
@@ -946,6 +1908,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the InterconnectRemoteLocations service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.interconnect_remote_locations}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the InterconnectRemoteLocations service,
+      # or if the versioned client gem needs an update to support the InterconnectRemoteLocations service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.interconnect_remote_locations_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :InterconnectRemoteLocations
+        service_module = service_module.const_get :InterconnectRemoteLocations
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for Interconnects.
       #
@@ -957,6 +1947,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the Interconnects service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.interconnects_available?}.
+      #
       # ## About Interconnects
       #
       # The Interconnects API.
@@ -976,6 +1971,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the Interconnects service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.interconnects}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the Interconnects service,
+      # or if the versioned client gem needs an update to support the Interconnects service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.interconnects_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :Interconnects
+        service_module = service_module.const_get :Interconnects
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for LicenseCodes.
       #
@@ -987,6 +2010,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the LicenseCodes service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.license_codes_available?}.
+      #
       # ## About LicenseCodes
       #
       # The LicenseCodes API.
@@ -1006,6 +2034,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the LicenseCodes service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.license_codes}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the LicenseCodes service,
+      # or if the versioned client gem needs an update to support the LicenseCodes service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.license_codes_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :LicenseCodes
+        service_module = service_module.const_get :LicenseCodes
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for Licenses.
       #
@@ -1017,6 +2073,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the Licenses service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.licenses_available?}.
+      #
       # ## About Licenses
       #
       # The Licenses API.
@@ -1036,6 +2097,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the Licenses service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.licenses}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the Licenses service,
+      # or if the versioned client gem needs an update to support the Licenses service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.licenses_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :Licenses
+        service_module = service_module.const_get :Licenses
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for MachineImages.
       #
@@ -1047,6 +2136,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the MachineImages service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.machine_images_available?}.
+      #
       # ## About MachineImages
       #
       # The MachineImages API.
@@ -1066,6 +2160,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the MachineImages service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.machine_images}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the MachineImages service,
+      # or if the versioned client gem needs an update to support the MachineImages service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.machine_images_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :MachineImages
+        service_module = service_module.const_get :MachineImages
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for MachineTypes.
       #
@@ -1077,6 +2199,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the MachineTypes service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.machine_types_available?}.
+      #
       # ## About MachineTypes
       #
       # The MachineTypes API.
@@ -1096,6 +2223,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the MachineTypes service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.machine_types}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the MachineTypes service,
+      # or if the versioned client gem needs an update to support the MachineTypes service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.machine_types_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :MachineTypes
+        service_module = service_module.const_get :MachineTypes
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for NetworkAttachments.
       #
@@ -1107,6 +2262,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the NetworkAttachments service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.network_attachments_available?}.
+      #
       # ## About NetworkAttachments
       #
       # The NetworkAttachments API.
@@ -1126,6 +2286,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the NetworkAttachments service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.network_attachments}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the NetworkAttachments service,
+      # or if the versioned client gem needs an update to support the NetworkAttachments service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.network_attachments_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :NetworkAttachments
+        service_module = service_module.const_get :NetworkAttachments
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for NetworkEdgeSecurityServices.
       #
@@ -1137,6 +2325,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the NetworkEdgeSecurityServices service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.network_edge_security_services_available?}.
+      #
       # ## About NetworkEdgeSecurityServices
       #
       # The NetworkEdgeSecurityServices API.
@@ -1156,6 +2349,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the NetworkEdgeSecurityServices service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.network_edge_security_services}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the NetworkEdgeSecurityServices service,
+      # or if the versioned client gem needs an update to support the NetworkEdgeSecurityServices service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.network_edge_security_services_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :NetworkEdgeSecurityServices
+        service_module = service_module.const_get :NetworkEdgeSecurityServices
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for NetworkEndpointGroups.
       #
@@ -1167,6 +2388,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the NetworkEndpointGroups service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.network_endpoint_groups_available?}.
+      #
       # ## About NetworkEndpointGroups
       #
       # The NetworkEndpointGroups API.
@@ -1186,6 +2412,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the NetworkEndpointGroups service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.network_endpoint_groups}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the NetworkEndpointGroups service,
+      # or if the versioned client gem needs an update to support the NetworkEndpointGroups service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.network_endpoint_groups_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :NetworkEndpointGroups
+        service_module = service_module.const_get :NetworkEndpointGroups
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for NetworkFirewallPolicies.
       #
@@ -1197,6 +2451,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the NetworkFirewallPolicies service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.network_firewall_policies_available?}.
+      #
       # ## About NetworkFirewallPolicies
       #
       # The NetworkFirewallPolicies API.
@@ -1216,6 +2475,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the NetworkFirewallPolicies service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.network_firewall_policies}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the NetworkFirewallPolicies service,
+      # or if the versioned client gem needs an update to support the NetworkFirewallPolicies service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.network_firewall_policies_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :NetworkFirewallPolicies
+        service_module = service_module.const_get :NetworkFirewallPolicies
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for NetworkProfiles.
       #
@@ -1227,6 +2514,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the NetworkProfiles service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.network_profiles_available?}.
+      #
       # ## About NetworkProfiles
       #
       # The NetworkProfiles API.
@@ -1246,6 +2538,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the NetworkProfiles service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.network_profiles}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the NetworkProfiles service,
+      # or if the versioned client gem needs an update to support the NetworkProfiles service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.network_profiles_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :NetworkProfiles
+        service_module = service_module.const_get :NetworkProfiles
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for Networks.
       #
@@ -1257,6 +2577,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the Networks service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.networks_available?}.
+      #
       # ## About Networks
       #
       # The Networks API.
@@ -1276,6 +2601,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the Networks service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.networks}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the Networks service,
+      # or if the versioned client gem needs an update to support the Networks service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.networks_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :Networks
+        service_module = service_module.const_get :Networks
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for NodeGroups.
       #
@@ -1287,23 +2640,56 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the NodeGroups service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.node_groups_available?}.
+      #
       # ## About NodeGroups
       #
       # The NodeGroups API.
       #
       # @param version [::String, ::Symbol] The API version to connect to. Optional.
       #   Defaults to `:v1`.
-      # @return [::Object] A client object for the specified version.
+      # @return [::Object] A client object for the specified version.
+      #
+      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
+        service_module = Google::Cloud::Compute.const_get(package_name).const_get(:NodeGroups)
+        service_module.const_get(:Rest).const_get(:Client).new(&block)
+      end
+
+      ##
+      # Determines whether the NodeGroups service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.node_groups}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the NodeGroups service,
+      # or if the versioned client gem needs an update to support the NodeGroups service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
       #
-      def self.node_groups version: :v1, &block
+      def self.node_groups_available? version: :v1
         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
-        service_module = Google::Cloud::Compute.const_get(package_name).const_get(:NodeGroups)
-        service_module.const_get(:Rest).const_get(:Client).new(&block)
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :NodeGroups
+        service_module = service_module.const_get :NodeGroups
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
       end
 
       ##
@@ -1317,6 +2703,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the NodeTemplates service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.node_templates_available?}.
+      #
       # ## About NodeTemplates
       #
       # The NodeTemplates API.
@@ -1336,6 +2727,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the NodeTemplates service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.node_templates}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the NodeTemplates service,
+      # or if the versioned client gem needs an update to support the NodeTemplates service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.node_templates_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :NodeTemplates
+        service_module = service_module.const_get :NodeTemplates
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for NodeTypes.
       #
@@ -1347,6 +2766,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the NodeTypes service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.node_types_available?}.
+      #
       # ## About NodeTypes
       #
       # The NodeTypes API.
@@ -1366,6 +2790,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the NodeTypes service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.node_types}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the NodeTypes service,
+      # or if the versioned client gem needs an update to support the NodeTypes service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.node_types_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :NodeTypes
+        service_module = service_module.const_get :NodeTypes
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for PacketMirrorings.
       #
@@ -1377,6 +2829,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the PacketMirrorings service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.packet_mirrorings_available?}.
+      #
       # ## About PacketMirrorings
       #
       # The PacketMirrorings API.
@@ -1396,6 +2853,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the PacketMirrorings service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.packet_mirrorings}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the PacketMirrorings service,
+      # or if the versioned client gem needs an update to support the PacketMirrorings service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.packet_mirrorings_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :PacketMirrorings
+        service_module = service_module.const_get :PacketMirrorings
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for Projects.
       #
@@ -1407,6 +2892,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the Projects service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.projects_available?}.
+      #
       # ## About Projects
       #
       # The Projects API.
@@ -1426,6 +2916,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the Projects service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.projects}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the Projects service,
+      # or if the versioned client gem needs an update to support the Projects service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.projects_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :Projects
+        service_module = service_module.const_get :Projects
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for PublicAdvertisedPrefixes.
       #
@@ -1437,6 +2955,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the PublicAdvertisedPrefixes service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.public_advertised_prefixes_available?}.
+      #
       # ## About PublicAdvertisedPrefixes
       #
       # The PublicAdvertisedPrefixes API.
@@ -1456,6 +2979,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the PublicAdvertisedPrefixes service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.public_advertised_prefixes}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the PublicAdvertisedPrefixes service,
+      # or if the versioned client gem needs an update to support the PublicAdvertisedPrefixes service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.public_advertised_prefixes_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :PublicAdvertisedPrefixes
+        service_module = service_module.const_get :PublicAdvertisedPrefixes
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for PublicDelegatedPrefixes.
       #
@@ -1467,6 +3018,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the PublicDelegatedPrefixes service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.public_delegated_prefixes_available?}.
+      #
       # ## About PublicDelegatedPrefixes
       #
       # The PublicDelegatedPrefixes API.
@@ -1486,6 +3042,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the PublicDelegatedPrefixes service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.public_delegated_prefixes}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the PublicDelegatedPrefixes service,
+      # or if the versioned client gem needs an update to support the PublicDelegatedPrefixes service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.public_delegated_prefixes_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :PublicDelegatedPrefixes
+        service_module = service_module.const_get :PublicDelegatedPrefixes
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionAutoscalers.
       #
@@ -1497,6 +3081,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionAutoscalers service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_autoscalers_available?}.
+      #
       # ## About RegionAutoscalers
       #
       # The RegionAutoscalers API.
@@ -1516,6 +3105,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionAutoscalers service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_autoscalers}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionAutoscalers service,
+      # or if the versioned client gem needs an update to support the RegionAutoscalers service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_autoscalers_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionAutoscalers
+        service_module = service_module.const_get :RegionAutoscalers
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionBackendServices.
       #
@@ -1527,6 +3144,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionBackendServices service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_backend_services_available?}.
+      #
       # ## About RegionBackendServices
       #
       # The RegionBackendServices API.
@@ -1546,6 +3168,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionBackendServices service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_backend_services}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionBackendServices service,
+      # or if the versioned client gem needs an update to support the RegionBackendServices service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_backend_services_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionBackendServices
+        service_module = service_module.const_get :RegionBackendServices
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionCommitments.
       #
@@ -1557,6 +3207,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionCommitments service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_commitments_available?}.
+      #
       # ## About RegionCommitments
       #
       # The RegionCommitments API.
@@ -1576,6 +3231,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionCommitments service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_commitments}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionCommitments service,
+      # or if the versioned client gem needs an update to support the RegionCommitments service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_commitments_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionCommitments
+        service_module = service_module.const_get :RegionCommitments
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionDiskTypes.
       #
@@ -1587,6 +3270,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionDiskTypes service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_disk_types_available?}.
+      #
       # ## About RegionDiskTypes
       #
       # The RegionDiskTypes API.
@@ -1606,6 +3294,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionDiskTypes service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_disk_types}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionDiskTypes service,
+      # or if the versioned client gem needs an update to support the RegionDiskTypes service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_disk_types_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionDiskTypes
+        service_module = service_module.const_get :RegionDiskTypes
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionDisks.
       #
@@ -1617,6 +3333,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionDisks service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_disks_available?}.
+      #
       # ## About RegionDisks
       #
       # The RegionDisks API.
@@ -1636,6 +3357,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionDisks service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_disks}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionDisks service,
+      # or if the versioned client gem needs an update to support the RegionDisks service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_disks_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionDisks
+        service_module = service_module.const_get :RegionDisks
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionHealthCheckServices.
       #
@@ -1647,6 +3396,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionHealthCheckServices service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_health_check_services_available?}.
+      #
       # ## About RegionHealthCheckServices
       #
       # The RegionHealthCheckServices API.
@@ -1666,6 +3420,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionHealthCheckServices service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_health_check_services}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionHealthCheckServices service,
+      # or if the versioned client gem needs an update to support the RegionHealthCheckServices service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_health_check_services_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionHealthCheckServices
+        service_module = service_module.const_get :RegionHealthCheckServices
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionHealthChecks.
       #
@@ -1677,6 +3459,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionHealthChecks service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_health_checks_available?}.
+      #
       # ## About RegionHealthChecks
       #
       # The RegionHealthChecks API.
@@ -1696,6 +3483,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionHealthChecks service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_health_checks}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionHealthChecks service,
+      # or if the versioned client gem needs an update to support the RegionHealthChecks service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_health_checks_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionHealthChecks
+        service_module = service_module.const_get :RegionHealthChecks
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionInstanceGroupManagers.
       #
@@ -1707,6 +3522,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionInstanceGroupManagers service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_instance_group_managers_available?}.
+      #
       # ## About RegionInstanceGroupManagers
       #
       # The RegionInstanceGroupManagers API.
@@ -1726,6 +3546,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionInstanceGroupManagers service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_instance_group_managers}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionInstanceGroupManagers service,
+      # or if the versioned client gem needs an update to support the RegionInstanceGroupManagers service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_instance_group_managers_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionInstanceGroupManagers
+        service_module = service_module.const_get :RegionInstanceGroupManagers
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionInstanceGroups.
       #
@@ -1737,6 +3585,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionInstanceGroups service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_instance_groups_available?}.
+      #
       # ## About RegionInstanceGroups
       #
       # The RegionInstanceGroups API.
@@ -1756,6 +3609,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionInstanceGroups service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_instance_groups}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionInstanceGroups service,
+      # or if the versioned client gem needs an update to support the RegionInstanceGroups service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_instance_groups_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionInstanceGroups
+        service_module = service_module.const_get :RegionInstanceGroups
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionInstanceTemplates.
       #
@@ -1767,6 +3648,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionInstanceTemplates service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_instance_templates_available?}.
+      #
       # ## About RegionInstanceTemplates
       #
       # The RegionInstanceTemplates API.
@@ -1786,6 +3672,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionInstanceTemplates service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_instance_templates}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionInstanceTemplates service,
+      # or if the versioned client gem needs an update to support the RegionInstanceTemplates service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_instance_templates_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionInstanceTemplates
+        service_module = service_module.const_get :RegionInstanceTemplates
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionInstances.
       #
@@ -1797,6 +3711,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionInstances service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_instances_available?}.
+      #
       # ## About RegionInstances
       #
       # The RegionInstances API.
@@ -1816,6 +3735,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionInstances service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_instances}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionInstances service,
+      # or if the versioned client gem needs an update to support the RegionInstances service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_instances_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionInstances
+        service_module = service_module.const_get :RegionInstances
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionInstantSnapshots.
       #
@@ -1827,6 +3774,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionInstantSnapshots service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_instant_snapshots_available?}.
+      #
       # ## About RegionInstantSnapshots
       #
       # The RegionInstantSnapshots API.
@@ -1846,6 +3798,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionInstantSnapshots service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_instant_snapshots}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionInstantSnapshots service,
+      # or if the versioned client gem needs an update to support the RegionInstantSnapshots service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_instant_snapshots_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionInstantSnapshots
+        service_module = service_module.const_get :RegionInstantSnapshots
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionNetworkEndpointGroups.
       #
@@ -1857,23 +3837,56 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionNetworkEndpointGroups service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_network_endpoint_groups_available?}.
+      #
       # ## About RegionNetworkEndpointGroups
       #
       # The RegionNetworkEndpointGroups API.
       #
       # @param version [::String, ::Symbol] The API version to connect to. Optional.
       #   Defaults to `:v1`.
-      # @return [::Object] A client object for the specified version.
+      # @return [::Object] A client object for the specified version.
+      #
+      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
+        service_module = Google::Cloud::Compute.const_get(package_name).const_get(:RegionNetworkEndpointGroups)
+        service_module.const_get(:Rest).const_get(:Client).new(&block)
+      end
+
+      ##
+      # Determines whether the RegionNetworkEndpointGroups service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_network_endpoint_groups}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionNetworkEndpointGroups service,
+      # or if the versioned client gem needs an update to support the RegionNetworkEndpointGroups service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
       #
-      def self.region_network_endpoint_groups version: :v1, &block
+      def self.region_network_endpoint_groups_available? version: :v1
         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
-        service_module = Google::Cloud::Compute.const_get(package_name).const_get(:RegionNetworkEndpointGroups)
-        service_module.const_get(:Rest).const_get(:Client).new(&block)
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionNetworkEndpointGroups
+        service_module = service_module.const_get :RegionNetworkEndpointGroups
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
       end
 
       ##
@@ -1887,6 +3900,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionNetworkFirewallPolicies service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_network_firewall_policies_available?}.
+      #
       # ## About RegionNetworkFirewallPolicies
       #
       # The RegionNetworkFirewallPolicies API.
@@ -1906,6 +3924,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionNetworkFirewallPolicies service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_network_firewall_policies}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionNetworkFirewallPolicies service,
+      # or if the versioned client gem needs an update to support the RegionNetworkFirewallPolicies service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_network_firewall_policies_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionNetworkFirewallPolicies
+        service_module = service_module.const_get :RegionNetworkFirewallPolicies
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionNotificationEndpoints.
       #
@@ -1917,6 +3963,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionNotificationEndpoints service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_notification_endpoints_available?}.
+      #
       # ## About RegionNotificationEndpoints
       #
       # The RegionNotificationEndpoints API.
@@ -1936,6 +3987,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionNotificationEndpoints service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_notification_endpoints}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionNotificationEndpoints service,
+      # or if the versioned client gem needs an update to support the RegionNotificationEndpoints service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_notification_endpoints_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionNotificationEndpoints
+        service_module = service_module.const_get :RegionNotificationEndpoints
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionOperations.
       #
@@ -1947,6 +4026,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionOperations service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_operations_available?}.
+      #
       # ## About RegionOperations
       #
       # The RegionOperations API.
@@ -1966,6 +4050,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionOperations service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_operations}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionOperations service,
+      # or if the versioned client gem needs an update to support the RegionOperations service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_operations_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionOperations
+        service_module = service_module.const_get :RegionOperations
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionSecurityPolicies.
       #
@@ -1977,6 +4089,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionSecurityPolicies service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_security_policies_available?}.
+      #
       # ## About RegionSecurityPolicies
       #
       # The RegionSecurityPolicies API.
@@ -1996,6 +4113,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionSecurityPolicies service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_security_policies}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionSecurityPolicies service,
+      # or if the versioned client gem needs an update to support the RegionSecurityPolicies service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_security_policies_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionSecurityPolicies
+        service_module = service_module.const_get :RegionSecurityPolicies
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionSslCertificates.
       #
@@ -2007,6 +4152,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionSslCertificates service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_ssl_certificates_available?}.
+      #
       # ## About RegionSslCertificates
       #
       # The RegionSslCertificates API.
@@ -2026,6 +4176,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionSslCertificates service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_ssl_certificates}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionSslCertificates service,
+      # or if the versioned client gem needs an update to support the RegionSslCertificates service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_ssl_certificates_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionSslCertificates
+        service_module = service_module.const_get :RegionSslCertificates
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionSslPolicies.
       #
@@ -2037,6 +4215,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionSslPolicies service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_ssl_policies_available?}.
+      #
       # ## About RegionSslPolicies
       #
       # The RegionSslPolicies API.
@@ -2056,6 +4239,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionSslPolicies service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_ssl_policies}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionSslPolicies service,
+      # or if the versioned client gem needs an update to support the RegionSslPolicies service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_ssl_policies_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionSslPolicies
+        service_module = service_module.const_get :RegionSslPolicies
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionTargetHttpProxies.
       #
@@ -2067,6 +4278,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionTargetHttpProxies service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_target_http_proxies_available?}.
+      #
       # ## About RegionTargetHttpProxies
       #
       # The RegionTargetHttpProxies API.
@@ -2086,6 +4302,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionTargetHttpProxies service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_target_http_proxies}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionTargetHttpProxies service,
+      # or if the versioned client gem needs an update to support the RegionTargetHttpProxies service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_target_http_proxies_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionTargetHttpProxies
+        service_module = service_module.const_get :RegionTargetHttpProxies
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionTargetHttpsProxies.
       #
@@ -2097,6 +4341,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionTargetHttpsProxies service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_target_https_proxies_available?}.
+      #
       # ## About RegionTargetHttpsProxies
       #
       # The RegionTargetHttpsProxies API.
@@ -2116,6 +4365,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionTargetHttpsProxies service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_target_https_proxies}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionTargetHttpsProxies service,
+      # or if the versioned client gem needs an update to support the RegionTargetHttpsProxies service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_target_https_proxies_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionTargetHttpsProxies
+        service_module = service_module.const_get :RegionTargetHttpsProxies
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionTargetTcpProxies.
       #
@@ -2127,6 +4404,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionTargetTcpProxies service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_target_tcp_proxies_available?}.
+      #
       # ## About RegionTargetTcpProxies
       #
       # The RegionTargetTcpProxies API.
@@ -2146,6 +4428,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionTargetTcpProxies service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_target_tcp_proxies}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionTargetTcpProxies service,
+      # or if the versioned client gem needs an update to support the RegionTargetTcpProxies service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_target_tcp_proxies_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionTargetTcpProxies
+        service_module = service_module.const_get :RegionTargetTcpProxies
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionUrlMaps.
       #
@@ -2157,6 +4467,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionUrlMaps service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_url_maps_available?}.
+      #
       # ## About RegionUrlMaps
       #
       # The RegionUrlMaps API.
@@ -2176,6 +4491,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionUrlMaps service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_url_maps}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionUrlMaps service,
+      # or if the versioned client gem needs an update to support the RegionUrlMaps service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_url_maps_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionUrlMaps
+        service_module = service_module.const_get :RegionUrlMaps
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for RegionZones.
       #
@@ -2187,6 +4530,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the RegionZones service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.region_zones_available?}.
+      #
       # ## About RegionZones
       #
       # The RegionZones API.
@@ -2206,6 +4554,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the RegionZones service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.region_zones}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the RegionZones service,
+      # or if the versioned client gem needs an update to support the RegionZones service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.region_zones_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :RegionZones
+        service_module = service_module.const_get :RegionZones
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for Regions.
       #
@@ -2217,6 +4593,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the Regions service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.regions_available?}.
+      #
       # ## About Regions
       #
       # The Regions API.
@@ -2236,6 +4617,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the Regions service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.regions}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the Regions service,
+      # or if the versioned client gem needs an update to support the Regions service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.regions_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :Regions
+        service_module = service_module.const_get :Regions
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for Reservations.
       #
@@ -2247,6 +4656,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the Reservations service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.reservations_available?}.
+      #
       # ## About Reservations
       #
       # The Reservations API.
@@ -2266,6 +4680,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the Reservations service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.reservations}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the Reservations service,
+      # or if the versioned client gem needs an update to support the Reservations service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.reservations_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :Reservations
+        service_module = service_module.const_get :Reservations
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for ResourcePolicies.
       #
@@ -2277,6 +4719,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the ResourcePolicies service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.resource_policies_available?}.
+      #
       # ## About ResourcePolicies
       #
       # The ResourcePolicies API.
@@ -2296,6 +4743,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the ResourcePolicies service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.resource_policies}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the ResourcePolicies service,
+      # or if the versioned client gem needs an update to support the ResourcePolicies service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.resource_policies_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :ResourcePolicies
+        service_module = service_module.const_get :ResourcePolicies
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for Routers.
       #
@@ -2307,6 +4782,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the Routers service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.routers_available?}.
+      #
       # ## About Routers
       #
       # The Routers API.
@@ -2326,6 +4806,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the Routers service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.routers}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the Routers service,
+      # or if the versioned client gem needs an update to support the Routers service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.routers_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :Routers
+        service_module = service_module.const_get :Routers
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for Routes.
       #
@@ -2337,6 +4845,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the Routes service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.routes_available?}.
+      #
       # ## About Routes
       #
       # The Routes API.
@@ -2356,6 +4869,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the Routes service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.routes}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the Routes service,
+      # or if the versioned client gem needs an update to support the Routes service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.routes_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :Routes
+        service_module = service_module.const_get :Routes
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for SecurityPolicies.
       #
@@ -2367,6 +4908,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the SecurityPolicies service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.security_policies_available?}.
+      #
       # ## About SecurityPolicies
       #
       # The SecurityPolicies API.
@@ -2386,6 +4932,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the SecurityPolicies service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.security_policies}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the SecurityPolicies service,
+      # or if the versioned client gem needs an update to support the SecurityPolicies service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.security_policies_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :SecurityPolicies
+        service_module = service_module.const_get :SecurityPolicies
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for ServiceAttachments.
       #
@@ -2397,6 +4971,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the ServiceAttachments service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.service_attachments_available?}.
+      #
       # ## About ServiceAttachments
       #
       # The ServiceAttachments API.
@@ -2416,6 +4995,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the ServiceAttachments service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.service_attachments}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the ServiceAttachments service,
+      # or if the versioned client gem needs an update to support the ServiceAttachments service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.service_attachments_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :ServiceAttachments
+        service_module = service_module.const_get :ServiceAttachments
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for SnapshotSettingsService.
       #
@@ -2427,23 +5034,56 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the SnapshotSettingsService service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.snapshot_settings_service_available?}.
+      #
       # ## About SnapshotSettingsService
       #
       # The SnapshotSettings API.
       #
       # @param version [::String, ::Symbol] The API version to connect to. Optional.
       #   Defaults to `:v1`.
-      # @return [::Object] A client object for the specified version.
+      # @return [::Object] A client object for the specified version.
+      #
+      def self.snapshot_settings_service 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
+        service_module = Google::Cloud::Compute.const_get(package_name).const_get(:SnapshotSettingsService)
+        service_module.const_get(:Rest).const_get(:Client).new(&block)
+      end
+
+      ##
+      # Determines whether the SnapshotSettingsService service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.snapshot_settings_service}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the SnapshotSettingsService service,
+      # or if the versioned client gem needs an update to support the SnapshotSettingsService service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
       #
-      def self.snapshot_settings_service version: :v1, &block
+      def self.snapshot_settings_service_available? version: :v1
         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
-        service_module = Google::Cloud::Compute.const_get(package_name).const_get(:SnapshotSettingsService)
-        service_module.const_get(:Rest).const_get(:Client).new(&block)
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :SnapshotSettingsService
+        service_module = service_module.const_get :SnapshotSettingsService
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
       end
 
       ##
@@ -2457,6 +5097,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the Snapshots service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.snapshots_available?}.
+      #
       # ## About Snapshots
       #
       # The Snapshots API.
@@ -2476,6 +5121,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the Snapshots service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.snapshots}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the Snapshots service,
+      # or if the versioned client gem needs an update to support the Snapshots service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.snapshots_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :Snapshots
+        service_module = service_module.const_get :Snapshots
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for SslCertificates.
       #
@@ -2487,6 +5160,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the SslCertificates service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.ssl_certificates_available?}.
+      #
       # ## About SslCertificates
       #
       # The SslCertificates API.
@@ -2506,6 +5184,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the SslCertificates service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.ssl_certificates}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the SslCertificates service,
+      # or if the versioned client gem needs an update to support the SslCertificates service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.ssl_certificates_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :SslCertificates
+        service_module = service_module.const_get :SslCertificates
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for SslPolicies.
       #
@@ -2517,6 +5223,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the SslPolicies service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.ssl_policies_available?}.
+      #
       # ## About SslPolicies
       #
       # The SslPolicies API.
@@ -2536,6 +5247,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the SslPolicies service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.ssl_policies}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the SslPolicies service,
+      # or if the versioned client gem needs an update to support the SslPolicies service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.ssl_policies_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :SslPolicies
+        service_module = service_module.const_get :SslPolicies
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for StoragePoolTypes.
       #
@@ -2547,6 +5286,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the StoragePoolTypes service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.storage_pool_types_available?}.
+      #
       # ## About StoragePoolTypes
       #
       # The StoragePoolTypes API.
@@ -2566,6 +5310,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the StoragePoolTypes service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.storage_pool_types}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the StoragePoolTypes service,
+      # or if the versioned client gem needs an update to support the StoragePoolTypes service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.storage_pool_types_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :StoragePoolTypes
+        service_module = service_module.const_get :StoragePoolTypes
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for StoragePools.
       #
@@ -2577,6 +5349,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the StoragePools service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.storage_pools_available?}.
+      #
       # ## About StoragePools
       #
       # The StoragePools API.
@@ -2596,6 +5373,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the StoragePools service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.storage_pools}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the StoragePools service,
+      # or if the versioned client gem needs an update to support the StoragePools service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.storage_pools_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :StoragePools
+        service_module = service_module.const_get :StoragePools
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for Subnetworks.
       #
@@ -2607,6 +5412,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the Subnetworks service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.subnetworks_available?}.
+      #
       # ## About Subnetworks
       #
       # The Subnetworks API.
@@ -2626,6 +5436,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the Subnetworks service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.subnetworks}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the Subnetworks service,
+      # or if the versioned client gem needs an update to support the Subnetworks service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.subnetworks_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :Subnetworks
+        service_module = service_module.const_get :Subnetworks
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for TargetGrpcProxies.
       #
@@ -2637,6 +5475,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the TargetGrpcProxies service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.target_grpc_proxies_available?}.
+      #
       # ## About TargetGrpcProxies
       #
       # The TargetGrpcProxies API.
@@ -2656,6 +5499,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the TargetGrpcProxies service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.target_grpc_proxies}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the TargetGrpcProxies service,
+      # or if the versioned client gem needs an update to support the TargetGrpcProxies service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.target_grpc_proxies_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :TargetGrpcProxies
+        service_module = service_module.const_get :TargetGrpcProxies
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for TargetHttpProxies.
       #
@@ -2667,6 +5538,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the TargetHttpProxies service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.target_http_proxies_available?}.
+      #
       # ## About TargetHttpProxies
       #
       # The TargetHttpProxies API.
@@ -2686,6 +5562,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the TargetHttpProxies service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.target_http_proxies}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the TargetHttpProxies service,
+      # or if the versioned client gem needs an update to support the TargetHttpProxies service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.target_http_proxies_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :TargetHttpProxies
+        service_module = service_module.const_get :TargetHttpProxies
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for TargetHttpsProxies.
       #
@@ -2697,6 +5601,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the TargetHttpsProxies service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.target_https_proxies_available?}.
+      #
       # ## About TargetHttpsProxies
       #
       # The TargetHttpsProxies API.
@@ -2716,6 +5625,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the TargetHttpsProxies service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.target_https_proxies}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the TargetHttpsProxies service,
+      # or if the versioned client gem needs an update to support the TargetHttpsProxies service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.target_https_proxies_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :TargetHttpsProxies
+        service_module = service_module.const_get :TargetHttpsProxies
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for TargetInstances.
       #
@@ -2727,6 +5664,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the TargetInstances service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.target_instances_available?}.
+      #
       # ## About TargetInstances
       #
       # The TargetInstances API.
@@ -2746,6 +5688,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the TargetInstances service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.target_instances}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the TargetInstances service,
+      # or if the versioned client gem needs an update to support the TargetInstances service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.target_instances_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :TargetInstances
+        service_module = service_module.const_get :TargetInstances
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for TargetPools.
       #
@@ -2757,6 +5727,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the TargetPools service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.target_pools_available?}.
+      #
       # ## About TargetPools
       #
       # The TargetPools API.
@@ -2776,6 +5751,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the TargetPools service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.target_pools}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the TargetPools service,
+      # or if the versioned client gem needs an update to support the TargetPools service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.target_pools_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :TargetPools
+        service_module = service_module.const_get :TargetPools
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for TargetSslProxies.
       #
@@ -2787,6 +5790,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the TargetSslProxies service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.target_ssl_proxies_available?}.
+      #
       # ## About TargetSslProxies
       #
       # The TargetSslProxies API.
@@ -2806,6 +5814,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the TargetSslProxies service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.target_ssl_proxies}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the TargetSslProxies service,
+      # or if the versioned client gem needs an update to support the TargetSslProxies service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.target_ssl_proxies_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :TargetSslProxies
+        service_module = service_module.const_get :TargetSslProxies
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for TargetTcpProxies.
       #
@@ -2817,6 +5853,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the TargetTcpProxies service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.target_tcp_proxies_available?}.
+      #
       # ## About TargetTcpProxies
       #
       # The TargetTcpProxies API.
@@ -2836,6 +5877,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the TargetTcpProxies service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.target_tcp_proxies}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the TargetTcpProxies service,
+      # or if the versioned client gem needs an update to support the TargetTcpProxies service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.target_tcp_proxies_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :TargetTcpProxies
+        service_module = service_module.const_get :TargetTcpProxies
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for TargetVpnGateways.
       #
@@ -2847,6 +5916,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the TargetVpnGateways service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.target_vpn_gateways_available?}.
+      #
       # ## About TargetVpnGateways
       #
       # The TargetVpnGateways API.
@@ -2866,6 +5940,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the TargetVpnGateways service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.target_vpn_gateways}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the TargetVpnGateways service,
+      # or if the versioned client gem needs an update to support the TargetVpnGateways service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.target_vpn_gateways_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :TargetVpnGateways
+        service_module = service_module.const_get :TargetVpnGateways
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for UrlMaps.
       #
@@ -2877,6 +5979,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the UrlMaps service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.url_maps_available?}.
+      #
       # ## About UrlMaps
       #
       # The UrlMaps API.
@@ -2896,6 +6003,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the UrlMaps service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.url_maps}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the UrlMaps service,
+      # or if the versioned client gem needs an update to support the UrlMaps service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.url_maps_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :UrlMaps
+        service_module = service_module.const_get :UrlMaps
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for VpnGateways.
       #
@@ -2907,6 +6042,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the VpnGateways service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.vpn_gateways_available?}.
+      #
       # ## About VpnGateways
       #
       # The VpnGateways API.
@@ -2926,6 +6066,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the VpnGateways service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.vpn_gateways}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the VpnGateways service,
+      # or if the versioned client gem needs an update to support the VpnGateways service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.vpn_gateways_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :VpnGateways
+        service_module = service_module.const_get :VpnGateways
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for VpnTunnels.
       #
@@ -2937,6 +6105,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the VpnTunnels service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.vpn_tunnels_available?}.
+      #
       # ## About VpnTunnels
       #
       # The VpnTunnels API.
@@ -2956,6 +6129,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the VpnTunnels service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.vpn_tunnels}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the VpnTunnels service,
+      # or if the versioned client gem needs an update to support the VpnTunnels service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.vpn_tunnels_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :VpnTunnels
+        service_module = service_module.const_get :VpnTunnels
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for ZoneOperations.
       #
@@ -2967,6 +6168,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the ZoneOperations service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.zone_operations_available?}.
+      #
       # ## About ZoneOperations
       #
       # The ZoneOperations API.
@@ -2986,6 +6192,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the ZoneOperations service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.zone_operations}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the ZoneOperations service,
+      # or if the versioned client gem needs an update to support the ZoneOperations service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.zone_operations_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :ZoneOperations
+        service_module = service_module.const_get :ZoneOperations
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Create a new client object for Zones.
       #
@@ -2997,6 +6231,11 @@ module Google
       # supported by that API version, and the corresponding gem is available, the
       # appropriate versioned client will be returned.
       #
+      # Raises an exception if the currently installed versioned client gem for the
+      # given API version does not support the Zones service.
+      # You can determine whether the method will succeed by calling
+      # {Google::Cloud::Compute.zones_available?}.
+      #
       # ## About Zones
       #
       # The Zones API.
@@ -3016,6 +6255,34 @@ module Google
         service_module.const_get(:Rest).const_get(:Client).new(&block)
       end
 
+      ##
+      # Determines whether the Zones service is supported by the current client.
+      # If true, you can retrieve a client object by calling {Google::Cloud::Compute.zones}.
+      # If false, that method will raise an exception. This could happen if the given
+      # API version does not exist or does not support the Zones service,
+      # or if the versioned client gem needs an update to support the Zones service.
+      #
+      # @param version [::String, ::Symbol] The API version to connect to. Optional.
+      #   Defaults to `:v1`.
+      # @return [boolean] Whether the service is available.
+      #
+      def self.zones_available? version: :v1
+        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
+        return false unless package_name
+        service_module = Google::Cloud::Compute.const_get package_name
+        return false unless service_module.const_defined? :Zones
+        service_module = service_module.const_get :Zones
+        return false unless service_module.const_defined? :Rest
+        service_module = service_module.const_get :Rest
+        service_module.const_defined? :Client
+      rescue ::LoadError
+        false
+      end
+
       ##
       # Configure the google-cloud-compute library.
       #