"""Generated client library for compute version beta."""
# NOTE: This file is autogenerated and should not be edited by hand.
from apitools.base.py import base_api
from googlecloudsdk.third_party.apis.compute.beta import compute_beta_messages as messages


class ComputeBeta(base_api.BaseApiClient):
  """Generated client library for service compute version beta."""

  MESSAGES_MODULE = messages
  BASE_URL = u'https://www.googleapis.com/compute/beta/'

  _PACKAGE = u'compute'
  _SCOPES = [u'https://www.googleapis.com/auth/cloud-platform', u'https://www.googleapis.com/auth/compute', u'https://www.googleapis.com/auth/compute.readonly', u'https://www.googleapis.com/auth/devstorage.full_control', u'https://www.googleapis.com/auth/devstorage.read_only', u'https://www.googleapis.com/auth/devstorage.read_write']
  _VERSION = u'beta'
  _CLIENT_ID = '1042881264118.apps.googleusercontent.com'
  _CLIENT_SECRET = 'x_Tw5K8nnjoRAqULM9PFAC2b'
  _USER_AGENT = 'x_Tw5K8nnjoRAqULM9PFAC2b'
  _CLIENT_CLASS_NAME = u'ComputeBeta'
  _URL_VERSION = u'beta'
  _API_KEY = None

  def __init__(self, url='', credentials=None,
               get_credentials=True, http=None, model=None,
               log_request=False, log_response=False,
               credentials_args=None, default_global_params=None,
               additional_http_headers=None):
    """Create a new compute handle."""
    url = url or self.BASE_URL
    super(ComputeBeta, self).__init__(
        url, credentials=credentials,
        get_credentials=get_credentials, http=http, model=model,
        log_request=log_request, log_response=log_response,
        credentials_args=credentials_args,
        default_global_params=default_global_params,
        additional_http_headers=additional_http_headers)
    self.acceleratorTypes = self.AcceleratorTypesService(self)
    self.addresses = self.AddressesService(self)
    self.autoscalers = self.AutoscalersService(self)
    self.backendBuckets = self.BackendBucketsService(self)
    self.backendServices = self.BackendServicesService(self)
    self.diskTypes = self.DiskTypesService(self)
    self.disks = self.DisksService(self)
    self.firewalls = self.FirewallsService(self)
    self.forwardingRules = self.ForwardingRulesService(self)
    self.globalAddresses = self.GlobalAddressesService(self)
    self.globalForwardingRules = self.GlobalForwardingRulesService(self)
    self.globalOperations = self.GlobalOperationsService(self)
    self.healthChecks = self.HealthChecksService(self)
    self.httpHealthChecks = self.HttpHealthChecksService(self)
    self.httpsHealthChecks = self.HttpsHealthChecksService(self)
    self.images = self.ImagesService(self)
    self.instanceGroupManagers = self.InstanceGroupManagersService(self)
    self.instanceGroups = self.InstanceGroupsService(self)
    self.instanceTemplates = self.InstanceTemplatesService(self)
    self.instances = self.InstancesService(self)
    self.licenses = self.LicensesService(self)
    self.machineTypes = self.MachineTypesService(self)
    self.networks = self.NetworksService(self)
    self.projects = self.ProjectsService(self)
    self.regionAutoscalers = self.RegionAutoscalersService(self)
    self.regionBackendServices = self.RegionBackendServicesService(self)
    self.regionInstanceGroupManagers = self.RegionInstanceGroupManagersService(self)
    self.regionInstanceGroups = self.RegionInstanceGroupsService(self)
    self.regionOperations = self.RegionOperationsService(self)
    self.regions = self.RegionsService(self)
    self.routers = self.RoutersService(self)
    self.routes = self.RoutesService(self)
    self.snapshots = self.SnapshotsService(self)
    self.sslCertificates = self.SslCertificatesService(self)
    self.subnetworks = self.SubnetworksService(self)
    self.targetHttpProxies = self.TargetHttpProxiesService(self)
    self.targetHttpsProxies = self.TargetHttpsProxiesService(self)
    self.targetInstances = self.TargetInstancesService(self)
    self.targetPools = self.TargetPoolsService(self)
    self.targetSslProxies = self.TargetSslProxiesService(self)
    self.targetTcpProxies = self.TargetTcpProxiesService(self)
    self.targetVpnGateways = self.TargetVpnGatewaysService(self)
    self.urlMaps = self.UrlMapsService(self)
    self.vpnTunnels = self.VpnTunnelsService(self)
    self.zoneOperations = self.ZoneOperationsService(self)
    self.zones = self.ZonesService(self)

  class AcceleratorTypesService(base_api.BaseApiService):
    """Service class for the acceleratorTypes resource."""

    _NAME = u'acceleratorTypes'

    def __init__(self, client):
      super(ComputeBeta.AcceleratorTypesService, self).__init__(client)
      self._upload_configs = {
          }

    def AggregatedList(self, request, global_params=None):
      """Retrieves an aggregated list of accelerator types.

      Args:
        request: (ComputeAcceleratorTypesAggregatedListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (AcceleratorTypeAggregatedList) The response message.
      """
      config = self.GetMethodConfig('AggregatedList')
      return self._RunMethod(
          config, request, global_params=global_params)

    AggregatedList.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.acceleratorTypes.aggregatedList',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/aggregated/acceleratorTypes',
        request_field='',
        request_type_name=u'ComputeAcceleratorTypesAggregatedListRequest',
        response_type_name=u'AcceleratorTypeAggregatedList',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified accelerator type. Get a list of available accelerator types by making a list() request.

      Args:
        request: (ComputeAcceleratorTypesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (AcceleratorType) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.acceleratorTypes.get',
        ordered_params=[u'project', u'zone', u'acceleratorType'],
        path_params=[u'acceleratorType', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/acceleratorTypes/{acceleratorType}',
        request_field='',
        request_type_name=u'ComputeAcceleratorTypesGetRequest',
        response_type_name=u'AcceleratorType',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves a list of accelerator types available to the specified project.

      Args:
        request: (ComputeAcceleratorTypesListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (AcceleratorTypeList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.acceleratorTypes.list',
        ordered_params=[u'project', u'zone'],
        path_params=[u'project', u'zone'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/zones/{zone}/acceleratorTypes',
        request_field='',
        request_type_name=u'ComputeAcceleratorTypesListRequest',
        response_type_name=u'AcceleratorTypeList',
        supports_download=False,
    )

  class AddressesService(base_api.BaseApiService):
    """Service class for the addresses resource."""

    _NAME = u'addresses'

    def __init__(self, client):
      super(ComputeBeta.AddressesService, self).__init__(client)
      self._upload_configs = {
          }

    def AggregatedList(self, request, global_params=None):
      """Retrieves an aggregated list of addresses.

      Args:
        request: (ComputeAddressesAggregatedListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (AddressAggregatedList) The response message.
      """
      config = self.GetMethodConfig('AggregatedList')
      return self._RunMethod(
          config, request, global_params=global_params)

    AggregatedList.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.addresses.aggregatedList',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/aggregated/addresses',
        request_field='',
        request_type_name=u'ComputeAddressesAggregatedListRequest',
        response_type_name=u'AddressAggregatedList',
        supports_download=False,
    )

    def Delete(self, request, global_params=None):
      """Deletes the specified address resource.

      Args:
        request: (ComputeAddressesDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.addresses.delete',
        ordered_params=[u'project', u'region', u'address'],
        path_params=[u'address', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/addresses/{address}',
        request_field='',
        request_type_name=u'ComputeAddressesDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified address resource.

      Args:
        request: (ComputeAddressesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Address) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.addresses.get',
        ordered_params=[u'project', u'region', u'address'],
        path_params=[u'address', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/addresses/{address}',
        request_field='',
        request_type_name=u'ComputeAddressesGetRequest',
        response_type_name=u'Address',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates an address resource in the specified project using the data included in the request.

      Args:
        request: (ComputeAddressesInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.addresses.insert',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/addresses',
        request_field=u'address',
        request_type_name=u'ComputeAddressesInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves a list of addresses contained within the specified region.

      Args:
        request: (ComputeAddressesListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (AddressList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.addresses.list',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/regions/{region}/addresses',
        request_field='',
        request_type_name=u'ComputeAddressesListRequest',
        response_type_name=u'AddressList',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeAddressesTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.addresses.testIamPermissions',
        ordered_params=[u'project', u'region', u'resource'],
        path_params=[u'project', u'region', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/addresses/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeAddressesTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

  class AutoscalersService(base_api.BaseApiService):
    """Service class for the autoscalers resource."""

    _NAME = u'autoscalers'

    def __init__(self, client):
      super(ComputeBeta.AutoscalersService, self).__init__(client)
      self._upload_configs = {
          }

    def AggregatedList(self, request, global_params=None):
      """Retrieves an aggregated list of autoscalers.

      Args:
        request: (ComputeAutoscalersAggregatedListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (AutoscalerAggregatedList) The response message.
      """
      config = self.GetMethodConfig('AggregatedList')
      return self._RunMethod(
          config, request, global_params=global_params)

    AggregatedList.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.autoscalers.aggregatedList',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/aggregated/autoscalers',
        request_field='',
        request_type_name=u'ComputeAutoscalersAggregatedListRequest',
        response_type_name=u'AutoscalerAggregatedList',
        supports_download=False,
    )

    def Delete(self, request, global_params=None):
      """Deletes the specified autoscaler.

      Args:
        request: (ComputeAutoscalersDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.autoscalers.delete',
        ordered_params=[u'project', u'zone', u'autoscaler'],
        path_params=[u'autoscaler', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/autoscalers/{autoscaler}',
        request_field='',
        request_type_name=u'ComputeAutoscalersDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified autoscaler resource. Get a list of available autoscalers by making a list() request.

      Args:
        request: (ComputeAutoscalersGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Autoscaler) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.autoscalers.get',
        ordered_params=[u'project', u'zone', u'autoscaler'],
        path_params=[u'autoscaler', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/autoscalers/{autoscaler}',
        request_field='',
        request_type_name=u'ComputeAutoscalersGetRequest',
        response_type_name=u'Autoscaler',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates an autoscaler in the specified project using the data included in the request.

      Args:
        request: (ComputeAutoscalersInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.autoscalers.insert',
        ordered_params=[u'project', u'zone'],
        path_params=[u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/autoscalers',
        request_field=u'autoscaler',
        request_type_name=u'ComputeAutoscalersInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves a list of autoscalers contained within the specified zone.

      Args:
        request: (ComputeAutoscalersListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (AutoscalerList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.autoscalers.list',
        ordered_params=[u'project', u'zone'],
        path_params=[u'project', u'zone'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/zones/{zone}/autoscalers',
        request_field='',
        request_type_name=u'ComputeAutoscalersListRequest',
        response_type_name=u'AutoscalerList',
        supports_download=False,
    )

    def Patch(self, request, global_params=None):
      """Updates an autoscaler in the specified project using the data included in the request. This method supports patch semantics.

      Args:
        request: (ComputeAutoscalersPatchRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Patch')
      return self._RunMethod(
          config, request, global_params=global_params)

    Patch.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PATCH',
        method_id=u'compute.autoscalers.patch',
        ordered_params=[u'project', u'zone', u'autoscaler'],
        path_params=[u'project', u'zone'],
        query_params=[u'autoscaler'],
        relative_path=u'projects/{project}/zones/{zone}/autoscalers',
        request_field=u'autoscalerResource',
        request_type_name=u'ComputeAutoscalersPatchRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeAutoscalersTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.autoscalers.testIamPermissions',
        ordered_params=[u'project', u'zone', u'resource'],
        path_params=[u'project', u'resource', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/autoscalers/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeAutoscalersTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

    def Update(self, request, global_params=None):
      """Updates an autoscaler in the specified project using the data included in the request.

      Args:
        request: (ComputeAutoscalersUpdateRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Update')
      return self._RunMethod(
          config, request, global_params=global_params)

    Update.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PUT',
        method_id=u'compute.autoscalers.update',
        ordered_params=[u'project', u'zone'],
        path_params=[u'project', u'zone'],
        query_params=[u'autoscaler'],
        relative_path=u'projects/{project}/zones/{zone}/autoscalers',
        request_field=u'autoscalerResource',
        request_type_name=u'ComputeAutoscalersUpdateRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

  class BackendBucketsService(base_api.BaseApiService):
    """Service class for the backendBuckets resource."""

    _NAME = u'backendBuckets'

    def __init__(self, client):
      super(ComputeBeta.BackendBucketsService, self).__init__(client)
      self._upload_configs = {
          }

    def Delete(self, request, global_params=None):
      """Deletes the specified BackendBucket resource.

      Args:
        request: (ComputeBackendBucketsDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.backendBuckets.delete',
        ordered_params=[u'project', u'backendBucket'],
        path_params=[u'backendBucket', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/backendBuckets/{backendBucket}',
        request_field='',
        request_type_name=u'ComputeBackendBucketsDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified BackendBucket resource. Get a list of available backend buckets by making a list() request.

      Args:
        request: (ComputeBackendBucketsGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (BackendBucket) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.backendBuckets.get',
        ordered_params=[u'project', u'backendBucket'],
        path_params=[u'backendBucket', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/backendBuckets/{backendBucket}',
        request_field='',
        request_type_name=u'ComputeBackendBucketsGetRequest',
        response_type_name=u'BackendBucket',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a BackendBucket resource in the specified project using the data included in the request.

      Args:
        request: (ComputeBackendBucketsInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.backendBuckets.insert',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/backendBuckets',
        request_field=u'backendBucket',
        request_type_name=u'ComputeBackendBucketsInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of BackendBucket resources available to the specified project.

      Args:
        request: (ComputeBackendBucketsListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (BackendBucketList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.backendBuckets.list',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/global/backendBuckets',
        request_field='',
        request_type_name=u'ComputeBackendBucketsListRequest',
        response_type_name=u'BackendBucketList',
        supports_download=False,
    )

    def Patch(self, request, global_params=None):
      """Updates the specified BackendBucket resource with the data included in the request. This method supports patch semantics.

      Args:
        request: (ComputeBackendBucketsPatchRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Patch')
      return self._RunMethod(
          config, request, global_params=global_params)

    Patch.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PATCH',
        method_id=u'compute.backendBuckets.patch',
        ordered_params=[u'project', u'backendBucket'],
        path_params=[u'backendBucket', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/backendBuckets/{backendBucket}',
        request_field=u'backendBucketResource',
        request_type_name=u'ComputeBackendBucketsPatchRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Update(self, request, global_params=None):
      """Updates the specified BackendBucket resource with the data included in the request.

      Args:
        request: (ComputeBackendBucketsUpdateRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Update')
      return self._RunMethod(
          config, request, global_params=global_params)

    Update.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PUT',
        method_id=u'compute.backendBuckets.update',
        ordered_params=[u'project', u'backendBucket'],
        path_params=[u'backendBucket', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/backendBuckets/{backendBucket}',
        request_field=u'backendBucketResource',
        request_type_name=u'ComputeBackendBucketsUpdateRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

  class BackendServicesService(base_api.BaseApiService):
    """Service class for the backendServices resource."""

    _NAME = u'backendServices'

    def __init__(self, client):
      super(ComputeBeta.BackendServicesService, self).__init__(client)
      self._upload_configs = {
          }

    def AggregatedList(self, request, global_params=None):
      """Retrieves the list of all BackendService resources, regional and global, available to the specified project.

      Args:
        request: (ComputeBackendServicesAggregatedListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (BackendServiceAggregatedList) The response message.
      """
      config = self.GetMethodConfig('AggregatedList')
      return self._RunMethod(
          config, request, global_params=global_params)

    AggregatedList.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.backendServices.aggregatedList',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/aggregated/backendServices',
        request_field='',
        request_type_name=u'ComputeBackendServicesAggregatedListRequest',
        response_type_name=u'BackendServiceAggregatedList',
        supports_download=False,
    )

    def Delete(self, request, global_params=None):
      """Deletes the specified BackendService resource.

      Args:
        request: (ComputeBackendServicesDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.backendServices.delete',
        ordered_params=[u'project', u'backendService'],
        path_params=[u'backendService', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/backendServices/{backendService}',
        request_field='',
        request_type_name=u'ComputeBackendServicesDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified BackendService resource. Get a list of available backend services by making a list() request.

      Args:
        request: (ComputeBackendServicesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (BackendService) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.backendServices.get',
        ordered_params=[u'project', u'backendService'],
        path_params=[u'backendService', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/backendServices/{backendService}',
        request_field='',
        request_type_name=u'ComputeBackendServicesGetRequest',
        response_type_name=u'BackendService',
        supports_download=False,
    )

    def GetHealth(self, request, global_params=None):
      """Gets the most recent health check results for this BackendService.

      Args:
        request: (ComputeBackendServicesGetHealthRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (BackendServiceGroupHealth) The response message.
      """
      config = self.GetMethodConfig('GetHealth')
      return self._RunMethod(
          config, request, global_params=global_params)

    GetHealth.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.backendServices.getHealth',
        ordered_params=[u'project', u'backendService'],
        path_params=[u'backendService', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/backendServices/{backendService}/getHealth',
        request_field=u'resourceGroupReference',
        request_type_name=u'ComputeBackendServicesGetHealthRequest',
        response_type_name=u'BackendServiceGroupHealth',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a BackendService resource in the specified project using the data included in the request. There are several restrictions and guidelines to keep in mind when creating a backend service. Read  Restrictions and Guidelines for more information.

      Args:
        request: (ComputeBackendServicesInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.backendServices.insert',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/backendServices',
        request_field=u'backendService',
        request_type_name=u'ComputeBackendServicesInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of BackendService resources available to the specified project.

      Args:
        request: (ComputeBackendServicesListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (BackendServiceList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.backendServices.list',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/global/backendServices',
        request_field='',
        request_type_name=u'ComputeBackendServicesListRequest',
        response_type_name=u'BackendServiceList',
        supports_download=False,
    )

    def Patch(self, request, global_params=None):
      """Updates the specified BackendService resource with the data included in the request. There are several restrictions and guidelines to keep in mind when updating a backend service. Read  Restrictions and Guidelines for more information. This method supports patch semantics.

      Args:
        request: (ComputeBackendServicesPatchRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Patch')
      return self._RunMethod(
          config, request, global_params=global_params)

    Patch.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PATCH',
        method_id=u'compute.backendServices.patch',
        ordered_params=[u'project', u'backendService'],
        path_params=[u'backendService', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/backendServices/{backendService}',
        request_field=u'backendServiceResource',
        request_type_name=u'ComputeBackendServicesPatchRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeBackendServicesTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.backendServices.testIamPermissions',
        ordered_params=[u'project', u'resource'],
        path_params=[u'project', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/global/backendServices/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeBackendServicesTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

    def Update(self, request, global_params=None):
      """Updates the specified BackendService resource with the data included in the request. There are several restrictions and guidelines to keep in mind when updating a backend service. Read  Restrictions and Guidelines for more information.

      Args:
        request: (ComputeBackendServicesUpdateRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Update')
      return self._RunMethod(
          config, request, global_params=global_params)

    Update.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PUT',
        method_id=u'compute.backendServices.update',
        ordered_params=[u'project', u'backendService'],
        path_params=[u'backendService', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/backendServices/{backendService}',
        request_field=u'backendServiceResource',
        request_type_name=u'ComputeBackendServicesUpdateRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

  class DiskTypesService(base_api.BaseApiService):
    """Service class for the diskTypes resource."""

    _NAME = u'diskTypes'

    def __init__(self, client):
      super(ComputeBeta.DiskTypesService, self).__init__(client)
      self._upload_configs = {
          }

    def AggregatedList(self, request, global_params=None):
      """Retrieves an aggregated list of disk types.

      Args:
        request: (ComputeDiskTypesAggregatedListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (DiskTypeAggregatedList) The response message.
      """
      config = self.GetMethodConfig('AggregatedList')
      return self._RunMethod(
          config, request, global_params=global_params)

    AggregatedList.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.diskTypes.aggregatedList',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/aggregated/diskTypes',
        request_field='',
        request_type_name=u'ComputeDiskTypesAggregatedListRequest',
        response_type_name=u'DiskTypeAggregatedList',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified disk type. Get a list of available disk types by making a list() request.

      Args:
        request: (ComputeDiskTypesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (DiskType) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.diskTypes.get',
        ordered_params=[u'project', u'zone', u'diskType'],
        path_params=[u'diskType', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/diskTypes/{diskType}',
        request_field='',
        request_type_name=u'ComputeDiskTypesGetRequest',
        response_type_name=u'DiskType',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves a list of disk types available to the specified project.

      Args:
        request: (ComputeDiskTypesListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (DiskTypeList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.diskTypes.list',
        ordered_params=[u'project', u'zone'],
        path_params=[u'project', u'zone'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/zones/{zone}/diskTypes',
        request_field='',
        request_type_name=u'ComputeDiskTypesListRequest',
        response_type_name=u'DiskTypeList',
        supports_download=False,
    )

  class DisksService(base_api.BaseApiService):
    """Service class for the disks resource."""

    _NAME = u'disks'

    def __init__(self, client):
      super(ComputeBeta.DisksService, self).__init__(client)
      self._upload_configs = {
          }

    def AggregatedList(self, request, global_params=None):
      """Retrieves an aggregated list of persistent disks.

      Args:
        request: (ComputeDisksAggregatedListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (DiskAggregatedList) The response message.
      """
      config = self.GetMethodConfig('AggregatedList')
      return self._RunMethod(
          config, request, global_params=global_params)

    AggregatedList.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.disks.aggregatedList',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/aggregated/disks',
        request_field='',
        request_type_name=u'ComputeDisksAggregatedListRequest',
        response_type_name=u'DiskAggregatedList',
        supports_download=False,
    )

    def CreateSnapshot(self, request, global_params=None):
      """Creates a snapshot of a specified persistent disk.

      Args:
        request: (ComputeDisksCreateSnapshotRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('CreateSnapshot')
      return self._RunMethod(
          config, request, global_params=global_params)

    CreateSnapshot.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.disks.createSnapshot',
        ordered_params=[u'project', u'zone', u'disk'],
        path_params=[u'disk', u'project', u'zone'],
        query_params=[u'guestFlush'],
        relative_path=u'projects/{project}/zones/{zone}/disks/{disk}/createSnapshot',
        request_field=u'snapshot',
        request_type_name=u'ComputeDisksCreateSnapshotRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Delete(self, request, global_params=None):
      """Deletes the specified persistent disk. Deleting a disk removes its data permanently and is irreversible. However, deleting a disk does not delete any snapshots previously made from the disk. You must separately delete snapshots.

      Args:
        request: (ComputeDisksDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.disks.delete',
        ordered_params=[u'project', u'zone', u'disk'],
        path_params=[u'disk', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/disks/{disk}',
        request_field='',
        request_type_name=u'ComputeDisksDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns a specified persistent disk. Get a list of available persistent disks by making a list() request.

      Args:
        request: (ComputeDisksGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Disk) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.disks.get',
        ordered_params=[u'project', u'zone', u'disk'],
        path_params=[u'disk', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/disks/{disk}',
        request_field='',
        request_type_name=u'ComputeDisksGetRequest',
        response_type_name=u'Disk',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a persistent disk in the specified project using the data in the request. You can create a disk with a sourceImage, a sourceSnapshot, or create an empty 500 GB data disk by omitting all properties. You can also create a disk that is larger than the default size by specifying the sizeGb property.

      Args:
        request: (ComputeDisksInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.disks.insert',
        ordered_params=[u'project', u'zone'],
        path_params=[u'project', u'zone'],
        query_params=[u'sourceImage'],
        relative_path=u'projects/{project}/zones/{zone}/disks',
        request_field=u'disk',
        request_type_name=u'ComputeDisksInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves a list of persistent disks contained within the specified zone.

      Args:
        request: (ComputeDisksListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (DiskList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.disks.list',
        ordered_params=[u'project', u'zone'],
        path_params=[u'project', u'zone'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/zones/{zone}/disks',
        request_field='',
        request_type_name=u'ComputeDisksListRequest',
        response_type_name=u'DiskList',
        supports_download=False,
    )

    def Resize(self, request, global_params=None):
      """Resizes the specified persistent disk.

      Args:
        request: (ComputeDisksResizeRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Resize')
      return self._RunMethod(
          config, request, global_params=global_params)

    Resize.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.disks.resize',
        ordered_params=[u'project', u'zone', u'disk'],
        path_params=[u'disk', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/disks/{disk}/resize',
        request_field=u'disksResizeRequest',
        request_type_name=u'ComputeDisksResizeRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetLabels(self, request, global_params=None):
      """Sets the labels on a disk. To learn more about labels, read the Labeling or Tagging Resources documentation.

      Args:
        request: (ComputeDisksSetLabelsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetLabels')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetLabels.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.disks.setLabels',
        ordered_params=[u'project', u'zone', u'resource'],
        path_params=[u'project', u'resource', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/disks/{resource}/setLabels',
        request_field=u'zoneSetLabelsRequest',
        request_type_name=u'ComputeDisksSetLabelsRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeDisksTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.disks.testIamPermissions',
        ordered_params=[u'project', u'zone', u'resource'],
        path_params=[u'project', u'resource', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/disks/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeDisksTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

  class FirewallsService(base_api.BaseApiService):
    """Service class for the firewalls resource."""

    _NAME = u'firewalls'

    def __init__(self, client):
      super(ComputeBeta.FirewallsService, self).__init__(client)
      self._upload_configs = {
          }

    def Delete(self, request, global_params=None):
      """Deletes the specified firewall.

      Args:
        request: (ComputeFirewallsDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.firewalls.delete',
        ordered_params=[u'project', u'firewall'],
        path_params=[u'firewall', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/firewalls/{firewall}',
        request_field='',
        request_type_name=u'ComputeFirewallsDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified firewall.

      Args:
        request: (ComputeFirewallsGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Firewall) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.firewalls.get',
        ordered_params=[u'project', u'firewall'],
        path_params=[u'firewall', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/firewalls/{firewall}',
        request_field='',
        request_type_name=u'ComputeFirewallsGetRequest',
        response_type_name=u'Firewall',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a firewall rule in the specified project using the data included in the request.

      Args:
        request: (ComputeFirewallsInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.firewalls.insert',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/firewalls',
        request_field=u'firewall',
        request_type_name=u'ComputeFirewallsInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of firewall rules available to the specified project.

      Args:
        request: (ComputeFirewallsListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (FirewallList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.firewalls.list',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/global/firewalls',
        request_field='',
        request_type_name=u'ComputeFirewallsListRequest',
        response_type_name=u'FirewallList',
        supports_download=False,
    )

    def Patch(self, request, global_params=None):
      """Updates the specified firewall rule with the data included in the request. This method supports patch semantics.

      Args:
        request: (ComputeFirewallsPatchRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Patch')
      return self._RunMethod(
          config, request, global_params=global_params)

    Patch.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PATCH',
        method_id=u'compute.firewalls.patch',
        ordered_params=[u'project', u'firewall'],
        path_params=[u'firewall', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/firewalls/{firewall}',
        request_field=u'firewallResource',
        request_type_name=u'ComputeFirewallsPatchRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeFirewallsTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.firewalls.testIamPermissions',
        ordered_params=[u'project', u'resource'],
        path_params=[u'project', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/global/firewalls/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeFirewallsTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

    def Update(self, request, global_params=None):
      """Updates the specified firewall rule with the data included in the request.

      Args:
        request: (ComputeFirewallsUpdateRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Update')
      return self._RunMethod(
          config, request, global_params=global_params)

    Update.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PUT',
        method_id=u'compute.firewalls.update',
        ordered_params=[u'project', u'firewall'],
        path_params=[u'firewall', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/firewalls/{firewall}',
        request_field=u'firewallResource',
        request_type_name=u'ComputeFirewallsUpdateRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

  class ForwardingRulesService(base_api.BaseApiService):
    """Service class for the forwardingRules resource."""

    _NAME = u'forwardingRules'

    def __init__(self, client):
      super(ComputeBeta.ForwardingRulesService, self).__init__(client)
      self._upload_configs = {
          }

    def AggregatedList(self, request, global_params=None):
      """Retrieves an aggregated list of forwarding rules.

      Args:
        request: (ComputeForwardingRulesAggregatedListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (ForwardingRuleAggregatedList) The response message.
      """
      config = self.GetMethodConfig('AggregatedList')
      return self._RunMethod(
          config, request, global_params=global_params)

    AggregatedList.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.forwardingRules.aggregatedList',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/aggregated/forwardingRules',
        request_field='',
        request_type_name=u'ComputeForwardingRulesAggregatedListRequest',
        response_type_name=u'ForwardingRuleAggregatedList',
        supports_download=False,
    )

    def Delete(self, request, global_params=None):
      """Deletes the specified ForwardingRule resource.

      Args:
        request: (ComputeForwardingRulesDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.forwardingRules.delete',
        ordered_params=[u'project', u'region', u'forwardingRule'],
        path_params=[u'forwardingRule', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/forwardingRules/{forwardingRule}',
        request_field='',
        request_type_name=u'ComputeForwardingRulesDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified ForwardingRule resource.

      Args:
        request: (ComputeForwardingRulesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (ForwardingRule) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.forwardingRules.get',
        ordered_params=[u'project', u'region', u'forwardingRule'],
        path_params=[u'forwardingRule', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/forwardingRules/{forwardingRule}',
        request_field='',
        request_type_name=u'ComputeForwardingRulesGetRequest',
        response_type_name=u'ForwardingRule',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a ForwardingRule resource in the specified project and region using the data included in the request.

      Args:
        request: (ComputeForwardingRulesInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.forwardingRules.insert',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/forwardingRules',
        request_field=u'forwardingRule',
        request_type_name=u'ComputeForwardingRulesInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves a list of ForwardingRule resources available to the specified project and region.

      Args:
        request: (ComputeForwardingRulesListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (ForwardingRuleList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.forwardingRules.list',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/regions/{region}/forwardingRules',
        request_field='',
        request_type_name=u'ComputeForwardingRulesListRequest',
        response_type_name=u'ForwardingRuleList',
        supports_download=False,
    )

    def SetTarget(self, request, global_params=None):
      """Changes target URL for forwarding rule. The new target should be of the same type as the old target.

      Args:
        request: (ComputeForwardingRulesSetTargetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetTarget')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetTarget.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.forwardingRules.setTarget',
        ordered_params=[u'project', u'region', u'forwardingRule'],
        path_params=[u'forwardingRule', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/forwardingRules/{forwardingRule}/setTarget',
        request_field=u'targetReference',
        request_type_name=u'ComputeForwardingRulesSetTargetRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeForwardingRulesTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.forwardingRules.testIamPermissions',
        ordered_params=[u'project', u'region', u'resource'],
        path_params=[u'project', u'region', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/forwardingRules/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeForwardingRulesTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

  class GlobalAddressesService(base_api.BaseApiService):
    """Service class for the globalAddresses resource."""

    _NAME = u'globalAddresses'

    def __init__(self, client):
      super(ComputeBeta.GlobalAddressesService, self).__init__(client)
      self._upload_configs = {
          }

    def Delete(self, request, global_params=None):
      """Deletes the specified address resource.

      Args:
        request: (ComputeGlobalAddressesDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.globalAddresses.delete',
        ordered_params=[u'project', u'address'],
        path_params=[u'address', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/addresses/{address}',
        request_field='',
        request_type_name=u'ComputeGlobalAddressesDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified address resource. Get a list of available addresses by making a list() request.

      Args:
        request: (ComputeGlobalAddressesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Address) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.globalAddresses.get',
        ordered_params=[u'project', u'address'],
        path_params=[u'address', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/addresses/{address}',
        request_field='',
        request_type_name=u'ComputeGlobalAddressesGetRequest',
        response_type_name=u'Address',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates an address resource in the specified project using the data included in the request.

      Args:
        request: (ComputeGlobalAddressesInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.globalAddresses.insert',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/addresses',
        request_field=u'address',
        request_type_name=u'ComputeGlobalAddressesInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves a list of global addresses.

      Args:
        request: (ComputeGlobalAddressesListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (AddressList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.globalAddresses.list',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/global/addresses',
        request_field='',
        request_type_name=u'ComputeGlobalAddressesListRequest',
        response_type_name=u'AddressList',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeGlobalAddressesTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.globalAddresses.testIamPermissions',
        ordered_params=[u'project', u'resource'],
        path_params=[u'project', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/global/addresses/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeGlobalAddressesTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

  class GlobalForwardingRulesService(base_api.BaseApiService):
    """Service class for the globalForwardingRules resource."""

    _NAME = u'globalForwardingRules'

    def __init__(self, client):
      super(ComputeBeta.GlobalForwardingRulesService, self).__init__(client)
      self._upload_configs = {
          }

    def Delete(self, request, global_params=None):
      """Deletes the specified ForwardingRule resource.

      Args:
        request: (ComputeGlobalForwardingRulesDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.globalForwardingRules.delete',
        ordered_params=[u'project', u'forwardingRule'],
        path_params=[u'forwardingRule', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/forwardingRules/{forwardingRule}',
        request_field='',
        request_type_name=u'ComputeGlobalForwardingRulesDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified ForwardingRule resource. Get a list of available forwarding rules by making a list() request.

      Args:
        request: (ComputeGlobalForwardingRulesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (ForwardingRule) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.globalForwardingRules.get',
        ordered_params=[u'project', u'forwardingRule'],
        path_params=[u'forwardingRule', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/forwardingRules/{forwardingRule}',
        request_field='',
        request_type_name=u'ComputeGlobalForwardingRulesGetRequest',
        response_type_name=u'ForwardingRule',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a ForwardingRule resource in the specified project and region using the data included in the request.

      Args:
        request: (ComputeGlobalForwardingRulesInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.globalForwardingRules.insert',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/forwardingRules',
        request_field=u'forwardingRule',
        request_type_name=u'ComputeGlobalForwardingRulesInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves a list of ForwardingRule resources available to the specified project.

      Args:
        request: (ComputeGlobalForwardingRulesListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (ForwardingRuleList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.globalForwardingRules.list',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/global/forwardingRules',
        request_field='',
        request_type_name=u'ComputeGlobalForwardingRulesListRequest',
        response_type_name=u'ForwardingRuleList',
        supports_download=False,
    )

    def SetTarget(self, request, global_params=None):
      """Changes target URL for forwarding rule. The new target should be of the same type as the old target.

      Args:
        request: (ComputeGlobalForwardingRulesSetTargetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetTarget')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetTarget.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.globalForwardingRules.setTarget',
        ordered_params=[u'project', u'forwardingRule'],
        path_params=[u'forwardingRule', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/forwardingRules/{forwardingRule}/setTarget',
        request_field=u'targetReference',
        request_type_name=u'ComputeGlobalForwardingRulesSetTargetRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeGlobalForwardingRulesTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.globalForwardingRules.testIamPermissions',
        ordered_params=[u'project', u'resource'],
        path_params=[u'project', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/global/forwardingRules/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeGlobalForwardingRulesTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

  class GlobalOperationsService(base_api.BaseApiService):
    """Service class for the globalOperations resource."""

    _NAME = u'globalOperations'

    def __init__(self, client):
      super(ComputeBeta.GlobalOperationsService, self).__init__(client)
      self._upload_configs = {
          }

    def AggregatedList(self, request, global_params=None):
      """Retrieves an aggregated list of all operations.

      Args:
        request: (ComputeGlobalOperationsAggregatedListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (OperationAggregatedList) The response message.
      """
      config = self.GetMethodConfig('AggregatedList')
      return self._RunMethod(
          config, request, global_params=global_params)

    AggregatedList.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.globalOperations.aggregatedList',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/aggregated/operations',
        request_field='',
        request_type_name=u'ComputeGlobalOperationsAggregatedListRequest',
        response_type_name=u'OperationAggregatedList',
        supports_download=False,
    )

    def Delete(self, request, global_params=None):
      """Deletes the specified Operations resource.

      Args:
        request: (ComputeGlobalOperationsDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (ComputeGlobalOperationsDeleteResponse) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.globalOperations.delete',
        ordered_params=[u'project', u'operation'],
        path_params=[u'operation', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/operations/{operation}',
        request_field='',
        request_type_name=u'ComputeGlobalOperationsDeleteRequest',
        response_type_name=u'ComputeGlobalOperationsDeleteResponse',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Retrieves the specified Operations resource. Get a list of operations by making a list() request.

      Args:
        request: (ComputeGlobalOperationsGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.globalOperations.get',
        ordered_params=[u'project', u'operation'],
        path_params=[u'operation', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/operations/{operation}',
        request_field='',
        request_type_name=u'ComputeGlobalOperationsGetRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves a list of Operation resources contained within the specified project.

      Args:
        request: (ComputeGlobalOperationsListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (OperationList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.globalOperations.list',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/global/operations',
        request_field='',
        request_type_name=u'ComputeGlobalOperationsListRequest',
        response_type_name=u'OperationList',
        supports_download=False,
    )

  class HealthChecksService(base_api.BaseApiService):
    """Service class for the healthChecks resource."""

    _NAME = u'healthChecks'

    def __init__(self, client):
      super(ComputeBeta.HealthChecksService, self).__init__(client)
      self._upload_configs = {
          }

    def Delete(self, request, global_params=None):
      """Deletes the specified HealthCheck resource.

      Args:
        request: (ComputeHealthChecksDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.healthChecks.delete',
        ordered_params=[u'project', u'healthCheck'],
        path_params=[u'healthCheck', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/healthChecks/{healthCheck}',
        request_field='',
        request_type_name=u'ComputeHealthChecksDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified HealthCheck resource. Get a list of available health checks by making a list() request.

      Args:
        request: (ComputeHealthChecksGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (HealthCheck) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.healthChecks.get',
        ordered_params=[u'project', u'healthCheck'],
        path_params=[u'healthCheck', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/healthChecks/{healthCheck}',
        request_field='',
        request_type_name=u'ComputeHealthChecksGetRequest',
        response_type_name=u'HealthCheck',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a HealthCheck resource in the specified project using the data included in the request.

      Args:
        request: (ComputeHealthChecksInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.healthChecks.insert',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/healthChecks',
        request_field=u'healthCheck',
        request_type_name=u'ComputeHealthChecksInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of HealthCheck resources available to the specified project.

      Args:
        request: (ComputeHealthChecksListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (HealthCheckList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.healthChecks.list',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/global/healthChecks',
        request_field='',
        request_type_name=u'ComputeHealthChecksListRequest',
        response_type_name=u'HealthCheckList',
        supports_download=False,
    )

    def Patch(self, request, global_params=None):
      """Updates a HealthCheck resource in the specified project using the data included in the request. This method supports patch semantics.

      Args:
        request: (ComputeHealthChecksPatchRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Patch')
      return self._RunMethod(
          config, request, global_params=global_params)

    Patch.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PATCH',
        method_id=u'compute.healthChecks.patch',
        ordered_params=[u'project', u'healthCheck'],
        path_params=[u'healthCheck', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/healthChecks/{healthCheck}',
        request_field=u'healthCheckResource',
        request_type_name=u'ComputeHealthChecksPatchRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeHealthChecksTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.healthChecks.testIamPermissions',
        ordered_params=[u'project', u'resource'],
        path_params=[u'project', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/global/healthChecks/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeHealthChecksTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

    def Update(self, request, global_params=None):
      """Updates a HealthCheck resource in the specified project using the data included in the request.

      Args:
        request: (ComputeHealthChecksUpdateRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Update')
      return self._RunMethod(
          config, request, global_params=global_params)

    Update.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PUT',
        method_id=u'compute.healthChecks.update',
        ordered_params=[u'project', u'healthCheck'],
        path_params=[u'healthCheck', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/healthChecks/{healthCheck}',
        request_field=u'healthCheckResource',
        request_type_name=u'ComputeHealthChecksUpdateRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

  class HttpHealthChecksService(base_api.BaseApiService):
    """Service class for the httpHealthChecks resource."""

    _NAME = u'httpHealthChecks'

    def __init__(self, client):
      super(ComputeBeta.HttpHealthChecksService, self).__init__(client)
      self._upload_configs = {
          }

    def Delete(self, request, global_params=None):
      """Deletes the specified HttpHealthCheck resource.

      Args:
        request: (ComputeHttpHealthChecksDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.httpHealthChecks.delete',
        ordered_params=[u'project', u'httpHealthCheck'],
        path_params=[u'httpHealthCheck', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/httpHealthChecks/{httpHealthCheck}',
        request_field='',
        request_type_name=u'ComputeHttpHealthChecksDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified HttpHealthCheck resource. Get a list of available HTTP health checks by making a list() request.

      Args:
        request: (ComputeHttpHealthChecksGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (HttpHealthCheck) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.httpHealthChecks.get',
        ordered_params=[u'project', u'httpHealthCheck'],
        path_params=[u'httpHealthCheck', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/httpHealthChecks/{httpHealthCheck}',
        request_field='',
        request_type_name=u'ComputeHttpHealthChecksGetRequest',
        response_type_name=u'HttpHealthCheck',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a HttpHealthCheck resource in the specified project using the data included in the request.

      Args:
        request: (ComputeHttpHealthChecksInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.httpHealthChecks.insert',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/httpHealthChecks',
        request_field=u'httpHealthCheck',
        request_type_name=u'ComputeHttpHealthChecksInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of HttpHealthCheck resources available to the specified project.

      Args:
        request: (ComputeHttpHealthChecksListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (HttpHealthCheckList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.httpHealthChecks.list',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/global/httpHealthChecks',
        request_field='',
        request_type_name=u'ComputeHttpHealthChecksListRequest',
        response_type_name=u'HttpHealthCheckList',
        supports_download=False,
    )

    def Patch(self, request, global_params=None):
      """Updates a HttpHealthCheck resource in the specified project using the data included in the request. This method supports patch semantics.

      Args:
        request: (ComputeHttpHealthChecksPatchRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Patch')
      return self._RunMethod(
          config, request, global_params=global_params)

    Patch.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PATCH',
        method_id=u'compute.httpHealthChecks.patch',
        ordered_params=[u'project', u'httpHealthCheck'],
        path_params=[u'httpHealthCheck', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/httpHealthChecks/{httpHealthCheck}',
        request_field=u'httpHealthCheckResource',
        request_type_name=u'ComputeHttpHealthChecksPatchRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeHttpHealthChecksTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.httpHealthChecks.testIamPermissions',
        ordered_params=[u'project', u'resource'],
        path_params=[u'project', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/global/httpHealthChecks/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeHttpHealthChecksTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

    def Update(self, request, global_params=None):
      """Updates a HttpHealthCheck resource in the specified project using the data included in the request.

      Args:
        request: (ComputeHttpHealthChecksUpdateRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Update')
      return self._RunMethod(
          config, request, global_params=global_params)

    Update.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PUT',
        method_id=u'compute.httpHealthChecks.update',
        ordered_params=[u'project', u'httpHealthCheck'],
        path_params=[u'httpHealthCheck', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/httpHealthChecks/{httpHealthCheck}',
        request_field=u'httpHealthCheckResource',
        request_type_name=u'ComputeHttpHealthChecksUpdateRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

  class HttpsHealthChecksService(base_api.BaseApiService):
    """Service class for the httpsHealthChecks resource."""

    _NAME = u'httpsHealthChecks'

    def __init__(self, client):
      super(ComputeBeta.HttpsHealthChecksService, self).__init__(client)
      self._upload_configs = {
          }

    def Delete(self, request, global_params=None):
      """Deletes the specified HttpsHealthCheck resource.

      Args:
        request: (ComputeHttpsHealthChecksDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.httpsHealthChecks.delete',
        ordered_params=[u'project', u'httpsHealthCheck'],
        path_params=[u'httpsHealthCheck', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/httpsHealthChecks/{httpsHealthCheck}',
        request_field='',
        request_type_name=u'ComputeHttpsHealthChecksDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified HttpsHealthCheck resource. Get a list of available HTTPS health checks by making a list() request.

      Args:
        request: (ComputeHttpsHealthChecksGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (HttpsHealthCheck) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.httpsHealthChecks.get',
        ordered_params=[u'project', u'httpsHealthCheck'],
        path_params=[u'httpsHealthCheck', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/httpsHealthChecks/{httpsHealthCheck}',
        request_field='',
        request_type_name=u'ComputeHttpsHealthChecksGetRequest',
        response_type_name=u'HttpsHealthCheck',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a HttpsHealthCheck resource in the specified project using the data included in the request.

      Args:
        request: (ComputeHttpsHealthChecksInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.httpsHealthChecks.insert',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/httpsHealthChecks',
        request_field=u'httpsHealthCheck',
        request_type_name=u'ComputeHttpsHealthChecksInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of HttpsHealthCheck resources available to the specified project.

      Args:
        request: (ComputeHttpsHealthChecksListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (HttpsHealthCheckList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.httpsHealthChecks.list',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/global/httpsHealthChecks',
        request_field='',
        request_type_name=u'ComputeHttpsHealthChecksListRequest',
        response_type_name=u'HttpsHealthCheckList',
        supports_download=False,
    )

    def Patch(self, request, global_params=None):
      """Updates a HttpsHealthCheck resource in the specified project using the data included in the request. This method supports patch semantics.

      Args:
        request: (ComputeHttpsHealthChecksPatchRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Patch')
      return self._RunMethod(
          config, request, global_params=global_params)

    Patch.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PATCH',
        method_id=u'compute.httpsHealthChecks.patch',
        ordered_params=[u'project', u'httpsHealthCheck'],
        path_params=[u'httpsHealthCheck', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/httpsHealthChecks/{httpsHealthCheck}',
        request_field=u'httpsHealthCheckResource',
        request_type_name=u'ComputeHttpsHealthChecksPatchRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeHttpsHealthChecksTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.httpsHealthChecks.testIamPermissions',
        ordered_params=[u'project', u'resource'],
        path_params=[u'project', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/global/httpsHealthChecks/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeHttpsHealthChecksTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

    def Update(self, request, global_params=None):
      """Updates a HttpsHealthCheck resource in the specified project using the data included in the request.

      Args:
        request: (ComputeHttpsHealthChecksUpdateRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Update')
      return self._RunMethod(
          config, request, global_params=global_params)

    Update.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PUT',
        method_id=u'compute.httpsHealthChecks.update',
        ordered_params=[u'project', u'httpsHealthCheck'],
        path_params=[u'httpsHealthCheck', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/httpsHealthChecks/{httpsHealthCheck}',
        request_field=u'httpsHealthCheckResource',
        request_type_name=u'ComputeHttpsHealthChecksUpdateRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

  class ImagesService(base_api.BaseApiService):
    """Service class for the images resource."""

    _NAME = u'images'

    def __init__(self, client):
      super(ComputeBeta.ImagesService, self).__init__(client)
      self._upload_configs = {
          }

    def Delete(self, request, global_params=None):
      """Deletes the specified image.

      Args:
        request: (ComputeImagesDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.images.delete',
        ordered_params=[u'project', u'image'],
        path_params=[u'image', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/images/{image}',
        request_field='',
        request_type_name=u'ComputeImagesDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Deprecate(self, request, global_params=None):
      """Sets the deprecation status of an image.

If an empty request body is given, clears the deprecation status instead.

      Args:
        request: (ComputeImagesDeprecateRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Deprecate')
      return self._RunMethod(
          config, request, global_params=global_params)

    Deprecate.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.images.deprecate',
        ordered_params=[u'project', u'image'],
        path_params=[u'image', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/images/{image}/deprecate',
        request_field=u'deprecationStatus',
        request_type_name=u'ComputeImagesDeprecateRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified image. Get a list of available images by making a list() request.

      Args:
        request: (ComputeImagesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Image) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.images.get',
        ordered_params=[u'project', u'image'],
        path_params=[u'image', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/images/{image}',
        request_field='',
        request_type_name=u'ComputeImagesGetRequest',
        response_type_name=u'Image',
        supports_download=False,
    )

    def GetFromFamily(self, request, global_params=None):
      """Returns the latest image that is part of an image family and is not deprecated.

      Args:
        request: (ComputeImagesGetFromFamilyRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Image) The response message.
      """
      config = self.GetMethodConfig('GetFromFamily')
      return self._RunMethod(
          config, request, global_params=global_params)

    GetFromFamily.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.images.getFromFamily',
        ordered_params=[u'project', u'family'],
        path_params=[u'family', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/images/family/{family}',
        request_field='',
        request_type_name=u'ComputeImagesGetFromFamilyRequest',
        response_type_name=u'Image',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates an image in the specified project using the data included in the request.

      Args:
        request: (ComputeImagesInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.images.insert',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/images',
        request_field=u'image',
        request_type_name=u'ComputeImagesInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of private images available to the specified project. Private images are images you create that belong to your project. This method does not get any images that belong to other projects, including publicly-available images, like Debian 8. If you want to get a list of publicly-available images, use this method to make a request to the respective image project, such as debian-cloud or windows-cloud.

      Args:
        request: (ComputeImagesListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (ImageList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.images.list',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/global/images',
        request_field='',
        request_type_name=u'ComputeImagesListRequest',
        response_type_name=u'ImageList',
        supports_download=False,
    )

    def SetLabels(self, request, global_params=None):
      """Sets the labels on an image. To learn more about labels, read the Labeling or Tagging Resources documentation.

      Args:
        request: (ComputeImagesSetLabelsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetLabels')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetLabels.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.images.setLabels',
        ordered_params=[u'project', u'resource'],
        path_params=[u'project', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/global/images/{resource}/setLabels',
        request_field=u'globalSetLabelsRequest',
        request_type_name=u'ComputeImagesSetLabelsRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeImagesTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.images.testIamPermissions',
        ordered_params=[u'project', u'resource'],
        path_params=[u'project', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/global/images/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeImagesTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

  class InstanceGroupManagersService(base_api.BaseApiService):
    """Service class for the instanceGroupManagers resource."""

    _NAME = u'instanceGroupManagers'

    def __init__(self, client):
      super(ComputeBeta.InstanceGroupManagersService, self).__init__(client)
      self._upload_configs = {
          }

    def AbandonInstances(self, request, global_params=None):
      """Schedules a group action to remove the specified instances from the managed instance group. Abandoning an instance does not delete the instance, but it does remove the instance from any target pools that are applied by the managed instance group. This method reduces the targetSize of the managed instance group by the number of instances that you abandon. This operation is marked as DONE when the action is scheduled even if the instances have not yet been removed from the group. You must separately verify the status of the abandoning action with the listmanagedinstances method.

      Args:
        request: (ComputeInstanceGroupManagersAbandonInstancesRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('AbandonInstances')
      return self._RunMethod(
          config, request, global_params=global_params)

    AbandonInstances.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instanceGroupManagers.abandonInstances',
        ordered_params=[u'project', u'zone', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/abandonInstances',
        request_field=u'instanceGroupManagersAbandonInstancesRequest',
        request_type_name=u'ComputeInstanceGroupManagersAbandonInstancesRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def AggregatedList(self, request, global_params=None):
      """Retrieves the list of managed instance groups and groups them by zone.

      Args:
        request: (ComputeInstanceGroupManagersAggregatedListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (InstanceGroupManagerAggregatedList) The response message.
      """
      config = self.GetMethodConfig('AggregatedList')
      return self._RunMethod(
          config, request, global_params=global_params)

    AggregatedList.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.instanceGroupManagers.aggregatedList',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/aggregated/instanceGroupManagers',
        request_field='',
        request_type_name=u'ComputeInstanceGroupManagersAggregatedListRequest',
        response_type_name=u'InstanceGroupManagerAggregatedList',
        supports_download=False,
    )

    def Delete(self, request, global_params=None):
      """Deletes the specified managed instance group and all of the instances in that group. Note that the instance group must not belong to a backend service. Read  Deleting an instance group for more information.

      Args:
        request: (ComputeInstanceGroupManagersDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.instanceGroupManagers.delete',
        ordered_params=[u'project', u'zone', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}',
        request_field='',
        request_type_name=u'ComputeInstanceGroupManagersDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def DeleteInstances(self, request, global_params=None):
      """Schedules a group action to delete the specified instances in the managed instance group. The instances are also removed from any target pools of which they were a member. This method reduces the targetSize of the managed instance group by the number of instances that you delete. This operation is marked as DONE when the action is scheduled even if the instances are still being deleted. You must separately verify the status of the deleting action with the listmanagedinstances method.

      Args:
        request: (ComputeInstanceGroupManagersDeleteInstancesRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('DeleteInstances')
      return self._RunMethod(
          config, request, global_params=global_params)

    DeleteInstances.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instanceGroupManagers.deleteInstances',
        ordered_params=[u'project', u'zone', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/deleteInstances',
        request_field=u'instanceGroupManagersDeleteInstancesRequest',
        request_type_name=u'ComputeInstanceGroupManagersDeleteInstancesRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns all of the details about the specified managed instance group. Get a list of available managed instance groups by making a list() request.

      Args:
        request: (ComputeInstanceGroupManagersGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (InstanceGroupManager) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.instanceGroupManagers.get',
        ordered_params=[u'project', u'zone', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}',
        request_field='',
        request_type_name=u'ComputeInstanceGroupManagersGetRequest',
        response_type_name=u'InstanceGroupManager',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a managed instance group using the information that you specify in the request. After the group is created, it schedules an action to create instances in the group using the specified instance template. This operation is marked as DONE when the group is created even if the instances in the group have not yet been created. You must separately verify the status of the individual instances with the listmanagedinstances method.

      Args:
        request: (ComputeInstanceGroupManagersInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instanceGroupManagers.insert',
        ordered_params=[u'project', u'zone'],
        path_params=[u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroupManagers',
        request_field=u'instanceGroupManager',
        request_type_name=u'ComputeInstanceGroupManagersInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves a list of managed instance groups that are contained within the specified project and zone.

      Args:
        request: (ComputeInstanceGroupManagersListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (InstanceGroupManagerList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.instanceGroupManagers.list',
        ordered_params=[u'project', u'zone'],
        path_params=[u'project', u'zone'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroupManagers',
        request_field='',
        request_type_name=u'ComputeInstanceGroupManagersListRequest',
        response_type_name=u'InstanceGroupManagerList',
        supports_download=False,
    )

    def ListManagedInstances(self, request, global_params=None):
      """Lists all of the instances in the managed instance group. Each instance in the list has a currentAction, which indicates the action that the managed instance group is performing on the instance. For example, if the group is still creating an instance, the currentAction is CREATING. If a previous action failed, the list displays the errors for that failed action.

      Args:
        request: (ComputeInstanceGroupManagersListManagedInstancesRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (InstanceGroupManagersListManagedInstancesResponse) The response message.
      """
      config = self.GetMethodConfig('ListManagedInstances')
      return self._RunMethod(
          config, request, global_params=global_params)

    ListManagedInstances.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instanceGroupManagers.listManagedInstances',
        ordered_params=[u'project', u'zone', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'zone'],
        query_params=[u'filter', u'maxResults', u'order_by', u'pageToken'],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/listManagedInstances',
        request_field='',
        request_type_name=u'ComputeInstanceGroupManagersListManagedInstancesRequest',
        response_type_name=u'InstanceGroupManagersListManagedInstancesResponse',
        supports_download=False,
    )

    def Patch(self, request, global_params=None):
      """Updates a managed instance group using the information that you specify in the request. This operation is marked as DONE when the group is updated even if the instances in the group have not yet been updated. You must separately verify the status of the individual instances with the listmanagedinstances method. This method supports patch semantics.

      Args:
        request: (ComputeInstanceGroupManagersPatchRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Patch')
      return self._RunMethod(
          config, request, global_params=global_params)

    Patch.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PATCH',
        method_id=u'compute.instanceGroupManagers.patch',
        ordered_params=[u'project', u'zone', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}',
        request_field=u'instanceGroupManagerResource',
        request_type_name=u'ComputeInstanceGroupManagersPatchRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def RecreateInstances(self, request, global_params=None):
      """Schedules a group action to recreate the specified instances in the managed instance group. The instances are deleted and recreated using the current instance template for the managed instance group. This operation is marked as DONE when the action is scheduled even if the instances have not yet been recreated. You must separately verify the status of the recreating action with the listmanagedinstances method.

      Args:
        request: (ComputeInstanceGroupManagersRecreateInstancesRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('RecreateInstances')
      return self._RunMethod(
          config, request, global_params=global_params)

    RecreateInstances.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instanceGroupManagers.recreateInstances',
        ordered_params=[u'project', u'zone', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/recreateInstances',
        request_field=u'instanceGroupManagersRecreateInstancesRequest',
        request_type_name=u'ComputeInstanceGroupManagersRecreateInstancesRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Resize(self, request, global_params=None):
      """Resizes the managed instance group. If you increase the size, the group creates new instances using the current instance template. If you decrease the size, the group deletes instances. The resize operation is marked DONE when the resize actions are scheduled even if the group has not yet added or deleted any instances. You must separately verify the status of the creating or deleting actions with the listmanagedinstances method.

      Args:
        request: (ComputeInstanceGroupManagersResizeRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Resize')
      return self._RunMethod(
          config, request, global_params=global_params)

    Resize.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instanceGroupManagers.resize',
        ordered_params=[u'project', u'zone', u'instanceGroupManager', u'size'],
        path_params=[u'instanceGroupManager', u'project', u'zone'],
        query_params=[u'size'],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/resize',
        request_field='',
        request_type_name=u'ComputeInstanceGroupManagersResizeRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def ResizeAdvanced(self, request, global_params=None):
      """Resizes the managed instance group with advanced configuration options like disabling creation retries. This is an extended version of the resize method.

If you increase the size of the instance group, the group creates new instances using the current instance template. If you decrease the size, the group deletes instances. The resize operation is marked DONE when the resize actions are scheduled even if the group has not yet added or deleted any instances. You must separately verify the status of the creating, creatingWithoutRetries, or deleting actions with the get or listmanagedinstances method.

      Args:
        request: (ComputeInstanceGroupManagersResizeAdvancedRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('ResizeAdvanced')
      return self._RunMethod(
          config, request, global_params=global_params)

    ResizeAdvanced.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instanceGroupManagers.resizeAdvanced',
        ordered_params=[u'project', u'zone', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/resizeAdvanced',
        request_field=u'instanceGroupManagersResizeAdvancedRequest',
        request_type_name=u'ComputeInstanceGroupManagersResizeAdvancedRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetAutoHealingPolicies(self, request, global_params=None):
      """Modifies the autohealing policies.

      Args:
        request: (ComputeInstanceGroupManagersSetAutoHealingPoliciesRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetAutoHealingPolicies')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetAutoHealingPolicies.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instanceGroupManagers.setAutoHealingPolicies',
        ordered_params=[u'project', u'zone', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/setAutoHealingPolicies',
        request_field=u'instanceGroupManagersSetAutoHealingRequest',
        request_type_name=u'ComputeInstanceGroupManagersSetAutoHealingPoliciesRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetInstanceTemplate(self, request, global_params=None):
      """Specifies the instance template to use when creating new instances in this group. The templates for existing instances in the group do not change unless you recreate them.

      Args:
        request: (ComputeInstanceGroupManagersSetInstanceTemplateRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetInstanceTemplate')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetInstanceTemplate.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instanceGroupManagers.setInstanceTemplate',
        ordered_params=[u'project', u'zone', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/setInstanceTemplate',
        request_field=u'instanceGroupManagersSetInstanceTemplateRequest',
        request_type_name=u'ComputeInstanceGroupManagersSetInstanceTemplateRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetTargetPools(self, request, global_params=None):
      """Modifies the target pools to which all instances in this managed instance group are assigned. The target pools automatically apply to all of the instances in the managed instance group. This operation is marked DONE when you make the request even if the instances have not yet been added to their target pools. The change might take some time to apply to all of the instances in the group depending on the size of the group.

      Args:
        request: (ComputeInstanceGroupManagersSetTargetPoolsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetTargetPools')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetTargetPools.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instanceGroupManagers.setTargetPools',
        ordered_params=[u'project', u'zone', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}/setTargetPools',
        request_field=u'instanceGroupManagersSetTargetPoolsRequest',
        request_type_name=u'ComputeInstanceGroupManagersSetTargetPoolsRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeInstanceGroupManagersTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instanceGroupManagers.testIamPermissions',
        ordered_params=[u'project', u'zone', u'resource'],
        path_params=[u'project', u'resource', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroupManagers/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeInstanceGroupManagersTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

    def Update(self, request, global_params=None):
      """Updates a managed instance group using the information that you specify in the request. This operation is marked as DONE when the group is updated even if the instances in the group have not yet been updated. You must separately verify the status of the individual instances with the listmanagedinstances method.

      Args:
        request: (ComputeInstanceGroupManagersUpdateRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Update')
      return self._RunMethod(
          config, request, global_params=global_params)

    Update.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PUT',
        method_id=u'compute.instanceGroupManagers.update',
        ordered_params=[u'project', u'zone', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroupManagers/{instanceGroupManager}',
        request_field=u'instanceGroupManagerResource',
        request_type_name=u'ComputeInstanceGroupManagersUpdateRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

  class InstanceGroupsService(base_api.BaseApiService):
    """Service class for the instanceGroups resource."""

    _NAME = u'instanceGroups'

    def __init__(self, client):
      super(ComputeBeta.InstanceGroupsService, self).__init__(client)
      self._upload_configs = {
          }

    def AddInstances(self, request, global_params=None):
      """Adds a list of instances to the specified instance group. All of the instances in the instance group must be in the same network/subnetwork. Read  Adding instances for more information.

      Args:
        request: (ComputeInstanceGroupsAddInstancesRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('AddInstances')
      return self._RunMethod(
          config, request, global_params=global_params)

    AddInstances.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instanceGroups.addInstances',
        ordered_params=[u'project', u'zone', u'instanceGroup'],
        path_params=[u'instanceGroup', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroups/{instanceGroup}/addInstances',
        request_field=u'instanceGroupsAddInstancesRequest',
        request_type_name=u'ComputeInstanceGroupsAddInstancesRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def AggregatedList(self, request, global_params=None):
      """Retrieves the list of instance groups and sorts them by zone.

      Args:
        request: (ComputeInstanceGroupsAggregatedListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (InstanceGroupAggregatedList) The response message.
      """
      config = self.GetMethodConfig('AggregatedList')
      return self._RunMethod(
          config, request, global_params=global_params)

    AggregatedList.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.instanceGroups.aggregatedList',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/aggregated/instanceGroups',
        request_field='',
        request_type_name=u'ComputeInstanceGroupsAggregatedListRequest',
        response_type_name=u'InstanceGroupAggregatedList',
        supports_download=False,
    )

    def Delete(self, request, global_params=None):
      """Deletes the specified instance group. The instances in the group are not deleted. Note that instance group must not belong to a backend service. Read  Deleting an instance group for more information.

      Args:
        request: (ComputeInstanceGroupsDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.instanceGroups.delete',
        ordered_params=[u'project', u'zone', u'instanceGroup'],
        path_params=[u'instanceGroup', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroups/{instanceGroup}',
        request_field='',
        request_type_name=u'ComputeInstanceGroupsDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified instance group. Get a list of available instance groups by making a list() request.

      Args:
        request: (ComputeInstanceGroupsGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (InstanceGroup) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.instanceGroups.get',
        ordered_params=[u'project', u'zone', u'instanceGroup'],
        path_params=[u'instanceGroup', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroups/{instanceGroup}',
        request_field='',
        request_type_name=u'ComputeInstanceGroupsGetRequest',
        response_type_name=u'InstanceGroup',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates an instance group in the specified project using the parameters that are included in the request.

      Args:
        request: (ComputeInstanceGroupsInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instanceGroups.insert',
        ordered_params=[u'project', u'zone'],
        path_params=[u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroups',
        request_field=u'instanceGroup',
        request_type_name=u'ComputeInstanceGroupsInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of instance groups that are located in the specified project and zone.

      Args:
        request: (ComputeInstanceGroupsListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (InstanceGroupList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.instanceGroups.list',
        ordered_params=[u'project', u'zone'],
        path_params=[u'project', u'zone'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroups',
        request_field='',
        request_type_name=u'ComputeInstanceGroupsListRequest',
        response_type_name=u'InstanceGroupList',
        supports_download=False,
    )

    def ListInstances(self, request, global_params=None):
      """Lists the instances in the specified instance group.

      Args:
        request: (ComputeInstanceGroupsListInstancesRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (InstanceGroupsListInstances) The response message.
      """
      config = self.GetMethodConfig('ListInstances')
      return self._RunMethod(
          config, request, global_params=global_params)

    ListInstances.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instanceGroups.listInstances',
        ordered_params=[u'project', u'zone', u'instanceGroup'],
        path_params=[u'instanceGroup', u'project', u'zone'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroups/{instanceGroup}/listInstances',
        request_field=u'instanceGroupsListInstancesRequest',
        request_type_name=u'ComputeInstanceGroupsListInstancesRequest',
        response_type_name=u'InstanceGroupsListInstances',
        supports_download=False,
    )

    def RemoveInstances(self, request, global_params=None):
      """Removes one or more instances from the specified instance group, but does not delete those instances.

      Args:
        request: (ComputeInstanceGroupsRemoveInstancesRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('RemoveInstances')
      return self._RunMethod(
          config, request, global_params=global_params)

    RemoveInstances.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instanceGroups.removeInstances',
        ordered_params=[u'project', u'zone', u'instanceGroup'],
        path_params=[u'instanceGroup', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroups/{instanceGroup}/removeInstances',
        request_field=u'instanceGroupsRemoveInstancesRequest',
        request_type_name=u'ComputeInstanceGroupsRemoveInstancesRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetNamedPorts(self, request, global_params=None):
      """Sets the named ports for the specified instance group.

      Args:
        request: (ComputeInstanceGroupsSetNamedPortsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetNamedPorts')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetNamedPorts.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instanceGroups.setNamedPorts',
        ordered_params=[u'project', u'zone', u'instanceGroup'],
        path_params=[u'instanceGroup', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroups/{instanceGroup}/setNamedPorts',
        request_field=u'instanceGroupsSetNamedPortsRequest',
        request_type_name=u'ComputeInstanceGroupsSetNamedPortsRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeInstanceGroupsTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instanceGroups.testIamPermissions',
        ordered_params=[u'project', u'zone', u'resource'],
        path_params=[u'project', u'resource', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instanceGroups/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeInstanceGroupsTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

  class InstanceTemplatesService(base_api.BaseApiService):
    """Service class for the instanceTemplates resource."""

    _NAME = u'instanceTemplates'

    def __init__(self, client):
      super(ComputeBeta.InstanceTemplatesService, self).__init__(client)
      self._upload_configs = {
          }

    def Delete(self, request, global_params=None):
      """Deletes the specified instance template. If you delete an instance template that is being referenced from another instance group, the instance group will not be able to create or recreate virtual machine instances. Deleting an instance template is permanent and cannot be undone.

      Args:
        request: (ComputeInstanceTemplatesDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.instanceTemplates.delete',
        ordered_params=[u'project', u'instanceTemplate'],
        path_params=[u'instanceTemplate', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/instanceTemplates/{instanceTemplate}',
        request_field='',
        request_type_name=u'ComputeInstanceTemplatesDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified instance template. Get a list of available instance templates by making a list() request.

      Args:
        request: (ComputeInstanceTemplatesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (InstanceTemplate) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.instanceTemplates.get',
        ordered_params=[u'project', u'instanceTemplate'],
        path_params=[u'instanceTemplate', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/instanceTemplates/{instanceTemplate}',
        request_field='',
        request_type_name=u'ComputeInstanceTemplatesGetRequest',
        response_type_name=u'InstanceTemplate',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates an instance template in the specified project using the data that is included in the request. If you are creating a new template to update an existing instance group, your new instance template must use the same network or, if applicable, the same subnetwork as the original template.

      Args:
        request: (ComputeInstanceTemplatesInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instanceTemplates.insert',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/instanceTemplates',
        request_field=u'instanceTemplate',
        request_type_name=u'ComputeInstanceTemplatesInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves a list of instance templates that are contained within the specified project and zone.

      Args:
        request: (ComputeInstanceTemplatesListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (InstanceTemplateList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.instanceTemplates.list',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/global/instanceTemplates',
        request_field='',
        request_type_name=u'ComputeInstanceTemplatesListRequest',
        response_type_name=u'InstanceTemplateList',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeInstanceTemplatesTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instanceTemplates.testIamPermissions',
        ordered_params=[u'project', u'resource'],
        path_params=[u'project', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/global/instanceTemplates/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeInstanceTemplatesTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

  class InstancesService(base_api.BaseApiService):
    """Service class for the instances resource."""

    _NAME = u'instances'

    def __init__(self, client):
      super(ComputeBeta.InstancesService, self).__init__(client)
      self._upload_configs = {
          }

    def AddAccessConfig(self, request, global_params=None):
      """Adds an access config to an instance's network interface.

      Args:
        request: (ComputeInstancesAddAccessConfigRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('AddAccessConfig')
      return self._RunMethod(
          config, request, global_params=global_params)

    AddAccessConfig.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instances.addAccessConfig',
        ordered_params=[u'project', u'zone', u'instance', u'networkInterface'],
        path_params=[u'instance', u'project', u'zone'],
        query_params=[u'networkInterface'],
        relative_path=u'projects/{project}/zones/{zone}/instances/{instance}/addAccessConfig',
        request_field=u'accessConfig',
        request_type_name=u'ComputeInstancesAddAccessConfigRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def AggregatedList(self, request, global_params=None):
      """Retrieves aggregated list of instances.

      Args:
        request: (ComputeInstancesAggregatedListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (InstanceAggregatedList) The response message.
      """
      config = self.GetMethodConfig('AggregatedList')
      return self._RunMethod(
          config, request, global_params=global_params)

    AggregatedList.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.instances.aggregatedList',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/aggregated/instances',
        request_field='',
        request_type_name=u'ComputeInstancesAggregatedListRequest',
        response_type_name=u'InstanceAggregatedList',
        supports_download=False,
    )

    def AttachDisk(self, request, global_params=None):
      """Attaches a Disk resource to an instance.

      Args:
        request: (ComputeInstancesAttachDiskRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('AttachDisk')
      return self._RunMethod(
          config, request, global_params=global_params)

    AttachDisk.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instances.attachDisk',
        ordered_params=[u'project', u'zone', u'instance'],
        path_params=[u'instance', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instances/{instance}/attachDisk',
        request_field=u'attachedDisk',
        request_type_name=u'ComputeInstancesAttachDiskRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Delete(self, request, global_params=None):
      """Deletes the specified Instance resource. For more information, see Stopping or Deleting an Instance.

      Args:
        request: (ComputeInstancesDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.instances.delete',
        ordered_params=[u'project', u'zone', u'instance'],
        path_params=[u'instance', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instances/{instance}',
        request_field='',
        request_type_name=u'ComputeInstancesDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def DeleteAccessConfig(self, request, global_params=None):
      """Deletes an access config from an instance's network interface.

      Args:
        request: (ComputeInstancesDeleteAccessConfigRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('DeleteAccessConfig')
      return self._RunMethod(
          config, request, global_params=global_params)

    DeleteAccessConfig.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instances.deleteAccessConfig',
        ordered_params=[u'project', u'zone', u'instance', u'accessConfig', u'networkInterface'],
        path_params=[u'instance', u'project', u'zone'],
        query_params=[u'accessConfig', u'networkInterface'],
        relative_path=u'projects/{project}/zones/{zone}/instances/{instance}/deleteAccessConfig',
        request_field='',
        request_type_name=u'ComputeInstancesDeleteAccessConfigRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def DetachDisk(self, request, global_params=None):
      """Detaches a disk from an instance.

      Args:
        request: (ComputeInstancesDetachDiskRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('DetachDisk')
      return self._RunMethod(
          config, request, global_params=global_params)

    DetachDisk.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instances.detachDisk',
        ordered_params=[u'project', u'zone', u'instance', u'deviceName'],
        path_params=[u'instance', u'project', u'zone'],
        query_params=[u'deviceName'],
        relative_path=u'projects/{project}/zones/{zone}/instances/{instance}/detachDisk',
        request_field='',
        request_type_name=u'ComputeInstancesDetachDiskRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified Instance resource. Get a list of available instances by making a list() request.

      Args:
        request: (ComputeInstancesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Instance) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.instances.get',
        ordered_params=[u'project', u'zone', u'instance'],
        path_params=[u'instance', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instances/{instance}',
        request_field='',
        request_type_name=u'ComputeInstancesGetRequest',
        response_type_name=u'Instance',
        supports_download=False,
    )

    def GetSerialPortOutput(self, request, global_params=None):
      """Returns the specified instance's serial port output.

      Args:
        request: (ComputeInstancesGetSerialPortOutputRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (SerialPortOutput) The response message.
      """
      config = self.GetMethodConfig('GetSerialPortOutput')
      return self._RunMethod(
          config, request, global_params=global_params)

    GetSerialPortOutput.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.instances.getSerialPortOutput',
        ordered_params=[u'project', u'zone', u'instance'],
        path_params=[u'instance', u'project', u'zone'],
        query_params=[u'port', u'start'],
        relative_path=u'projects/{project}/zones/{zone}/instances/{instance}/serialPort',
        request_field='',
        request_type_name=u'ComputeInstancesGetSerialPortOutputRequest',
        response_type_name=u'SerialPortOutput',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates an instance resource in the specified project using the data included in the request.

      Args:
        request: (ComputeInstancesInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instances.insert',
        ordered_params=[u'project', u'zone'],
        path_params=[u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instances',
        request_field=u'instance',
        request_type_name=u'ComputeInstancesInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of instances contained within the specified zone.

      Args:
        request: (ComputeInstancesListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (InstanceList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.instances.list',
        ordered_params=[u'project', u'zone'],
        path_params=[u'project', u'zone'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/zones/{zone}/instances',
        request_field='',
        request_type_name=u'ComputeInstancesListRequest',
        response_type_name=u'InstanceList',
        supports_download=False,
    )

    def Reset(self, request, global_params=None):
      """Performs a hard reset on the instance.

      Args:
        request: (ComputeInstancesResetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Reset')
      return self._RunMethod(
          config, request, global_params=global_params)

    Reset.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instances.reset',
        ordered_params=[u'project', u'zone', u'instance'],
        path_params=[u'instance', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instances/{instance}/reset',
        request_field='',
        request_type_name=u'ComputeInstancesResetRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetDiskAutoDelete(self, request, global_params=None):
      """Sets the auto-delete flag for a disk attached to an instance.

      Args:
        request: (ComputeInstancesSetDiskAutoDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetDiskAutoDelete')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetDiskAutoDelete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instances.setDiskAutoDelete',
        ordered_params=[u'project', u'zone', u'instance', u'autoDelete', u'deviceName'],
        path_params=[u'instance', u'project', u'zone'],
        query_params=[u'autoDelete', u'deviceName'],
        relative_path=u'projects/{project}/zones/{zone}/instances/{instance}/setDiskAutoDelete',
        request_field='',
        request_type_name=u'ComputeInstancesSetDiskAutoDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetLabels(self, request, global_params=None):
      """Sets labels on an instance. To learn more about labels, read the Labeling or Tagging Resources documentation.

      Args:
        request: (ComputeInstancesSetLabelsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetLabels')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetLabels.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instances.setLabels',
        ordered_params=[u'project', u'zone', u'instance'],
        path_params=[u'instance', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instances/{instance}/setLabels',
        request_field=u'instancesSetLabelsRequest',
        request_type_name=u'ComputeInstancesSetLabelsRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetMachineResources(self, request, global_params=None):
      """Changes the number and/or type of accelerator for a stopped instance to the values specified in the request.

      Args:
        request: (ComputeInstancesSetMachineResourcesRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetMachineResources')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetMachineResources.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instances.setMachineResources',
        ordered_params=[u'project', u'zone', u'instance'],
        path_params=[u'instance', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instances/{instance}/setMachineResources',
        request_field=u'instancesSetMachineResourcesRequest',
        request_type_name=u'ComputeInstancesSetMachineResourcesRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetMachineType(self, request, global_params=None):
      """Changes the machine type for a stopped instance to the machine type specified in the request.

      Args:
        request: (ComputeInstancesSetMachineTypeRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetMachineType')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetMachineType.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instances.setMachineType',
        ordered_params=[u'project', u'zone', u'instance'],
        path_params=[u'instance', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instances/{instance}/setMachineType',
        request_field=u'instancesSetMachineTypeRequest',
        request_type_name=u'ComputeInstancesSetMachineTypeRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetMetadata(self, request, global_params=None):
      """Sets metadata for the specified instance to the data included in the request.

      Args:
        request: (ComputeInstancesSetMetadataRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetMetadata')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetMetadata.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instances.setMetadata',
        ordered_params=[u'project', u'zone', u'instance'],
        path_params=[u'instance', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instances/{instance}/setMetadata',
        request_field=u'metadata',
        request_type_name=u'ComputeInstancesSetMetadataRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetScheduling(self, request, global_params=None):
      """Sets an instance's scheduling options.

      Args:
        request: (ComputeInstancesSetSchedulingRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetScheduling')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetScheduling.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instances.setScheduling',
        ordered_params=[u'project', u'zone', u'instance'],
        path_params=[u'instance', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instances/{instance}/setScheduling',
        request_field=u'scheduling',
        request_type_name=u'ComputeInstancesSetSchedulingRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetServiceAccount(self, request, global_params=None):
      """Sets the service account on the instance. For more information, read Changing the service account and access scopes for an instance.

      Args:
        request: (ComputeInstancesSetServiceAccountRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetServiceAccount')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetServiceAccount.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instances.setServiceAccount',
        ordered_params=[u'project', u'zone', u'instance'],
        path_params=[u'instance', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instances/{instance}/setServiceAccount',
        request_field=u'instancesSetServiceAccountRequest',
        request_type_name=u'ComputeInstancesSetServiceAccountRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetTags(self, request, global_params=None):
      """Sets tags for the specified instance to the data included in the request.

      Args:
        request: (ComputeInstancesSetTagsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetTags')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetTags.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instances.setTags',
        ordered_params=[u'project', u'zone', u'instance'],
        path_params=[u'instance', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instances/{instance}/setTags',
        request_field=u'tags',
        request_type_name=u'ComputeInstancesSetTagsRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Start(self, request, global_params=None):
      """Starts an instance that was stopped using the using the instances().stop method. For more information, see Restart an instance.

      Args:
        request: (ComputeInstancesStartRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Start')
      return self._RunMethod(
          config, request, global_params=global_params)

    Start.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instances.start',
        ordered_params=[u'project', u'zone', u'instance'],
        path_params=[u'instance', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instances/{instance}/start',
        request_field='',
        request_type_name=u'ComputeInstancesStartRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def StartWithEncryptionKey(self, request, global_params=None):
      """Starts an instance that was stopped using the using the instances().stop method. For more information, see Restart an instance.

      Args:
        request: (ComputeInstancesStartWithEncryptionKeyRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('StartWithEncryptionKey')
      return self._RunMethod(
          config, request, global_params=global_params)

    StartWithEncryptionKey.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instances.startWithEncryptionKey',
        ordered_params=[u'project', u'zone', u'instance'],
        path_params=[u'instance', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instances/{instance}/startWithEncryptionKey',
        request_field=u'instancesStartWithEncryptionKeyRequest',
        request_type_name=u'ComputeInstancesStartWithEncryptionKeyRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Stop(self, request, global_params=None):
      """Stops a running instance, shutting it down cleanly, and allows you to restart the instance at a later time. Stopped instances do not incur per-minute, virtual machine usage charges while they are stopped, but any resources that the virtual machine is using, such as persistent disks and static IP addresses, will continue to be charged until they are deleted. For more information, see Stopping an instance.

      Args:
        request: (ComputeInstancesStopRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Stop')
      return self._RunMethod(
          config, request, global_params=global_params)

    Stop.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instances.stop',
        ordered_params=[u'project', u'zone', u'instance'],
        path_params=[u'instance', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instances/{instance}/stop',
        request_field='',
        request_type_name=u'ComputeInstancesStopRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeInstancesTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.instances.testIamPermissions',
        ordered_params=[u'project', u'zone', u'resource'],
        path_params=[u'project', u'resource', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/instances/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeInstancesTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

  class LicensesService(base_api.BaseApiService):
    """Service class for the licenses resource."""

    _NAME = u'licenses'

    def __init__(self, client):
      super(ComputeBeta.LicensesService, self).__init__(client)
      self._upload_configs = {
          }

    def Get(self, request, global_params=None):
      """Returns the specified License resource. Get a list of available licenses by making a list() request.

      Args:
        request: (ComputeLicensesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (License) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.licenses.get',
        ordered_params=[u'project', u'license'],
        path_params=[u'license', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/licenses/{license}',
        request_field='',
        request_type_name=u'ComputeLicensesGetRequest',
        response_type_name=u'License',
        supports_download=False,
    )

  class MachineTypesService(base_api.BaseApiService):
    """Service class for the machineTypes resource."""

    _NAME = u'machineTypes'

    def __init__(self, client):
      super(ComputeBeta.MachineTypesService, self).__init__(client)
      self._upload_configs = {
          }

    def AggregatedList(self, request, global_params=None):
      """Retrieves an aggregated list of machine types.

      Args:
        request: (ComputeMachineTypesAggregatedListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (MachineTypeAggregatedList) The response message.
      """
      config = self.GetMethodConfig('AggregatedList')
      return self._RunMethod(
          config, request, global_params=global_params)

    AggregatedList.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.machineTypes.aggregatedList',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/aggregated/machineTypes',
        request_field='',
        request_type_name=u'ComputeMachineTypesAggregatedListRequest',
        response_type_name=u'MachineTypeAggregatedList',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified machine type. Get a list of available machine types by making a list() request.

      Args:
        request: (ComputeMachineTypesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (MachineType) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.machineTypes.get',
        ordered_params=[u'project', u'zone', u'machineType'],
        path_params=[u'machineType', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/machineTypes/{machineType}',
        request_field='',
        request_type_name=u'ComputeMachineTypesGetRequest',
        response_type_name=u'MachineType',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves a list of machine types available to the specified project.

      Args:
        request: (ComputeMachineTypesListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (MachineTypeList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.machineTypes.list',
        ordered_params=[u'project', u'zone'],
        path_params=[u'project', u'zone'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/zones/{zone}/machineTypes',
        request_field='',
        request_type_name=u'ComputeMachineTypesListRequest',
        response_type_name=u'MachineTypeList',
        supports_download=False,
    )

  class NetworksService(base_api.BaseApiService):
    """Service class for the networks resource."""

    _NAME = u'networks'

    def __init__(self, client):
      super(ComputeBeta.NetworksService, self).__init__(client)
      self._upload_configs = {
          }

    def AddPeering(self, request, global_params=None):
      """Adds a peering to the specified network.

      Args:
        request: (ComputeNetworksAddPeeringRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('AddPeering')
      return self._RunMethod(
          config, request, global_params=global_params)

    AddPeering.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.networks.addPeering',
        ordered_params=[u'project', u'network'],
        path_params=[u'network', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/networks/{network}/addPeering',
        request_field=u'networksAddPeeringRequest',
        request_type_name=u'ComputeNetworksAddPeeringRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Delete(self, request, global_params=None):
      """Deletes the specified network.

      Args:
        request: (ComputeNetworksDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.networks.delete',
        ordered_params=[u'project', u'network'],
        path_params=[u'network', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/networks/{network}',
        request_field='',
        request_type_name=u'ComputeNetworksDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified network. Get a list of available networks by making a list() request.

      Args:
        request: (ComputeNetworksGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Network) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.networks.get',
        ordered_params=[u'project', u'network'],
        path_params=[u'network', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/networks/{network}',
        request_field='',
        request_type_name=u'ComputeNetworksGetRequest',
        response_type_name=u'Network',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a network in the specified project using the data included in the request.

      Args:
        request: (ComputeNetworksInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.networks.insert',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/networks',
        request_field=u'network',
        request_type_name=u'ComputeNetworksInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of networks available to the specified project.

      Args:
        request: (ComputeNetworksListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (NetworkList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.networks.list',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/global/networks',
        request_field='',
        request_type_name=u'ComputeNetworksListRequest',
        response_type_name=u'NetworkList',
        supports_download=False,
    )

    def RemovePeering(self, request, global_params=None):
      """Removes a peering from the specified network.

      Args:
        request: (ComputeNetworksRemovePeeringRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('RemovePeering')
      return self._RunMethod(
          config, request, global_params=global_params)

    RemovePeering.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.networks.removePeering',
        ordered_params=[u'project', u'network'],
        path_params=[u'network', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/networks/{network}/removePeering',
        request_field=u'networksRemovePeeringRequest',
        request_type_name=u'ComputeNetworksRemovePeeringRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SwitchToCustomMode(self, request, global_params=None):
      """Switches the network mode from auto subnet mode to custom subnet mode.

      Args:
        request: (ComputeNetworksSwitchToCustomModeRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SwitchToCustomMode')
      return self._RunMethod(
          config, request, global_params=global_params)

    SwitchToCustomMode.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.networks.switchToCustomMode',
        ordered_params=[u'project', u'network'],
        path_params=[u'network', u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/networks/{network}/switchToCustomMode',
        request_field='',
        request_type_name=u'ComputeNetworksSwitchToCustomModeRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeNetworksTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.networks.testIamPermissions',
        ordered_params=[u'project', u'resource'],
        path_params=[u'project', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/global/networks/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeNetworksTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

  class ProjectsService(base_api.BaseApiService):
    """Service class for the projects resource."""

    _NAME = u'projects'

    def __init__(self, client):
      super(ComputeBeta.ProjectsService, self).__init__(client)
      self._upload_configs = {
          }

    def DisableXpnHost(self, request, global_params=None):
      """Disable this project as an XPN host project.

      Args:
        request: (ComputeProjectsDisableXpnHostRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('DisableXpnHost')
      return self._RunMethod(
          config, request, global_params=global_params)

    DisableXpnHost.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.projects.disableXpnHost',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/disableXpnHost',
        request_field='',
        request_type_name=u'ComputeProjectsDisableXpnHostRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def DisableXpnResource(self, request, global_params=None):
      """Disable an XPN resource associated with this host project.

      Args:
        request: (ComputeProjectsDisableXpnResourceRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('DisableXpnResource')
      return self._RunMethod(
          config, request, global_params=global_params)

    DisableXpnResource.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.projects.disableXpnResource',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/disableXpnResource',
        request_field=u'projectsDisableXpnResourceRequest',
        request_type_name=u'ComputeProjectsDisableXpnResourceRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def EnableXpnHost(self, request, global_params=None):
      """Enable this project as an XPN host project.

      Args:
        request: (ComputeProjectsEnableXpnHostRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('EnableXpnHost')
      return self._RunMethod(
          config, request, global_params=global_params)

    EnableXpnHost.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.projects.enableXpnHost',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/enableXpnHost',
        request_field='',
        request_type_name=u'ComputeProjectsEnableXpnHostRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def EnableXpnResource(self, request, global_params=None):
      """Enable XPN resource (a.k.a service project or service folder in the future) for a host project, so that subnetworks in the host project can be used by instances in the service project or folder.

      Args:
        request: (ComputeProjectsEnableXpnResourceRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('EnableXpnResource')
      return self._RunMethod(
          config, request, global_params=global_params)

    EnableXpnResource.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.projects.enableXpnResource',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/enableXpnResource',
        request_field=u'projectsEnableXpnResourceRequest',
        request_type_name=u'ComputeProjectsEnableXpnResourceRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified Project resource.

      Args:
        request: (ComputeProjectsGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Project) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.projects.get',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}',
        request_field='',
        request_type_name=u'ComputeProjectsGetRequest',
        response_type_name=u'Project',
        supports_download=False,
    )

    def GetXpnHost(self, request, global_params=None):
      """Get the XPN host project that this project links to. May be empty if no link exists.

      Args:
        request: (ComputeProjectsGetXpnHostRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Project) The response message.
      """
      config = self.GetMethodConfig('GetXpnHost')
      return self._RunMethod(
          config, request, global_params=global_params)

    GetXpnHost.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.projects.getXpnHost',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/getXpnHost',
        request_field='',
        request_type_name=u'ComputeProjectsGetXpnHostRequest',
        response_type_name=u'Project',
        supports_download=False,
    )

    def GetXpnResources(self, request, global_params=None):
      """Get XPN resources associated with this host project.

      Args:
        request: (ComputeProjectsGetXpnResourcesRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (ProjectsGetXpnResources) The response message.
      """
      config = self.GetMethodConfig('GetXpnResources')
      return self._RunMethod(
          config, request, global_params=global_params)

    GetXpnResources.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.projects.getXpnResources',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'order_by', u'pageToken'],
        relative_path=u'projects/{project}/getXpnResources',
        request_field='',
        request_type_name=u'ComputeProjectsGetXpnResourcesRequest',
        response_type_name=u'ProjectsGetXpnResources',
        supports_download=False,
    )

    def ListXpnHosts(self, request, global_params=None):
      """List all XPN host projects visible to the user in an organization.

      Args:
        request: (ComputeProjectsListXpnHostsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (XpnHostList) The response message.
      """
      config = self.GetMethodConfig('ListXpnHosts')
      return self._RunMethod(
          config, request, global_params=global_params)

    ListXpnHosts.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.projects.listXpnHosts',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'order_by', u'pageToken'],
        relative_path=u'projects/{project}/listXpnHosts',
        request_field=u'projectsListXpnHostsRequest',
        request_type_name=u'ComputeProjectsListXpnHostsRequest',
        response_type_name=u'XpnHostList',
        supports_download=False,
    )

    def MoveDisk(self, request, global_params=None):
      """Moves a persistent disk from one zone to another.

      Args:
        request: (ComputeProjectsMoveDiskRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('MoveDisk')
      return self._RunMethod(
          config, request, global_params=global_params)

    MoveDisk.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.projects.moveDisk',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/moveDisk',
        request_field=u'diskMoveRequest',
        request_type_name=u'ComputeProjectsMoveDiskRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def MoveInstance(self, request, global_params=None):
      """Moves an instance and its attached persistent disks from one zone to another.

      Args:
        request: (ComputeProjectsMoveInstanceRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('MoveInstance')
      return self._RunMethod(
          config, request, global_params=global_params)

    MoveInstance.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.projects.moveInstance',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/moveInstance',
        request_field=u'instanceMoveRequest',
        request_type_name=u'ComputeProjectsMoveInstanceRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetCommonInstanceMetadata(self, request, global_params=None):
      """Sets metadata common to all instances within the specified project using the data included in the request.

      Args:
        request: (ComputeProjectsSetCommonInstanceMetadataRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetCommonInstanceMetadata')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetCommonInstanceMetadata.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.projects.setCommonInstanceMetadata',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/setCommonInstanceMetadata',
        request_field=u'metadata',
        request_type_name=u'ComputeProjectsSetCommonInstanceMetadataRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetUsageExportBucket(self, request, global_params=None):
      """Enables the usage export feature and sets the usage export bucket where reports are stored. If you provide an empty request body using this method, the usage export feature will be disabled.

      Args:
        request: (ComputeProjectsSetUsageExportBucketRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetUsageExportBucket')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetUsageExportBucket.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.projects.setUsageExportBucket',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/setUsageExportBucket',
        request_field=u'usageExportLocation',
        request_type_name=u'ComputeProjectsSetUsageExportBucketRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

  class RegionAutoscalersService(base_api.BaseApiService):
    """Service class for the regionAutoscalers resource."""

    _NAME = u'regionAutoscalers'

    def __init__(self, client):
      super(ComputeBeta.RegionAutoscalersService, self).__init__(client)
      self._upload_configs = {
          }

    def Delete(self, request, global_params=None):
      """Deletes the specified autoscaler.

      Args:
        request: (ComputeRegionAutoscalersDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.regionAutoscalers.delete',
        ordered_params=[u'project', u'region', u'autoscaler'],
        path_params=[u'autoscaler', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/autoscalers/{autoscaler}',
        request_field='',
        request_type_name=u'ComputeRegionAutoscalersDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified autoscaler.

      Args:
        request: (ComputeRegionAutoscalersGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Autoscaler) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.regionAutoscalers.get',
        ordered_params=[u'project', u'region', u'autoscaler'],
        path_params=[u'autoscaler', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/autoscalers/{autoscaler}',
        request_field='',
        request_type_name=u'ComputeRegionAutoscalersGetRequest',
        response_type_name=u'Autoscaler',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates an autoscaler in the specified project using the data included in the request.

      Args:
        request: (ComputeRegionAutoscalersInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.regionAutoscalers.insert',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/autoscalers',
        request_field=u'autoscaler',
        request_type_name=u'ComputeRegionAutoscalersInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves a list of autoscalers contained within the specified region.

      Args:
        request: (ComputeRegionAutoscalersListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (RegionAutoscalerList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.regionAutoscalers.list',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/regions/{region}/autoscalers',
        request_field='',
        request_type_name=u'ComputeRegionAutoscalersListRequest',
        response_type_name=u'RegionAutoscalerList',
        supports_download=False,
    )

    def Patch(self, request, global_params=None):
      """Updates an autoscaler in the specified project using the data included in the request. This method supports patch semantics.

      Args:
        request: (ComputeRegionAutoscalersPatchRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Patch')
      return self._RunMethod(
          config, request, global_params=global_params)

    Patch.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PATCH',
        method_id=u'compute.regionAutoscalers.patch',
        ordered_params=[u'project', u'region', u'autoscaler'],
        path_params=[u'project', u'region'],
        query_params=[u'autoscaler'],
        relative_path=u'projects/{project}/regions/{region}/autoscalers',
        request_field=u'autoscalerResource',
        request_type_name=u'ComputeRegionAutoscalersPatchRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeRegionAutoscalersTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.regionAutoscalers.testIamPermissions',
        ordered_params=[u'project', u'region', u'resource'],
        path_params=[u'project', u'region', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/autoscalers/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeRegionAutoscalersTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

    def Update(self, request, global_params=None):
      """Updates an autoscaler in the specified project using the data included in the request.

      Args:
        request: (ComputeRegionAutoscalersUpdateRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Update')
      return self._RunMethod(
          config, request, global_params=global_params)

    Update.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PUT',
        method_id=u'compute.regionAutoscalers.update',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[u'autoscaler'],
        relative_path=u'projects/{project}/regions/{region}/autoscalers',
        request_field=u'autoscalerResource',
        request_type_name=u'ComputeRegionAutoscalersUpdateRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

  class RegionBackendServicesService(base_api.BaseApiService):
    """Service class for the regionBackendServices resource."""

    _NAME = u'regionBackendServices'

    def __init__(self, client):
      super(ComputeBeta.RegionBackendServicesService, self).__init__(client)
      self._upload_configs = {
          }

    def Delete(self, request, global_params=None):
      """Deletes the specified regional BackendService resource.

      Args:
        request: (ComputeRegionBackendServicesDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.regionBackendServices.delete',
        ordered_params=[u'project', u'region', u'backendService'],
        path_params=[u'backendService', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/backendServices/{backendService}',
        request_field='',
        request_type_name=u'ComputeRegionBackendServicesDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified regional BackendService resource.

      Args:
        request: (ComputeRegionBackendServicesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (BackendService) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.regionBackendServices.get',
        ordered_params=[u'project', u'region', u'backendService'],
        path_params=[u'backendService', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/backendServices/{backendService}',
        request_field='',
        request_type_name=u'ComputeRegionBackendServicesGetRequest',
        response_type_name=u'BackendService',
        supports_download=False,
    )

    def GetHealth(self, request, global_params=None):
      """Gets the most recent health check results for this regional BackendService.

      Args:
        request: (ComputeRegionBackendServicesGetHealthRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (BackendServiceGroupHealth) The response message.
      """
      config = self.GetMethodConfig('GetHealth')
      return self._RunMethod(
          config, request, global_params=global_params)

    GetHealth.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.regionBackendServices.getHealth',
        ordered_params=[u'project', u'region', u'backendService'],
        path_params=[u'backendService', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/backendServices/{backendService}/getHealth',
        request_field=u'resourceGroupReference',
        request_type_name=u'ComputeRegionBackendServicesGetHealthRequest',
        response_type_name=u'BackendServiceGroupHealth',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a regional BackendService resource in the specified project using the data included in the request. There are several restrictions and guidelines to keep in mind when creating a regional backend service. Read  Restrictions and Guidelines for more information.

      Args:
        request: (ComputeRegionBackendServicesInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.regionBackendServices.insert',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/backendServices',
        request_field=u'backendService',
        request_type_name=u'ComputeRegionBackendServicesInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of regional BackendService resources available to the specified project in the given region.

      Args:
        request: (ComputeRegionBackendServicesListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (BackendServiceList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.regionBackendServices.list',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/regions/{region}/backendServices',
        request_field='',
        request_type_name=u'ComputeRegionBackendServicesListRequest',
        response_type_name=u'BackendServiceList',
        supports_download=False,
    )

    def Patch(self, request, global_params=None):
      """Updates the specified regional BackendService resource with the data included in the request. There are several restrictions and guidelines to keep in mind when updating a backend service. Read  Restrictions and Guidelines for more information. This method supports patch semantics.

      Args:
        request: (ComputeRegionBackendServicesPatchRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Patch')
      return self._RunMethod(
          config, request, global_params=global_params)

    Patch.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PATCH',
        method_id=u'compute.regionBackendServices.patch',
        ordered_params=[u'project', u'region', u'backendService'],
        path_params=[u'backendService', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/backendServices/{backendService}',
        request_field=u'backendServiceResource',
        request_type_name=u'ComputeRegionBackendServicesPatchRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeRegionBackendServicesTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.regionBackendServices.testIamPermissions',
        ordered_params=[u'project', u'region', u'resource'],
        path_params=[u'project', u'region', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/backendServices/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeRegionBackendServicesTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

    def Update(self, request, global_params=None):
      """Updates the specified regional BackendService resource with the data included in the request. There are several restrictions and guidelines to keep in mind when updating a backend service. Read  Restrictions and Guidelines for more information.

      Args:
        request: (ComputeRegionBackendServicesUpdateRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Update')
      return self._RunMethod(
          config, request, global_params=global_params)

    Update.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PUT',
        method_id=u'compute.regionBackendServices.update',
        ordered_params=[u'project', u'region', u'backendService'],
        path_params=[u'backendService', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/backendServices/{backendService}',
        request_field=u'backendServiceResource',
        request_type_name=u'ComputeRegionBackendServicesUpdateRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

  class RegionInstanceGroupManagersService(base_api.BaseApiService):
    """Service class for the regionInstanceGroupManagers resource."""

    _NAME = u'regionInstanceGroupManagers'

    def __init__(self, client):
      super(ComputeBeta.RegionInstanceGroupManagersService, self).__init__(client)
      self._upload_configs = {
          }

    def AbandonInstances(self, request, global_params=None):
      """Schedules a group action to remove the specified instances from the managed instance group. Abandoning an instance does not delete the instance, but it does remove the instance from any target pools that are applied by the managed instance group. This method reduces the targetSize of the managed instance group by the number of instances that you abandon. This operation is marked as DONE when the action is scheduled even if the instances have not yet been removed from the group. You must separately verify the status of the abandoning action with the listmanagedinstances method.

      Args:
        request: (ComputeRegionInstanceGroupManagersAbandonInstancesRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('AbandonInstances')
      return self._RunMethod(
          config, request, global_params=global_params)

    AbandonInstances.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.regionInstanceGroupManagers.abandonInstances',
        ordered_params=[u'project', u'region', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/abandonInstances',
        request_field=u'regionInstanceGroupManagersAbandonInstancesRequest',
        request_type_name=u'ComputeRegionInstanceGroupManagersAbandonInstancesRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Delete(self, request, global_params=None):
      """Deletes the specified managed instance group and all of the instances in that group.

      Args:
        request: (ComputeRegionInstanceGroupManagersDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.regionInstanceGroupManagers.delete',
        ordered_params=[u'project', u'region', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}',
        request_field='',
        request_type_name=u'ComputeRegionInstanceGroupManagersDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def DeleteInstances(self, request, global_params=None):
      """Schedules a group action to delete the specified instances in the managed instance group. The instances are also removed from any target pools of which they were a member. This method reduces the targetSize of the managed instance group by the number of instances that you delete. This operation is marked as DONE when the action is scheduled even if the instances are still being deleted. You must separately verify the status of the deleting action with the listmanagedinstances method.

      Args:
        request: (ComputeRegionInstanceGroupManagersDeleteInstancesRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('DeleteInstances')
      return self._RunMethod(
          config, request, global_params=global_params)

    DeleteInstances.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.regionInstanceGroupManagers.deleteInstances',
        ordered_params=[u'project', u'region', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/deleteInstances',
        request_field=u'regionInstanceGroupManagersDeleteInstancesRequest',
        request_type_name=u'ComputeRegionInstanceGroupManagersDeleteInstancesRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns all of the details about the specified managed instance group.

      Args:
        request: (ComputeRegionInstanceGroupManagersGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (InstanceGroupManager) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.regionInstanceGroupManagers.get',
        ordered_params=[u'project', u'region', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}',
        request_field='',
        request_type_name=u'ComputeRegionInstanceGroupManagersGetRequest',
        response_type_name=u'InstanceGroupManager',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a managed instance group using the information that you specify in the request. After the group is created, it schedules an action to create instances in the group using the specified instance template. This operation is marked as DONE when the group is created even if the instances in the group have not yet been created. You must separately verify the status of the individual instances with the listmanagedinstances method.

      Args:
        request: (ComputeRegionInstanceGroupManagersInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.regionInstanceGroupManagers.insert',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/instanceGroupManagers',
        request_field=u'instanceGroupManager',
        request_type_name=u'ComputeRegionInstanceGroupManagersInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of managed instance groups that are contained within the specified region.

      Args:
        request: (ComputeRegionInstanceGroupManagersListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (RegionInstanceGroupManagerList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.regionInstanceGroupManagers.list',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/regions/{region}/instanceGroupManagers',
        request_field='',
        request_type_name=u'ComputeRegionInstanceGroupManagersListRequest',
        response_type_name=u'RegionInstanceGroupManagerList',
        supports_download=False,
    )

    def ListManagedInstances(self, request, global_params=None):
      """Lists the instances in the managed instance group and instances that are scheduled to be created. The list includes any current actions that the group has scheduled for its instances.

      Args:
        request: (ComputeRegionInstanceGroupManagersListManagedInstancesRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (RegionInstanceGroupManagersListInstancesResponse) The response message.
      """
      config = self.GetMethodConfig('ListManagedInstances')
      return self._RunMethod(
          config, request, global_params=global_params)

    ListManagedInstances.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.regionInstanceGroupManagers.listManagedInstances',
        ordered_params=[u'project', u'region', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'region'],
        query_params=[u'filter', u'maxResults', u'order_by', u'pageToken'],
        relative_path=u'projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/listManagedInstances',
        request_field='',
        request_type_name=u'ComputeRegionInstanceGroupManagersListManagedInstancesRequest',
        response_type_name=u'RegionInstanceGroupManagersListInstancesResponse',
        supports_download=False,
    )

    def Patch(self, request, global_params=None):
      """Updates a managed instance group using the information that you specify in the request. This operation is marked as DONE when the group is updated even if the instances in the group have not yet been updated. You must separately verify the status of the individual instances with the listmanagedinstances method. This method supports patch semantics.

      Args:
        request: (ComputeRegionInstanceGroupManagersPatchRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Patch')
      return self._RunMethod(
          config, request, global_params=global_params)

    Patch.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PATCH',
        method_id=u'compute.regionInstanceGroupManagers.patch',
        ordered_params=[u'project', u'region', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}',
        request_field=u'instanceGroupManagerResource',
        request_type_name=u'ComputeRegionInstanceGroupManagersPatchRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def RecreateInstances(self, request, global_params=None):
      """Schedules a group action to recreate the specified instances in the managed instance group. The instances are deleted and recreated using the current instance template for the managed instance group. This operation is marked as DONE when the action is scheduled even if the instances have not yet been recreated. You must separately verify the status of the recreating action with the listmanagedinstances method.

      Args:
        request: (ComputeRegionInstanceGroupManagersRecreateInstancesRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('RecreateInstances')
      return self._RunMethod(
          config, request, global_params=global_params)

    RecreateInstances.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.regionInstanceGroupManagers.recreateInstances',
        ordered_params=[u'project', u'region', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/recreateInstances',
        request_field=u'regionInstanceGroupManagersRecreateRequest',
        request_type_name=u'ComputeRegionInstanceGroupManagersRecreateInstancesRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Resize(self, request, global_params=None):
      """Changes the intended size for the managed instance group. If you increase the size, the group schedules actions to create new instances using the current instance template. If you decrease the size, the group schedules delete actions on one or more instances. The resize operation is marked DONE when the resize actions are scheduled even if the group has not yet added or deleted any instances. You must separately verify the status of the creating or deleting actions with the listmanagedinstances method.

      Args:
        request: (ComputeRegionInstanceGroupManagersResizeRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Resize')
      return self._RunMethod(
          config, request, global_params=global_params)

    Resize.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.regionInstanceGroupManagers.resize',
        ordered_params=[u'project', u'region', u'instanceGroupManager', u'size'],
        path_params=[u'instanceGroupManager', u'project', u'region'],
        query_params=[u'size'],
        relative_path=u'projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/resize',
        request_field='',
        request_type_name=u'ComputeRegionInstanceGroupManagersResizeRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetAutoHealingPolicies(self, request, global_params=None):
      """Modifies the autohealing policy for the instances in this managed instance group.

      Args:
        request: (ComputeRegionInstanceGroupManagersSetAutoHealingPoliciesRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetAutoHealingPolicies')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetAutoHealingPolicies.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.regionInstanceGroupManagers.setAutoHealingPolicies',
        ordered_params=[u'project', u'region', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/setAutoHealingPolicies',
        request_field=u'regionInstanceGroupManagersSetAutoHealingRequest',
        request_type_name=u'ComputeRegionInstanceGroupManagersSetAutoHealingPoliciesRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetInstanceTemplate(self, request, global_params=None):
      """Sets the instance template to use when creating new instances or recreating instances in this group. Existing instances are not affected.

      Args:
        request: (ComputeRegionInstanceGroupManagersSetInstanceTemplateRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetInstanceTemplate')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetInstanceTemplate.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.regionInstanceGroupManagers.setInstanceTemplate',
        ordered_params=[u'project', u'region', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/setInstanceTemplate',
        request_field=u'regionInstanceGroupManagersSetTemplateRequest',
        request_type_name=u'ComputeRegionInstanceGroupManagersSetInstanceTemplateRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetTargetPools(self, request, global_params=None):
      """Modifies the target pools to which all new instances in this group are assigned. Existing instances in the group are not affected.

      Args:
        request: (ComputeRegionInstanceGroupManagersSetTargetPoolsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetTargetPools')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetTargetPools.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.regionInstanceGroupManagers.setTargetPools',
        ordered_params=[u'project', u'region', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}/setTargetPools',
        request_field=u'regionInstanceGroupManagersSetTargetPoolsRequest',
        request_type_name=u'ComputeRegionInstanceGroupManagersSetTargetPoolsRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeRegionInstanceGroupManagersTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.regionInstanceGroupManagers.testIamPermissions',
        ordered_params=[u'project', u'region', u'resource'],
        path_params=[u'project', u'region', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/instanceGroupManagers/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeRegionInstanceGroupManagersTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

    def Update(self, request, global_params=None):
      """Updates a managed instance group using the information that you specify in the request. This operation is marked as DONE when the group is updated even if the instances in the group have not yet been updated. You must separately verify the status of the individual instances with the listmanagedinstances method.

      Args:
        request: (ComputeRegionInstanceGroupManagersUpdateRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Update')
      return self._RunMethod(
          config, request, global_params=global_params)

    Update.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PUT',
        method_id=u'compute.regionInstanceGroupManagers.update',
        ordered_params=[u'project', u'region', u'instanceGroupManager'],
        path_params=[u'instanceGroupManager', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/instanceGroupManagers/{instanceGroupManager}',
        request_field=u'instanceGroupManagerResource',
        request_type_name=u'ComputeRegionInstanceGroupManagersUpdateRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

  class RegionInstanceGroupsService(base_api.BaseApiService):
    """Service class for the regionInstanceGroups resource."""

    _NAME = u'regionInstanceGroups'

    def __init__(self, client):
      super(ComputeBeta.RegionInstanceGroupsService, self).__init__(client)
      self._upload_configs = {
          }

    def Get(self, request, global_params=None):
      """Returns the specified instance group resource.

      Args:
        request: (ComputeRegionInstanceGroupsGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (InstanceGroup) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.regionInstanceGroups.get',
        ordered_params=[u'project', u'region', u'instanceGroup'],
        path_params=[u'instanceGroup', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/instanceGroups/{instanceGroup}',
        request_field='',
        request_type_name=u'ComputeRegionInstanceGroupsGetRequest',
        response_type_name=u'InstanceGroup',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of instance group resources contained within the specified region.

      Args:
        request: (ComputeRegionInstanceGroupsListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (RegionInstanceGroupList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.regionInstanceGroups.list',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/regions/{region}/instanceGroups',
        request_field='',
        request_type_name=u'ComputeRegionInstanceGroupsListRequest',
        response_type_name=u'RegionInstanceGroupList',
        supports_download=False,
    )

    def ListInstances(self, request, global_params=None):
      """Lists the instances in the specified instance group and displays information about the named ports. Depending on the specified options, this method can list all instances or only the instances that are running.

      Args:
        request: (ComputeRegionInstanceGroupsListInstancesRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (RegionInstanceGroupsListInstances) The response message.
      """
      config = self.GetMethodConfig('ListInstances')
      return self._RunMethod(
          config, request, global_params=global_params)

    ListInstances.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.regionInstanceGroups.listInstances',
        ordered_params=[u'project', u'region', u'instanceGroup'],
        path_params=[u'instanceGroup', u'project', u'region'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/regions/{region}/instanceGroups/{instanceGroup}/listInstances',
        request_field=u'regionInstanceGroupsListInstancesRequest',
        request_type_name=u'ComputeRegionInstanceGroupsListInstancesRequest',
        response_type_name=u'RegionInstanceGroupsListInstances',
        supports_download=False,
    )

    def SetNamedPorts(self, request, global_params=None):
      """Sets the named ports for the specified regional instance group.

      Args:
        request: (ComputeRegionInstanceGroupsSetNamedPortsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetNamedPorts')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetNamedPorts.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.regionInstanceGroups.setNamedPorts',
        ordered_params=[u'project', u'region', u'instanceGroup'],
        path_params=[u'instanceGroup', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/instanceGroups/{instanceGroup}/setNamedPorts',
        request_field=u'regionInstanceGroupsSetNamedPortsRequest',
        request_type_name=u'ComputeRegionInstanceGroupsSetNamedPortsRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeRegionInstanceGroupsTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.regionInstanceGroups.testIamPermissions',
        ordered_params=[u'project', u'region', u'resource'],
        path_params=[u'project', u'region', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/instanceGroups/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeRegionInstanceGroupsTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

  class RegionOperationsService(base_api.BaseApiService):
    """Service class for the regionOperations resource."""

    _NAME = u'regionOperations'

    def __init__(self, client):
      super(ComputeBeta.RegionOperationsService, self).__init__(client)
      self._upload_configs = {
          }

    def Delete(self, request, global_params=None):
      """Deletes the specified region-specific Operations resource.

      Args:
        request: (ComputeRegionOperationsDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (ComputeRegionOperationsDeleteResponse) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.regionOperations.delete',
        ordered_params=[u'project', u'region', u'operation'],
        path_params=[u'operation', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/operations/{operation}',
        request_field='',
        request_type_name=u'ComputeRegionOperationsDeleteRequest',
        response_type_name=u'ComputeRegionOperationsDeleteResponse',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Retrieves the specified region-specific Operations resource.

      Args:
        request: (ComputeRegionOperationsGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.regionOperations.get',
        ordered_params=[u'project', u'region', u'operation'],
        path_params=[u'operation', u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/operations/{operation}',
        request_field='',
        request_type_name=u'ComputeRegionOperationsGetRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves a list of Operation resources contained within the specified region.

      Args:
        request: (ComputeRegionOperationsListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (OperationList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.regionOperations.list',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/regions/{region}/operations',
        request_field='',
        request_type_name=u'ComputeRegionOperationsListRequest',
        response_type_name=u'OperationList',
        supports_download=False,
    )

  class RegionsService(base_api.BaseApiService):
    """Service class for the regions resource."""

    _NAME = u'regions'

    def __init__(self, client):
      super(ComputeBeta.RegionsService, self).__init__(client)
      self._upload_configs = {
          }

    def Get(self, request, global_params=None):
      """Returns the specified Region resource. Get a list of available regions by making a list() request.

      Args:
        request: (ComputeRegionsGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Region) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.regions.get',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}',
        request_field='',
        request_type_name=u'ComputeRegionsGetRequest',
        response_type_name=u'Region',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of region resources available to the specified project.

      Args:
        request: (ComputeRegionsListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (RegionList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.regions.list',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/regions',
        request_field='',
        request_type_name=u'ComputeRegionsListRequest',
        response_type_name=u'RegionList',
        supports_download=False,
    )

  class RoutersService(base_api.BaseApiService):
    """Service class for the routers resource."""

    _NAME = u'routers'

    def __init__(self, client):
      super(ComputeBeta.RoutersService, self).__init__(client)
      self._upload_configs = {
          }

    def AggregatedList(self, request, global_params=None):
      """Retrieves an aggregated list of routers.

      Args:
        request: (ComputeRoutersAggregatedListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (RouterAggregatedList) The response message.
      """
      config = self.GetMethodConfig('AggregatedList')
      return self._RunMethod(
          config, request, global_params=global_params)

    AggregatedList.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.routers.aggregatedList',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/aggregated/routers',
        request_field='',
        request_type_name=u'ComputeRoutersAggregatedListRequest',
        response_type_name=u'RouterAggregatedList',
        supports_download=False,
    )

    def Delete(self, request, global_params=None):
      """Deletes the specified Router resource.

      Args:
        request: (ComputeRoutersDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.routers.delete',
        ordered_params=[u'project', u'region', u'router'],
        path_params=[u'project', u'region', u'router'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/routers/{router}',
        request_field='',
        request_type_name=u'ComputeRoutersDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified Router resource. Get a list of available routers by making a list() request.

      Args:
        request: (ComputeRoutersGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Router) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.routers.get',
        ordered_params=[u'project', u'region', u'router'],
        path_params=[u'project', u'region', u'router'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/routers/{router}',
        request_field='',
        request_type_name=u'ComputeRoutersGetRequest',
        response_type_name=u'Router',
        supports_download=False,
    )

    def GetRouterStatus(self, request, global_params=None):
      """Retrieves runtime information of the specified router.

      Args:
        request: (ComputeRoutersGetRouterStatusRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (RouterStatusResponse) The response message.
      """
      config = self.GetMethodConfig('GetRouterStatus')
      return self._RunMethod(
          config, request, global_params=global_params)

    GetRouterStatus.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.routers.getRouterStatus',
        ordered_params=[u'project', u'region', u'router'],
        path_params=[u'project', u'region', u'router'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/routers/{router}/getRouterStatus',
        request_field='',
        request_type_name=u'ComputeRoutersGetRouterStatusRequest',
        response_type_name=u'RouterStatusResponse',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a Router resource in the specified project and region using the data included in the request.

      Args:
        request: (ComputeRoutersInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.routers.insert',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/routers',
        request_field=u'router',
        request_type_name=u'ComputeRoutersInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves a list of Router resources available to the specified project.

      Args:
        request: (ComputeRoutersListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (RouterList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.routers.list',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/regions/{region}/routers',
        request_field='',
        request_type_name=u'ComputeRoutersListRequest',
        response_type_name=u'RouterList',
        supports_download=False,
    )

    def Patch(self, request, global_params=None):
      """Updates the specified Router resource with the data included in the request. This method supports patch semantics.

      Args:
        request: (ComputeRoutersPatchRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Patch')
      return self._RunMethod(
          config, request, global_params=global_params)

    Patch.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PATCH',
        method_id=u'compute.routers.patch',
        ordered_params=[u'project', u'region', u'router'],
        path_params=[u'project', u'region', u'router'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/routers/{router}',
        request_field=u'routerResource',
        request_type_name=u'ComputeRoutersPatchRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Preview(self, request, global_params=None):
      """Preview fields auto-generated during router create and update operations. Calling this method does NOT create or update the router.

      Args:
        request: (ComputeRoutersPreviewRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (RoutersPreviewResponse) The response message.
      """
      config = self.GetMethodConfig('Preview')
      return self._RunMethod(
          config, request, global_params=global_params)

    Preview.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.routers.preview',
        ordered_params=[u'project', u'region', u'router'],
        path_params=[u'project', u'region', u'router'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/routers/{router}/preview',
        request_field=u'routerResource',
        request_type_name=u'ComputeRoutersPreviewRequest',
        response_type_name=u'RoutersPreviewResponse',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeRoutersTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.routers.testIamPermissions',
        ordered_params=[u'project', u'region', u'resource'],
        path_params=[u'project', u'region', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/routers/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeRoutersTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

    def Update(self, request, global_params=None):
      """Updates the specified Router resource with the data included in the request.

      Args:
        request: (ComputeRoutersUpdateRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Update')
      return self._RunMethod(
          config, request, global_params=global_params)

    Update.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PUT',
        method_id=u'compute.routers.update',
        ordered_params=[u'project', u'region', u'router'],
        path_params=[u'project', u'region', u'router'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/routers/{router}',
        request_field=u'routerResource',
        request_type_name=u'ComputeRoutersUpdateRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

  class RoutesService(base_api.BaseApiService):
    """Service class for the routes resource."""

    _NAME = u'routes'

    def __init__(self, client):
      super(ComputeBeta.RoutesService, self).__init__(client)
      self._upload_configs = {
          }

    def Delete(self, request, global_params=None):
      """Deletes the specified Route resource.

      Args:
        request: (ComputeRoutesDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.routes.delete',
        ordered_params=[u'project', u'route'],
        path_params=[u'project', u'route'],
        query_params=[],
        relative_path=u'projects/{project}/global/routes/{route}',
        request_field='',
        request_type_name=u'ComputeRoutesDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified Route resource. Get a list of available routes by making a list() request.

      Args:
        request: (ComputeRoutesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Route) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.routes.get',
        ordered_params=[u'project', u'route'],
        path_params=[u'project', u'route'],
        query_params=[],
        relative_path=u'projects/{project}/global/routes/{route}',
        request_field='',
        request_type_name=u'ComputeRoutesGetRequest',
        response_type_name=u'Route',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a Route resource in the specified project using the data included in the request.

      Args:
        request: (ComputeRoutesInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.routes.insert',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/routes',
        request_field=u'route',
        request_type_name=u'ComputeRoutesInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of Route resources available to the specified project.

      Args:
        request: (ComputeRoutesListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (RouteList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.routes.list',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/global/routes',
        request_field='',
        request_type_name=u'ComputeRoutesListRequest',
        response_type_name=u'RouteList',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeRoutesTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.routes.testIamPermissions',
        ordered_params=[u'project', u'resource'],
        path_params=[u'project', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/global/routes/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeRoutesTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

  class SnapshotsService(base_api.BaseApiService):
    """Service class for the snapshots resource."""

    _NAME = u'snapshots'

    def __init__(self, client):
      super(ComputeBeta.SnapshotsService, self).__init__(client)
      self._upload_configs = {
          }

    def Delete(self, request, global_params=None):
      """Deletes the specified Snapshot resource. Keep in mind that deleting a single snapshot might not necessarily delete all the data on that snapshot. If any data on the snapshot that is marked for deletion is needed for subsequent snapshots, the data will be moved to the next corresponding snapshot.

For more information, see Deleting snaphots.

      Args:
        request: (ComputeSnapshotsDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.snapshots.delete',
        ordered_params=[u'project', u'snapshot'],
        path_params=[u'project', u'snapshot'],
        query_params=[],
        relative_path=u'projects/{project}/global/snapshots/{snapshot}',
        request_field='',
        request_type_name=u'ComputeSnapshotsDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified Snapshot resource. Get a list of available snapshots by making a list() request.

      Args:
        request: (ComputeSnapshotsGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Snapshot) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.snapshots.get',
        ordered_params=[u'project', u'snapshot'],
        path_params=[u'project', u'snapshot'],
        query_params=[],
        relative_path=u'projects/{project}/global/snapshots/{snapshot}',
        request_field='',
        request_type_name=u'ComputeSnapshotsGetRequest',
        response_type_name=u'Snapshot',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of Snapshot resources contained within the specified project.

      Args:
        request: (ComputeSnapshotsListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (SnapshotList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.snapshots.list',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/global/snapshots',
        request_field='',
        request_type_name=u'ComputeSnapshotsListRequest',
        response_type_name=u'SnapshotList',
        supports_download=False,
    )

    def SetLabels(self, request, global_params=None):
      """Sets the labels on a snapshot. To learn more about labels, read the Labeling or Tagging Resources documentation.

      Args:
        request: (ComputeSnapshotsSetLabelsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetLabels')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetLabels.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.snapshots.setLabels',
        ordered_params=[u'project', u'resource'],
        path_params=[u'project', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/global/snapshots/{resource}/setLabels',
        request_field=u'globalSetLabelsRequest',
        request_type_name=u'ComputeSnapshotsSetLabelsRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeSnapshotsTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.snapshots.testIamPermissions',
        ordered_params=[u'project', u'resource'],
        path_params=[u'project', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/global/snapshots/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeSnapshotsTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

  class SslCertificatesService(base_api.BaseApiService):
    """Service class for the sslCertificates resource."""

    _NAME = u'sslCertificates'

    def __init__(self, client):
      super(ComputeBeta.SslCertificatesService, self).__init__(client)
      self._upload_configs = {
          }

    def Delete(self, request, global_params=None):
      """Deletes the specified SslCertificate resource.

      Args:
        request: (ComputeSslCertificatesDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.sslCertificates.delete',
        ordered_params=[u'project', u'sslCertificate'],
        path_params=[u'project', u'sslCertificate'],
        query_params=[],
        relative_path=u'projects/{project}/global/sslCertificates/{sslCertificate}',
        request_field='',
        request_type_name=u'ComputeSslCertificatesDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified SslCertificate resource. Get a list of available SSL certificates by making a list() request.

      Args:
        request: (ComputeSslCertificatesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (SslCertificate) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.sslCertificates.get',
        ordered_params=[u'project', u'sslCertificate'],
        path_params=[u'project', u'sslCertificate'],
        query_params=[],
        relative_path=u'projects/{project}/global/sslCertificates/{sslCertificate}',
        request_field='',
        request_type_name=u'ComputeSslCertificatesGetRequest',
        response_type_name=u'SslCertificate',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a SslCertificate resource in the specified project using the data included in the request.

      Args:
        request: (ComputeSslCertificatesInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.sslCertificates.insert',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/sslCertificates',
        request_field=u'sslCertificate',
        request_type_name=u'ComputeSslCertificatesInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of SslCertificate resources available to the specified project.

      Args:
        request: (ComputeSslCertificatesListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (SslCertificateList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.sslCertificates.list',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/global/sslCertificates',
        request_field='',
        request_type_name=u'ComputeSslCertificatesListRequest',
        response_type_name=u'SslCertificateList',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeSslCertificatesTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.sslCertificates.testIamPermissions',
        ordered_params=[u'project', u'resource'],
        path_params=[u'project', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/global/sslCertificates/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeSslCertificatesTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

  class SubnetworksService(base_api.BaseApiService):
    """Service class for the subnetworks resource."""

    _NAME = u'subnetworks'

    def __init__(self, client):
      super(ComputeBeta.SubnetworksService, self).__init__(client)
      self._upload_configs = {
          }

    def AggregatedList(self, request, global_params=None):
      """Retrieves an aggregated list of subnetworks.

      Args:
        request: (ComputeSubnetworksAggregatedListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (SubnetworkAggregatedList) The response message.
      """
      config = self.GetMethodConfig('AggregatedList')
      return self._RunMethod(
          config, request, global_params=global_params)

    AggregatedList.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.subnetworks.aggregatedList',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/aggregated/subnetworks',
        request_field='',
        request_type_name=u'ComputeSubnetworksAggregatedListRequest',
        response_type_name=u'SubnetworkAggregatedList',
        supports_download=False,
    )

    def Delete(self, request, global_params=None):
      """Deletes the specified subnetwork.

      Args:
        request: (ComputeSubnetworksDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.subnetworks.delete',
        ordered_params=[u'project', u'region', u'subnetwork'],
        path_params=[u'project', u'region', u'subnetwork'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/subnetworks/{subnetwork}',
        request_field='',
        request_type_name=u'ComputeSubnetworksDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def ExpandIpCidrRange(self, request, global_params=None):
      """Expands the IP CIDR range of the subnetwork to a specified value.

      Args:
        request: (ComputeSubnetworksExpandIpCidrRangeRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('ExpandIpCidrRange')
      return self._RunMethod(
          config, request, global_params=global_params)

    ExpandIpCidrRange.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.subnetworks.expandIpCidrRange',
        ordered_params=[u'project', u'region', u'subnetwork'],
        path_params=[u'project', u'region', u'subnetwork'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/subnetworks/{subnetwork}/expandIpCidrRange',
        request_field=u'subnetworksExpandIpCidrRangeRequest',
        request_type_name=u'ComputeSubnetworksExpandIpCidrRangeRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified subnetwork. Get a list of available subnetworks list() request.

      Args:
        request: (ComputeSubnetworksGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Subnetwork) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.subnetworks.get',
        ordered_params=[u'project', u'region', u'subnetwork'],
        path_params=[u'project', u'region', u'subnetwork'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/subnetworks/{subnetwork}',
        request_field='',
        request_type_name=u'ComputeSubnetworksGetRequest',
        response_type_name=u'Subnetwork',
        supports_download=False,
    )

    def GetIamPolicy(self, request, global_params=None):
      """Gets the access control policy for a resource. May be empty if no such policy or resource exists.

      Args:
        request: (ComputeSubnetworksGetIamPolicyRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Policy) The response message.
      """
      config = self.GetMethodConfig('GetIamPolicy')
      return self._RunMethod(
          config, request, global_params=global_params)

    GetIamPolicy.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.subnetworks.getIamPolicy',
        ordered_params=[u'project', u'region', u'resource'],
        path_params=[u'project', u'region', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/subnetworks/{resource}/getIamPolicy',
        request_field='',
        request_type_name=u'ComputeSubnetworksGetIamPolicyRequest',
        response_type_name=u'Policy',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a subnetwork in the specified project using the data included in the request.

      Args:
        request: (ComputeSubnetworksInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.subnetworks.insert',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/subnetworks',
        request_field=u'subnetwork',
        request_type_name=u'ComputeSubnetworksInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves a list of subnetworks available to the specified project.

      Args:
        request: (ComputeSubnetworksListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (SubnetworkList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.subnetworks.list',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/regions/{region}/subnetworks',
        request_field='',
        request_type_name=u'ComputeSubnetworksListRequest',
        response_type_name=u'SubnetworkList',
        supports_download=False,
    )

    def SetIamPolicy(self, request, global_params=None):
      """Sets the access control policy on the specified resource. Replaces any existing policy.

      Args:
        request: (ComputeSubnetworksSetIamPolicyRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Policy) The response message.
      """
      config = self.GetMethodConfig('SetIamPolicy')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetIamPolicy.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.subnetworks.setIamPolicy',
        ordered_params=[u'project', u'region', u'resource'],
        path_params=[u'project', u'region', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/subnetworks/{resource}/setIamPolicy',
        request_field=u'policy',
        request_type_name=u'ComputeSubnetworksSetIamPolicyRequest',
        response_type_name=u'Policy',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeSubnetworksTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.subnetworks.testIamPermissions',
        ordered_params=[u'project', u'region', u'resource'],
        path_params=[u'project', u'region', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/subnetworks/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeSubnetworksTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

  class TargetHttpProxiesService(base_api.BaseApiService):
    """Service class for the targetHttpProxies resource."""

    _NAME = u'targetHttpProxies'

    def __init__(self, client):
      super(ComputeBeta.TargetHttpProxiesService, self).__init__(client)
      self._upload_configs = {
          }

    def Delete(self, request, global_params=None):
      """Deletes the specified TargetHttpProxy resource.

      Args:
        request: (ComputeTargetHttpProxiesDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.targetHttpProxies.delete',
        ordered_params=[u'project', u'targetHttpProxy'],
        path_params=[u'project', u'targetHttpProxy'],
        query_params=[],
        relative_path=u'projects/{project}/global/targetHttpProxies/{targetHttpProxy}',
        request_field='',
        request_type_name=u'ComputeTargetHttpProxiesDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified TargetHttpProxy resource. Get a list of available target HTTP proxies by making a list() request.

      Args:
        request: (ComputeTargetHttpProxiesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TargetHttpProxy) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.targetHttpProxies.get',
        ordered_params=[u'project', u'targetHttpProxy'],
        path_params=[u'project', u'targetHttpProxy'],
        query_params=[],
        relative_path=u'projects/{project}/global/targetHttpProxies/{targetHttpProxy}',
        request_field='',
        request_type_name=u'ComputeTargetHttpProxiesGetRequest',
        response_type_name=u'TargetHttpProxy',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a TargetHttpProxy resource in the specified project using the data included in the request.

      Args:
        request: (ComputeTargetHttpProxiesInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetHttpProxies.insert',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/targetHttpProxies',
        request_field=u'targetHttpProxy',
        request_type_name=u'ComputeTargetHttpProxiesInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of TargetHttpProxy resources available to the specified project.

      Args:
        request: (ComputeTargetHttpProxiesListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TargetHttpProxyList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.targetHttpProxies.list',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/global/targetHttpProxies',
        request_field='',
        request_type_name=u'ComputeTargetHttpProxiesListRequest',
        response_type_name=u'TargetHttpProxyList',
        supports_download=False,
    )

    def SetUrlMap(self, request, global_params=None):
      """Changes the URL map for TargetHttpProxy.

      Args:
        request: (ComputeTargetHttpProxiesSetUrlMapRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetUrlMap')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetUrlMap.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetHttpProxies.setUrlMap',
        ordered_params=[u'project', u'targetHttpProxy'],
        path_params=[u'project', u'targetHttpProxy'],
        query_params=[],
        relative_path=u'projects/{project}/targetHttpProxies/{targetHttpProxy}/setUrlMap',
        request_field=u'urlMapReference',
        request_type_name=u'ComputeTargetHttpProxiesSetUrlMapRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeTargetHttpProxiesTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetHttpProxies.testIamPermissions',
        ordered_params=[u'project', u'resource'],
        path_params=[u'project', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/global/targetHttpProxies/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeTargetHttpProxiesTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

  class TargetHttpsProxiesService(base_api.BaseApiService):
    """Service class for the targetHttpsProxies resource."""

    _NAME = u'targetHttpsProxies'

    def __init__(self, client):
      super(ComputeBeta.TargetHttpsProxiesService, self).__init__(client)
      self._upload_configs = {
          }

    def Delete(self, request, global_params=None):
      """Deletes the specified TargetHttpsProxy resource.

      Args:
        request: (ComputeTargetHttpsProxiesDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.targetHttpsProxies.delete',
        ordered_params=[u'project', u'targetHttpsProxy'],
        path_params=[u'project', u'targetHttpsProxy'],
        query_params=[],
        relative_path=u'projects/{project}/global/targetHttpsProxies/{targetHttpsProxy}',
        request_field='',
        request_type_name=u'ComputeTargetHttpsProxiesDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified TargetHttpsProxy resource. Get a list of available target HTTPS proxies by making a list() request.

      Args:
        request: (ComputeTargetHttpsProxiesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TargetHttpsProxy) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.targetHttpsProxies.get',
        ordered_params=[u'project', u'targetHttpsProxy'],
        path_params=[u'project', u'targetHttpsProxy'],
        query_params=[],
        relative_path=u'projects/{project}/global/targetHttpsProxies/{targetHttpsProxy}',
        request_field='',
        request_type_name=u'ComputeTargetHttpsProxiesGetRequest',
        response_type_name=u'TargetHttpsProxy',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a TargetHttpsProxy resource in the specified project using the data included in the request.

      Args:
        request: (ComputeTargetHttpsProxiesInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetHttpsProxies.insert',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/targetHttpsProxies',
        request_field=u'targetHttpsProxy',
        request_type_name=u'ComputeTargetHttpsProxiesInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of TargetHttpsProxy resources available to the specified project.

      Args:
        request: (ComputeTargetHttpsProxiesListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TargetHttpsProxyList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.targetHttpsProxies.list',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/global/targetHttpsProxies',
        request_field='',
        request_type_name=u'ComputeTargetHttpsProxiesListRequest',
        response_type_name=u'TargetHttpsProxyList',
        supports_download=False,
    )

    def SetSslCertificates(self, request, global_params=None):
      """Replaces SslCertificates for TargetHttpsProxy.

      Args:
        request: (ComputeTargetHttpsProxiesSetSslCertificatesRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetSslCertificates')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetSslCertificates.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetHttpsProxies.setSslCertificates',
        ordered_params=[u'project', u'targetHttpsProxy'],
        path_params=[u'project', u'targetHttpsProxy'],
        query_params=[],
        relative_path=u'projects/{project}/targetHttpsProxies/{targetHttpsProxy}/setSslCertificates',
        request_field=u'targetHttpsProxiesSetSslCertificatesRequest',
        request_type_name=u'ComputeTargetHttpsProxiesSetSslCertificatesRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetUrlMap(self, request, global_params=None):
      """Changes the URL map for TargetHttpsProxy.

      Args:
        request: (ComputeTargetHttpsProxiesSetUrlMapRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetUrlMap')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetUrlMap.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetHttpsProxies.setUrlMap',
        ordered_params=[u'project', u'targetHttpsProxy'],
        path_params=[u'project', u'targetHttpsProxy'],
        query_params=[],
        relative_path=u'projects/{project}/targetHttpsProxies/{targetHttpsProxy}/setUrlMap',
        request_field=u'urlMapReference',
        request_type_name=u'ComputeTargetHttpsProxiesSetUrlMapRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeTargetHttpsProxiesTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetHttpsProxies.testIamPermissions',
        ordered_params=[u'project', u'resource'],
        path_params=[u'project', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/global/targetHttpsProxies/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeTargetHttpsProxiesTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

  class TargetInstancesService(base_api.BaseApiService):
    """Service class for the targetInstances resource."""

    _NAME = u'targetInstances'

    def __init__(self, client):
      super(ComputeBeta.TargetInstancesService, self).__init__(client)
      self._upload_configs = {
          }

    def AggregatedList(self, request, global_params=None):
      """Retrieves an aggregated list of target instances.

      Args:
        request: (ComputeTargetInstancesAggregatedListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TargetInstanceAggregatedList) The response message.
      """
      config = self.GetMethodConfig('AggregatedList')
      return self._RunMethod(
          config, request, global_params=global_params)

    AggregatedList.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.targetInstances.aggregatedList',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/aggregated/targetInstances',
        request_field='',
        request_type_name=u'ComputeTargetInstancesAggregatedListRequest',
        response_type_name=u'TargetInstanceAggregatedList',
        supports_download=False,
    )

    def Delete(self, request, global_params=None):
      """Deletes the specified TargetInstance resource.

      Args:
        request: (ComputeTargetInstancesDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.targetInstances.delete',
        ordered_params=[u'project', u'zone', u'targetInstance'],
        path_params=[u'project', u'targetInstance', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/targetInstances/{targetInstance}',
        request_field='',
        request_type_name=u'ComputeTargetInstancesDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified TargetInstance resource. Get a list of available target instances by making a list() request.

      Args:
        request: (ComputeTargetInstancesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TargetInstance) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.targetInstances.get',
        ordered_params=[u'project', u'zone', u'targetInstance'],
        path_params=[u'project', u'targetInstance', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/targetInstances/{targetInstance}',
        request_field='',
        request_type_name=u'ComputeTargetInstancesGetRequest',
        response_type_name=u'TargetInstance',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a TargetInstance resource in the specified project and zone using the data included in the request.

      Args:
        request: (ComputeTargetInstancesInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetInstances.insert',
        ordered_params=[u'project', u'zone'],
        path_params=[u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/targetInstances',
        request_field=u'targetInstance',
        request_type_name=u'ComputeTargetInstancesInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves a list of TargetInstance resources available to the specified project and zone.

      Args:
        request: (ComputeTargetInstancesListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TargetInstanceList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.targetInstances.list',
        ordered_params=[u'project', u'zone'],
        path_params=[u'project', u'zone'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/zones/{zone}/targetInstances',
        request_field='',
        request_type_name=u'ComputeTargetInstancesListRequest',
        response_type_name=u'TargetInstanceList',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeTargetInstancesTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetInstances.testIamPermissions',
        ordered_params=[u'project', u'zone', u'resource'],
        path_params=[u'project', u'resource', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/targetInstances/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeTargetInstancesTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

  class TargetPoolsService(base_api.BaseApiService):
    """Service class for the targetPools resource."""

    _NAME = u'targetPools'

    def __init__(self, client):
      super(ComputeBeta.TargetPoolsService, self).__init__(client)
      self._upload_configs = {
          }

    def AddHealthCheck(self, request, global_params=None):
      """Adds health check URLs to a target pool.

      Args:
        request: (ComputeTargetPoolsAddHealthCheckRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('AddHealthCheck')
      return self._RunMethod(
          config, request, global_params=global_params)

    AddHealthCheck.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetPools.addHealthCheck',
        ordered_params=[u'project', u'region', u'targetPool'],
        path_params=[u'project', u'region', u'targetPool'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/targetPools/{targetPool}/addHealthCheck',
        request_field=u'targetPoolsAddHealthCheckRequest',
        request_type_name=u'ComputeTargetPoolsAddHealthCheckRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def AddInstance(self, request, global_params=None):
      """Adds an instance to a target pool.

      Args:
        request: (ComputeTargetPoolsAddInstanceRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('AddInstance')
      return self._RunMethod(
          config, request, global_params=global_params)

    AddInstance.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetPools.addInstance',
        ordered_params=[u'project', u'region', u'targetPool'],
        path_params=[u'project', u'region', u'targetPool'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/targetPools/{targetPool}/addInstance',
        request_field=u'targetPoolsAddInstanceRequest',
        request_type_name=u'ComputeTargetPoolsAddInstanceRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def AggregatedList(self, request, global_params=None):
      """Retrieves an aggregated list of target pools.

      Args:
        request: (ComputeTargetPoolsAggregatedListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TargetPoolAggregatedList) The response message.
      """
      config = self.GetMethodConfig('AggregatedList')
      return self._RunMethod(
          config, request, global_params=global_params)

    AggregatedList.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.targetPools.aggregatedList',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/aggregated/targetPools',
        request_field='',
        request_type_name=u'ComputeTargetPoolsAggregatedListRequest',
        response_type_name=u'TargetPoolAggregatedList',
        supports_download=False,
    )

    def Delete(self, request, global_params=None):
      """Deletes the specified target pool.

      Args:
        request: (ComputeTargetPoolsDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.targetPools.delete',
        ordered_params=[u'project', u'region', u'targetPool'],
        path_params=[u'project', u'region', u'targetPool'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/targetPools/{targetPool}',
        request_field='',
        request_type_name=u'ComputeTargetPoolsDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified target pool. Get a list of available target pools by making a list() request.

      Args:
        request: (ComputeTargetPoolsGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TargetPool) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.targetPools.get',
        ordered_params=[u'project', u'region', u'targetPool'],
        path_params=[u'project', u'region', u'targetPool'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/targetPools/{targetPool}',
        request_field='',
        request_type_name=u'ComputeTargetPoolsGetRequest',
        response_type_name=u'TargetPool',
        supports_download=False,
    )

    def GetHealth(self, request, global_params=None):
      """Gets the most recent health check results for each IP for the instance that is referenced by the given target pool.

      Args:
        request: (ComputeTargetPoolsGetHealthRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TargetPoolInstanceHealth) The response message.
      """
      config = self.GetMethodConfig('GetHealth')
      return self._RunMethod(
          config, request, global_params=global_params)

    GetHealth.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetPools.getHealth',
        ordered_params=[u'project', u'region', u'targetPool'],
        path_params=[u'project', u'region', u'targetPool'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/targetPools/{targetPool}/getHealth',
        request_field=u'instanceReference',
        request_type_name=u'ComputeTargetPoolsGetHealthRequest',
        response_type_name=u'TargetPoolInstanceHealth',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a target pool in the specified project and region using the data included in the request.

      Args:
        request: (ComputeTargetPoolsInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetPools.insert',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/targetPools',
        request_field=u'targetPool',
        request_type_name=u'ComputeTargetPoolsInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves a list of target pools available to the specified project and region.

      Args:
        request: (ComputeTargetPoolsListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TargetPoolList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.targetPools.list',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/regions/{region}/targetPools',
        request_field='',
        request_type_name=u'ComputeTargetPoolsListRequest',
        response_type_name=u'TargetPoolList',
        supports_download=False,
    )

    def RemoveHealthCheck(self, request, global_params=None):
      """Removes health check URL from a target pool.

      Args:
        request: (ComputeTargetPoolsRemoveHealthCheckRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('RemoveHealthCheck')
      return self._RunMethod(
          config, request, global_params=global_params)

    RemoveHealthCheck.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetPools.removeHealthCheck',
        ordered_params=[u'project', u'region', u'targetPool'],
        path_params=[u'project', u'region', u'targetPool'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/targetPools/{targetPool}/removeHealthCheck',
        request_field=u'targetPoolsRemoveHealthCheckRequest',
        request_type_name=u'ComputeTargetPoolsRemoveHealthCheckRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def RemoveInstance(self, request, global_params=None):
      """Removes instance URL from a target pool.

      Args:
        request: (ComputeTargetPoolsRemoveInstanceRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('RemoveInstance')
      return self._RunMethod(
          config, request, global_params=global_params)

    RemoveInstance.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetPools.removeInstance',
        ordered_params=[u'project', u'region', u'targetPool'],
        path_params=[u'project', u'region', u'targetPool'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/targetPools/{targetPool}/removeInstance',
        request_field=u'targetPoolsRemoveInstanceRequest',
        request_type_name=u'ComputeTargetPoolsRemoveInstanceRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetBackup(self, request, global_params=None):
      """Changes a backup target pool's configurations.

      Args:
        request: (ComputeTargetPoolsSetBackupRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetBackup')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetBackup.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetPools.setBackup',
        ordered_params=[u'project', u'region', u'targetPool'],
        path_params=[u'project', u'region', u'targetPool'],
        query_params=[u'failoverRatio'],
        relative_path=u'projects/{project}/regions/{region}/targetPools/{targetPool}/setBackup',
        request_field=u'targetReference',
        request_type_name=u'ComputeTargetPoolsSetBackupRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeTargetPoolsTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetPools.testIamPermissions',
        ordered_params=[u'project', u'region', u'resource'],
        path_params=[u'project', u'region', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/targetPools/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeTargetPoolsTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

  class TargetSslProxiesService(base_api.BaseApiService):
    """Service class for the targetSslProxies resource."""

    _NAME = u'targetSslProxies'

    def __init__(self, client):
      super(ComputeBeta.TargetSslProxiesService, self).__init__(client)
      self._upload_configs = {
          }

    def Delete(self, request, global_params=None):
      """Deletes the specified TargetSslProxy resource.

      Args:
        request: (ComputeTargetSslProxiesDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.targetSslProxies.delete',
        ordered_params=[u'project', u'targetSslProxy'],
        path_params=[u'project', u'targetSslProxy'],
        query_params=[],
        relative_path=u'projects/{project}/global/targetSslProxies/{targetSslProxy}',
        request_field='',
        request_type_name=u'ComputeTargetSslProxiesDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified TargetSslProxy resource. Get a list of available target SSL proxies by making a list() request.

      Args:
        request: (ComputeTargetSslProxiesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TargetSslProxy) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.targetSslProxies.get',
        ordered_params=[u'project', u'targetSslProxy'],
        path_params=[u'project', u'targetSslProxy'],
        query_params=[],
        relative_path=u'projects/{project}/global/targetSslProxies/{targetSslProxy}',
        request_field='',
        request_type_name=u'ComputeTargetSslProxiesGetRequest',
        response_type_name=u'TargetSslProxy',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a TargetSslProxy resource in the specified project using the data included in the request.

      Args:
        request: (ComputeTargetSslProxiesInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetSslProxies.insert',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/targetSslProxies',
        request_field=u'targetSslProxy',
        request_type_name=u'ComputeTargetSslProxiesInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of TargetSslProxy resources available to the specified project.

      Args:
        request: (ComputeTargetSslProxiesListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TargetSslProxyList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.targetSslProxies.list',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/global/targetSslProxies',
        request_field='',
        request_type_name=u'ComputeTargetSslProxiesListRequest',
        response_type_name=u'TargetSslProxyList',
        supports_download=False,
    )

    def SetBackendService(self, request, global_params=None):
      """Changes the BackendService for TargetSslProxy.

      Args:
        request: (ComputeTargetSslProxiesSetBackendServiceRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetBackendService')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetBackendService.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetSslProxies.setBackendService',
        ordered_params=[u'project', u'targetSslProxy'],
        path_params=[u'project', u'targetSslProxy'],
        query_params=[],
        relative_path=u'projects/{project}/global/targetSslProxies/{targetSslProxy}/setBackendService',
        request_field=u'targetSslProxiesSetBackendServiceRequest',
        request_type_name=u'ComputeTargetSslProxiesSetBackendServiceRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetProxyHeader(self, request, global_params=None):
      """Changes the ProxyHeaderType for TargetSslProxy.

      Args:
        request: (ComputeTargetSslProxiesSetProxyHeaderRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetProxyHeader')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetProxyHeader.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetSslProxies.setProxyHeader',
        ordered_params=[u'project', u'targetSslProxy'],
        path_params=[u'project', u'targetSslProxy'],
        query_params=[],
        relative_path=u'projects/{project}/global/targetSslProxies/{targetSslProxy}/setProxyHeader',
        request_field=u'targetSslProxiesSetProxyHeaderRequest',
        request_type_name=u'ComputeTargetSslProxiesSetProxyHeaderRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetSslCertificates(self, request, global_params=None):
      """Changes SslCertificates for TargetSslProxy.

      Args:
        request: (ComputeTargetSslProxiesSetSslCertificatesRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetSslCertificates')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetSslCertificates.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetSslProxies.setSslCertificates',
        ordered_params=[u'project', u'targetSslProxy'],
        path_params=[u'project', u'targetSslProxy'],
        query_params=[],
        relative_path=u'projects/{project}/global/targetSslProxies/{targetSslProxy}/setSslCertificates',
        request_field=u'targetSslProxiesSetSslCertificatesRequest',
        request_type_name=u'ComputeTargetSslProxiesSetSslCertificatesRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeTargetSslProxiesTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetSslProxies.testIamPermissions',
        ordered_params=[u'project', u'resource'],
        path_params=[u'project', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/global/targetSslProxies/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeTargetSslProxiesTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

  class TargetTcpProxiesService(base_api.BaseApiService):
    """Service class for the targetTcpProxies resource."""

    _NAME = u'targetTcpProxies'

    def __init__(self, client):
      super(ComputeBeta.TargetTcpProxiesService, self).__init__(client)
      self._upload_configs = {
          }

    def Delete(self, request, global_params=None):
      """Deletes the specified TargetTcpProxy resource.

      Args:
        request: (ComputeTargetTcpProxiesDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.targetTcpProxies.delete',
        ordered_params=[u'project', u'targetTcpProxy'],
        path_params=[u'project', u'targetTcpProxy'],
        query_params=[],
        relative_path=u'projects/{project}/global/targetTcpProxies/{targetTcpProxy}',
        request_field='',
        request_type_name=u'ComputeTargetTcpProxiesDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified TargetTcpProxy resource. Get a list of available target TCP proxies by making a list() request.

      Args:
        request: (ComputeTargetTcpProxiesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TargetTcpProxy) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.targetTcpProxies.get',
        ordered_params=[u'project', u'targetTcpProxy'],
        path_params=[u'project', u'targetTcpProxy'],
        query_params=[],
        relative_path=u'projects/{project}/global/targetTcpProxies/{targetTcpProxy}',
        request_field='',
        request_type_name=u'ComputeTargetTcpProxiesGetRequest',
        response_type_name=u'TargetTcpProxy',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a TargetTcpProxy resource in the specified project using the data included in the request.

      Args:
        request: (ComputeTargetTcpProxiesInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetTcpProxies.insert',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/targetTcpProxies',
        request_field=u'targetTcpProxy',
        request_type_name=u'ComputeTargetTcpProxiesInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of TargetTcpProxy resources available to the specified project.

      Args:
        request: (ComputeTargetTcpProxiesListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TargetTcpProxyList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.targetTcpProxies.list',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/global/targetTcpProxies',
        request_field='',
        request_type_name=u'ComputeTargetTcpProxiesListRequest',
        response_type_name=u'TargetTcpProxyList',
        supports_download=False,
    )

    def SetBackendService(self, request, global_params=None):
      """Changes the BackendService for TargetTcpProxy.

      Args:
        request: (ComputeTargetTcpProxiesSetBackendServiceRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetBackendService')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetBackendService.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetTcpProxies.setBackendService',
        ordered_params=[u'project', u'targetTcpProxy'],
        path_params=[u'project', u'targetTcpProxy'],
        query_params=[],
        relative_path=u'projects/{project}/global/targetTcpProxies/{targetTcpProxy}/setBackendService',
        request_field=u'targetTcpProxiesSetBackendServiceRequest',
        request_type_name=u'ComputeTargetTcpProxiesSetBackendServiceRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def SetProxyHeader(self, request, global_params=None):
      """Changes the ProxyHeaderType for TargetTcpProxy.

      Args:
        request: (ComputeTargetTcpProxiesSetProxyHeaderRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('SetProxyHeader')
      return self._RunMethod(
          config, request, global_params=global_params)

    SetProxyHeader.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetTcpProxies.setProxyHeader',
        ordered_params=[u'project', u'targetTcpProxy'],
        path_params=[u'project', u'targetTcpProxy'],
        query_params=[],
        relative_path=u'projects/{project}/global/targetTcpProxies/{targetTcpProxy}/setProxyHeader',
        request_field=u'targetTcpProxiesSetProxyHeaderRequest',
        request_type_name=u'ComputeTargetTcpProxiesSetProxyHeaderRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

  class TargetVpnGatewaysService(base_api.BaseApiService):
    """Service class for the targetVpnGateways resource."""

    _NAME = u'targetVpnGateways'

    def __init__(self, client):
      super(ComputeBeta.TargetVpnGatewaysService, self).__init__(client)
      self._upload_configs = {
          }

    def AggregatedList(self, request, global_params=None):
      """Retrieves an aggregated list of target VPN gateways.

      Args:
        request: (ComputeTargetVpnGatewaysAggregatedListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TargetVpnGatewayAggregatedList) The response message.
      """
      config = self.GetMethodConfig('AggregatedList')
      return self._RunMethod(
          config, request, global_params=global_params)

    AggregatedList.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.targetVpnGateways.aggregatedList',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/aggregated/targetVpnGateways',
        request_field='',
        request_type_name=u'ComputeTargetVpnGatewaysAggregatedListRequest',
        response_type_name=u'TargetVpnGatewayAggregatedList',
        supports_download=False,
    )

    def Delete(self, request, global_params=None):
      """Deletes the specified target VPN gateway.

      Args:
        request: (ComputeTargetVpnGatewaysDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.targetVpnGateways.delete',
        ordered_params=[u'project', u'region', u'targetVpnGateway'],
        path_params=[u'project', u'region', u'targetVpnGateway'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/targetVpnGateways/{targetVpnGateway}',
        request_field='',
        request_type_name=u'ComputeTargetVpnGatewaysDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified target VPN gateway. Get a list of available target VPN gateways by making a list() request.

      Args:
        request: (ComputeTargetVpnGatewaysGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TargetVpnGateway) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.targetVpnGateways.get',
        ordered_params=[u'project', u'region', u'targetVpnGateway'],
        path_params=[u'project', u'region', u'targetVpnGateway'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/targetVpnGateways/{targetVpnGateway}',
        request_field='',
        request_type_name=u'ComputeTargetVpnGatewaysGetRequest',
        response_type_name=u'TargetVpnGateway',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a target VPN gateway in the specified project and region using the data included in the request.

      Args:
        request: (ComputeTargetVpnGatewaysInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetVpnGateways.insert',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/targetVpnGateways',
        request_field=u'targetVpnGateway',
        request_type_name=u'ComputeTargetVpnGatewaysInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves a list of target VPN gateways available to the specified project and region.

      Args:
        request: (ComputeTargetVpnGatewaysListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TargetVpnGatewayList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.targetVpnGateways.list',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/regions/{region}/targetVpnGateways',
        request_field='',
        request_type_name=u'ComputeTargetVpnGatewaysListRequest',
        response_type_name=u'TargetVpnGatewayList',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeTargetVpnGatewaysTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.targetVpnGateways.testIamPermissions',
        ordered_params=[u'project', u'region', u'resource'],
        path_params=[u'project', u'region', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/targetVpnGateways/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeTargetVpnGatewaysTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

  class UrlMapsService(base_api.BaseApiService):
    """Service class for the urlMaps resource."""

    _NAME = u'urlMaps'

    def __init__(self, client):
      super(ComputeBeta.UrlMapsService, self).__init__(client)
      self._upload_configs = {
          }

    def Delete(self, request, global_params=None):
      """Deletes the specified UrlMap resource.

      Args:
        request: (ComputeUrlMapsDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.urlMaps.delete',
        ordered_params=[u'project', u'urlMap'],
        path_params=[u'project', u'urlMap'],
        query_params=[],
        relative_path=u'projects/{project}/global/urlMaps/{urlMap}',
        request_field='',
        request_type_name=u'ComputeUrlMapsDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified UrlMap resource. Get a list of available URL maps by making a list() request.

      Args:
        request: (ComputeUrlMapsGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (UrlMap) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.urlMaps.get',
        ordered_params=[u'project', u'urlMap'],
        path_params=[u'project', u'urlMap'],
        query_params=[],
        relative_path=u'projects/{project}/global/urlMaps/{urlMap}',
        request_field='',
        request_type_name=u'ComputeUrlMapsGetRequest',
        response_type_name=u'UrlMap',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a UrlMap resource in the specified project using the data included in the request.

      Args:
        request: (ComputeUrlMapsInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.urlMaps.insert',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[],
        relative_path=u'projects/{project}/global/urlMaps',
        request_field=u'urlMap',
        request_type_name=u'ComputeUrlMapsInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def InvalidateCache(self, request, global_params=None):
      """Initiates a cache invalidation operation, invalidating the specified path, scoped to the specified UrlMap.

      Args:
        request: (ComputeUrlMapsInvalidateCacheRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('InvalidateCache')
      return self._RunMethod(
          config, request, global_params=global_params)

    InvalidateCache.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.urlMaps.invalidateCache',
        ordered_params=[u'project', u'urlMap'],
        path_params=[u'project', u'urlMap'],
        query_params=[],
        relative_path=u'projects/{project}/global/urlMaps/{urlMap}/invalidateCache',
        request_field=u'cacheInvalidationRule',
        request_type_name=u'ComputeUrlMapsInvalidateCacheRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of UrlMap resources available to the specified project.

      Args:
        request: (ComputeUrlMapsListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (UrlMapList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.urlMaps.list',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/global/urlMaps',
        request_field='',
        request_type_name=u'ComputeUrlMapsListRequest',
        response_type_name=u'UrlMapList',
        supports_download=False,
    )

    def Patch(self, request, global_params=None):
      """Updates the specified UrlMap resource with the data included in the request. This method supports patch semantics.

      Args:
        request: (ComputeUrlMapsPatchRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Patch')
      return self._RunMethod(
          config, request, global_params=global_params)

    Patch.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PATCH',
        method_id=u'compute.urlMaps.patch',
        ordered_params=[u'project', u'urlMap'],
        path_params=[u'project', u'urlMap'],
        query_params=[],
        relative_path=u'projects/{project}/global/urlMaps/{urlMap}',
        request_field=u'urlMapResource',
        request_type_name=u'ComputeUrlMapsPatchRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeUrlMapsTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.urlMaps.testIamPermissions',
        ordered_params=[u'project', u'resource'],
        path_params=[u'project', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/global/urlMaps/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeUrlMapsTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

    def Update(self, request, global_params=None):
      """Updates the specified UrlMap resource with the data included in the request.

      Args:
        request: (ComputeUrlMapsUpdateRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Update')
      return self._RunMethod(
          config, request, global_params=global_params)

    Update.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'PUT',
        method_id=u'compute.urlMaps.update',
        ordered_params=[u'project', u'urlMap'],
        path_params=[u'project', u'urlMap'],
        query_params=[],
        relative_path=u'projects/{project}/global/urlMaps/{urlMap}',
        request_field=u'urlMapResource',
        request_type_name=u'ComputeUrlMapsUpdateRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Validate(self, request, global_params=None):
      """Runs static validation for the UrlMap. In particular, the tests of the provided UrlMap will be run. Calling this method does NOT create the UrlMap.

      Args:
        request: (ComputeUrlMapsValidateRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (UrlMapsValidateResponse) The response message.
      """
      config = self.GetMethodConfig('Validate')
      return self._RunMethod(
          config, request, global_params=global_params)

    Validate.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.urlMaps.validate',
        ordered_params=[u'project', u'urlMap'],
        path_params=[u'project', u'urlMap'],
        query_params=[],
        relative_path=u'projects/{project}/global/urlMaps/{urlMap}/validate',
        request_field=u'urlMapsValidateRequest',
        request_type_name=u'ComputeUrlMapsValidateRequest',
        response_type_name=u'UrlMapsValidateResponse',
        supports_download=False,
    )

  class VpnTunnelsService(base_api.BaseApiService):
    """Service class for the vpnTunnels resource."""

    _NAME = u'vpnTunnels'

    def __init__(self, client):
      super(ComputeBeta.VpnTunnelsService, self).__init__(client)
      self._upload_configs = {
          }

    def AggregatedList(self, request, global_params=None):
      """Retrieves an aggregated list of VPN tunnels.

      Args:
        request: (ComputeVpnTunnelsAggregatedListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (VpnTunnelAggregatedList) The response message.
      """
      config = self.GetMethodConfig('AggregatedList')
      return self._RunMethod(
          config, request, global_params=global_params)

    AggregatedList.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.vpnTunnels.aggregatedList',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/aggregated/vpnTunnels',
        request_field='',
        request_type_name=u'ComputeVpnTunnelsAggregatedListRequest',
        response_type_name=u'VpnTunnelAggregatedList',
        supports_download=False,
    )

    def Delete(self, request, global_params=None):
      """Deletes the specified VpnTunnel resource.

      Args:
        request: (ComputeVpnTunnelsDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.vpnTunnels.delete',
        ordered_params=[u'project', u'region', u'vpnTunnel'],
        path_params=[u'project', u'region', u'vpnTunnel'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/vpnTunnels/{vpnTunnel}',
        request_field='',
        request_type_name=u'ComputeVpnTunnelsDeleteRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Returns the specified VpnTunnel resource. Get a list of available VPN tunnels by making a list() request.

      Args:
        request: (ComputeVpnTunnelsGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (VpnTunnel) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.vpnTunnels.get',
        ordered_params=[u'project', u'region', u'vpnTunnel'],
        path_params=[u'project', u'region', u'vpnTunnel'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/vpnTunnels/{vpnTunnel}',
        request_field='',
        request_type_name=u'ComputeVpnTunnelsGetRequest',
        response_type_name=u'VpnTunnel',
        supports_download=False,
    )

    def Insert(self, request, global_params=None):
      """Creates a VpnTunnel resource in the specified project and region using the data included in the request.

      Args:
        request: (ComputeVpnTunnelsInsertRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Insert')
      return self._RunMethod(
          config, request, global_params=global_params)

    Insert.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.vpnTunnels.insert',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/vpnTunnels',
        request_field=u'vpnTunnel',
        request_type_name=u'ComputeVpnTunnelsInsertRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves a list of VpnTunnel resources contained in the specified project and region.

      Args:
        request: (ComputeVpnTunnelsListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (VpnTunnelList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.vpnTunnels.list',
        ordered_params=[u'project', u'region'],
        path_params=[u'project', u'region'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/regions/{region}/vpnTunnels',
        request_field='',
        request_type_name=u'ComputeVpnTunnelsListRequest',
        response_type_name=u'VpnTunnelList',
        supports_download=False,
    )

    def TestIamPermissions(self, request, global_params=None):
      """Returns permissions that a caller has on the specified resource.

      Args:
        request: (ComputeVpnTunnelsTestIamPermissionsRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestPermissionsResponse) The response message.
      """
      config = self.GetMethodConfig('TestIamPermissions')
      return self._RunMethod(
          config, request, global_params=global_params)

    TestIamPermissions.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'POST',
        method_id=u'compute.vpnTunnels.testIamPermissions',
        ordered_params=[u'project', u'region', u'resource'],
        path_params=[u'project', u'region', u'resource'],
        query_params=[],
        relative_path=u'projects/{project}/regions/{region}/vpnTunnels/{resource}/testIamPermissions',
        request_field=u'testPermissionsRequest',
        request_type_name=u'ComputeVpnTunnelsTestIamPermissionsRequest',
        response_type_name=u'TestPermissionsResponse',
        supports_download=False,
    )

  class ZoneOperationsService(base_api.BaseApiService):
    """Service class for the zoneOperations resource."""

    _NAME = u'zoneOperations'

    def __init__(self, client):
      super(ComputeBeta.ZoneOperationsService, self).__init__(client)
      self._upload_configs = {
          }

    def Delete(self, request, global_params=None):
      """Deletes the specified zone-specific Operations resource.

      Args:
        request: (ComputeZoneOperationsDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (ComputeZoneOperationsDeleteResponse) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    Delete.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'DELETE',
        method_id=u'compute.zoneOperations.delete',
        ordered_params=[u'project', u'zone', u'operation'],
        path_params=[u'operation', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/operations/{operation}',
        request_field='',
        request_type_name=u'ComputeZoneOperationsDeleteRequest',
        response_type_name=u'ComputeZoneOperationsDeleteResponse',
        supports_download=False,
    )

    def Get(self, request, global_params=None):
      """Retrieves the specified zone-specific Operations resource.

      Args:
        request: (ComputeZoneOperationsGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Operation) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.zoneOperations.get',
        ordered_params=[u'project', u'zone', u'operation'],
        path_params=[u'operation', u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}/operations/{operation}',
        request_field='',
        request_type_name=u'ComputeZoneOperationsGetRequest',
        response_type_name=u'Operation',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves a list of Operation resources contained within the specified zone.

      Args:
        request: (ComputeZoneOperationsListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (OperationList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.zoneOperations.list',
        ordered_params=[u'project', u'zone'],
        path_params=[u'project', u'zone'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/zones/{zone}/operations',
        request_field='',
        request_type_name=u'ComputeZoneOperationsListRequest',
        response_type_name=u'OperationList',
        supports_download=False,
    )

  class ZonesService(base_api.BaseApiService):
    """Service class for the zones resource."""

    _NAME = u'zones'

    def __init__(self, client):
      super(ComputeBeta.ZonesService, self).__init__(client)
      self._upload_configs = {
          }

    def Get(self, request, global_params=None):
      """Returns the specified Zone resource. Get a list of available zones by making a list() request.

      Args:
        request: (ComputeZonesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Zone) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    Get.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.zones.get',
        ordered_params=[u'project', u'zone'],
        path_params=[u'project', u'zone'],
        query_params=[],
        relative_path=u'projects/{project}/zones/{zone}',
        request_field='',
        request_type_name=u'ComputeZonesGetRequest',
        response_type_name=u'Zone',
        supports_download=False,
    )

    def List(self, request, global_params=None):
      """Retrieves the list of Zone resources available to the specified project.

      Args:
        request: (ComputeZonesListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (ZoneList) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

    List.method_config = lambda: base_api.ApiMethodInfo(
        http_method=u'GET',
        method_id=u'compute.zones.list',
        ordered_params=[u'project'],
        path_params=[u'project'],
        query_params=[u'filter', u'maxResults', u'orderBy', u'pageToken'],
        relative_path=u'projects/{project}/zones',
        request_field='',
        request_type_name=u'ComputeZonesListRequest',
        response_type_name=u'ZoneList',
        supports_download=False,
    )
