[Summary view] [Print] [Text view]

   1  <?php
   2  /*
   3   * Copyright 2010 Google Inc.
   4   *
   5   * Licensed under the Apache License, Version 2.0 (the "License"); you may not
   6   * use this file except in compliance with the License. You may obtain a copy of
   7   * the License at
   8   *
   9   * http://www.apache.org/licenses/LICENSE-2.0
  10   *
  11   * Unless required by applicable law or agreed to in writing, software
  12   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  13   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  14   * License for the specific language governing permissions and limitations under
  15   * the License.
  16   */
  17  
  18  /**
  19   * Service definition for Replicapool (v1beta1).
  20   *
  21   * <p>
  22   * The Replica Pool API allows users to declaratively provision and manage groups of Google Compute Engine instances based on a common template.
  23   * </p>
  24   *
  25   * <p>
  26   * For more information about this service, see the API
  27   * <a href="https://developers.google.com/compute/docs/replica-pool/" target="_blank">Documentation</a>
  28   * </p>
  29   *
  30   * @author Google, Inc.
  31   */
  32  class Google_Service_Replicapool extends Google_Service
  33  {
  34    /** View and manage your data across Google Cloud Platform services. */
  35    const CLOUD_PLATFORM = "https://www.googleapis.com/auth/cloud-platform";
  36    /** View and manage your Google Cloud Platform management resources and deployment status information. */
  37    const NDEV_CLOUDMAN = "https://www.googleapis.com/auth/ndev.cloudman";
  38    /** View your Google Cloud Platform management resources and deployment status information. */
  39    const NDEV_CLOUDMAN_READONLY = "https://www.googleapis.com/auth/ndev.cloudman.readonly";
  40    /** View and manage replica pools. */
  41    const REPLICAPOOL = "https://www.googleapis.com/auth/replicapool";
  42    /** View replica pools. */
  43    const REPLICAPOOL_READONLY = "https://www.googleapis.com/auth/replicapool.readonly";
  44  
  45    public $pools;
  46    public $replicas;
  47    
  48  
  49    /**
  50     * Constructs the internal representation of the Replicapool service.
  51     *
  52     * @param Google_Client $client
  53     */
  54    public function __construct(Google_Client $client)
  55    {
  56      parent::__construct($client);
  57      $this->servicePath = 'replicapool/v1beta1/projects/';
  58      $this->version = 'v1beta1';
  59      $this->serviceName = 'replicapool';
  60  
  61      $this->pools = new Google_Service_Replicapool_Pools_Resource(
  62          $this,
  63          $this->serviceName,
  64          'pools',
  65          array(
  66            'methods' => array(
  67              'delete' => array(
  68                'path' => '{projectName}/zones/{zone}/pools/{poolName}',
  69                'httpMethod' => 'POST',
  70                'parameters' => array(
  71                  'projectName' => array(
  72                    'location' => 'path',
  73                    'type' => 'string',
  74                    'required' => true,
  75                  ),
  76                  'zone' => array(
  77                    'location' => 'path',
  78                    'type' => 'string',
  79                    'required' => true,
  80                  ),
  81                  'poolName' => array(
  82                    'location' => 'path',
  83                    'type' => 'string',
  84                    'required' => true,
  85                  ),
  86                ),
  87              ),'get' => array(
  88                'path' => '{projectName}/zones/{zone}/pools/{poolName}',
  89                'httpMethod' => 'GET',
  90                'parameters' => array(
  91                  'projectName' => array(
  92                    'location' => 'path',
  93                    'type' => 'string',
  94                    'required' => true,
  95                  ),
  96                  'zone' => array(
  97                    'location' => 'path',
  98                    'type' => 'string',
  99                    'required' => true,
 100                  ),
 101                  'poolName' => array(
 102                    'location' => 'path',
 103                    'type' => 'string',
 104                    'required' => true,
 105                  ),
 106                ),
 107              ),'insert' => array(
 108                'path' => '{projectName}/zones/{zone}/pools',
 109                'httpMethod' => 'POST',
 110                'parameters' => array(
 111                  'projectName' => array(
 112                    'location' => 'path',
 113                    'type' => 'string',
 114                    'required' => true,
 115                  ),
 116                  'zone' => array(
 117                    'location' => 'path',
 118                    'type' => 'string',
 119                    'required' => true,
 120                  ),
 121                ),
 122              ),'list' => array(
 123                'path' => '{projectName}/zones/{zone}/pools',
 124                'httpMethod' => 'GET',
 125                'parameters' => array(
 126                  'projectName' => array(
 127                    'location' => 'path',
 128                    'type' => 'string',
 129                    'required' => true,
 130                  ),
 131                  'zone' => array(
 132                    'location' => 'path',
 133                    'type' => 'string',
 134                    'required' => true,
 135                  ),
 136                  'pageToken' => array(
 137                    'location' => 'query',
 138                    'type' => 'string',
 139                  ),
 140                  'maxResults' => array(
 141                    'location' => 'query',
 142                    'type' => 'integer',
 143                  ),
 144                ),
 145              ),'resize' => array(
 146                'path' => '{projectName}/zones/{zone}/pools/{poolName}/resize',
 147                'httpMethod' => 'POST',
 148                'parameters' => array(
 149                  'projectName' => array(
 150                    'location' => 'path',
 151                    'type' => 'string',
 152                    'required' => true,
 153                  ),
 154                  'zone' => array(
 155                    'location' => 'path',
 156                    'type' => 'string',
 157                    'required' => true,
 158                  ),
 159                  'poolName' => array(
 160                    'location' => 'path',
 161                    'type' => 'string',
 162                    'required' => true,
 163                  ),
 164                  'numReplicas' => array(
 165                    'location' => 'query',
 166                    'type' => 'integer',
 167                  ),
 168                ),
 169              ),'updatetemplate' => array(
 170                'path' => '{projectName}/zones/{zone}/pools/{poolName}/updateTemplate',
 171                'httpMethod' => 'POST',
 172                'parameters' => array(
 173                  'projectName' => array(
 174                    'location' => 'path',
 175                    'type' => 'string',
 176                    'required' => true,
 177                  ),
 178                  'zone' => array(
 179                    'location' => 'path',
 180                    'type' => 'string',
 181                    'required' => true,
 182                  ),
 183                  'poolName' => array(
 184                    'location' => 'path',
 185                    'type' => 'string',
 186                    'required' => true,
 187                  ),
 188                ),
 189              ),
 190            )
 191          )
 192      );
 193      $this->replicas = new Google_Service_Replicapool_Replicas_Resource(
 194          $this,
 195          $this->serviceName,
 196          'replicas',
 197          array(
 198            'methods' => array(
 199              'delete' => array(
 200                'path' => '{projectName}/zones/{zone}/pools/{poolName}/replicas/{replicaName}',
 201                'httpMethod' => 'POST',
 202                'parameters' => array(
 203                  'projectName' => array(
 204                    'location' => 'path',
 205                    'type' => 'string',
 206                    'required' => true,
 207                  ),
 208                  'zone' => array(
 209                    'location' => 'path',
 210                    'type' => 'string',
 211                    'required' => true,
 212                  ),
 213                  'poolName' => array(
 214                    'location' => 'path',
 215                    'type' => 'string',
 216                    'required' => true,
 217                  ),
 218                  'replicaName' => array(
 219                    'location' => 'path',
 220                    'type' => 'string',
 221                    'required' => true,
 222                  ),
 223                ),
 224              ),'get' => array(
 225                'path' => '{projectName}/zones/{zone}/pools/{poolName}/replicas/{replicaName}',
 226                'httpMethod' => 'GET',
 227                'parameters' => array(
 228                  'projectName' => array(
 229                    'location' => 'path',
 230                    'type' => 'string',
 231                    'required' => true,
 232                  ),
 233                  'zone' => array(
 234                    'location' => 'path',
 235                    'type' => 'string',
 236                    'required' => true,
 237                  ),
 238                  'poolName' => array(
 239                    'location' => 'path',
 240                    'type' => 'string',
 241                    'required' => true,
 242                  ),
 243                  'replicaName' => array(
 244                    'location' => 'path',
 245                    'type' => 'string',
 246                    'required' => true,
 247                  ),
 248                ),
 249              ),'list' => array(
 250                'path' => '{projectName}/zones/{zone}/pools/{poolName}/replicas',
 251                'httpMethod' => 'GET',
 252                'parameters' => array(
 253                  'projectName' => array(
 254                    'location' => 'path',
 255                    'type' => 'string',
 256                    'required' => true,
 257                  ),
 258                  'zone' => array(
 259                    'location' => 'path',
 260                    'type' => 'string',
 261                    'required' => true,
 262                  ),
 263                  'poolName' => array(
 264                    'location' => 'path',
 265                    'type' => 'string',
 266                    'required' => true,
 267                  ),
 268                  'pageToken' => array(
 269                    'location' => 'query',
 270                    'type' => 'string',
 271                  ),
 272                  'maxResults' => array(
 273                    'location' => 'query',
 274                    'type' => 'integer',
 275                  ),
 276                ),
 277              ),'restart' => array(
 278                'path' => '{projectName}/zones/{zone}/pools/{poolName}/replicas/{replicaName}/restart',
 279                'httpMethod' => 'POST',
 280                'parameters' => array(
 281                  'projectName' => array(
 282                    'location' => 'path',
 283                    'type' => 'string',
 284                    'required' => true,
 285                  ),
 286                  'zone' => array(
 287                    'location' => 'path',
 288                    'type' => 'string',
 289                    'required' => true,
 290                  ),
 291                  'poolName' => array(
 292                    'location' => 'path',
 293                    'type' => 'string',
 294                    'required' => true,
 295                  ),
 296                  'replicaName' => array(
 297                    'location' => 'path',
 298                    'type' => 'string',
 299                    'required' => true,
 300                  ),
 301                ),
 302              ),
 303            )
 304          )
 305      );
 306    }
 307  }
 308  
 309  
 310  /**
 311   * The "pools" collection of methods.
 312   * Typical usage is:
 313   *  <code>
 314   *   $replicapoolService = new Google_Service_Replicapool(...);
 315   *   $pools = $replicapoolService->pools;
 316   *  </code>
 317   */
 318  class Google_Service_Replicapool_Pools_Resource extends Google_Service_Resource
 319  {
 320  
 321    /**
 322     * Deletes a replica pool. (pools.delete)
 323     *
 324     * @param string $projectName
 325     * The project ID for this replica pool.
 326     * @param string $zone
 327     * The zone for this replica pool.
 328     * @param string $poolName
 329     * The name of the replica pool for this request.
 330     * @param Google_PoolsDeleteRequest $postBody
 331     * @param array $optParams Optional parameters.
 332     */
 333    public function delete($projectName, $zone, $poolName, Google_Service_Replicapool_PoolsDeleteRequest $postBody, $optParams = array())
 334    {
 335      $params = array('projectName' => $projectName, 'zone' => $zone, 'poolName' => $poolName, 'postBody' => $postBody);
 336      $params = array_merge($params, $optParams);
 337      return $this->call('delete', array($params));
 338    }
 339    /**
 340     * Gets information about a single replica pool. (pools.get)
 341     *
 342     * @param string $projectName
 343     * The project ID for this replica pool.
 344     * @param string $zone
 345     * The zone for this replica pool.
 346     * @param string $poolName
 347     * The name of the replica pool for this request.
 348     * @param array $optParams Optional parameters.
 349     * @return Google_Service_Replicapool_Pool
 350     */
 351    public function get($projectName, $zone, $poolName, $optParams = array())
 352    {
 353      $params = array('projectName' => $projectName, 'zone' => $zone, 'poolName' => $poolName);
 354      $params = array_merge($params, $optParams);
 355      return $this->call('get', array($params), "Google_Service_Replicapool_Pool");
 356    }
 357    /**
 358     * Inserts a new replica pool. (pools.insert)
 359     *
 360     * @param string $projectName
 361     * The project ID for this replica pool.
 362     * @param string $zone
 363     * The zone for this replica pool.
 364     * @param Google_Pool $postBody
 365     * @param array $optParams Optional parameters.
 366     * @return Google_Service_Replicapool_Pool
 367     */
 368    public function insert($projectName, $zone, Google_Service_Replicapool_Pool $postBody, $optParams = array())
 369    {
 370      $params = array('projectName' => $projectName, 'zone' => $zone, 'postBody' => $postBody);
 371      $params = array_merge($params, $optParams);
 372      return $this->call('insert', array($params), "Google_Service_Replicapool_Pool");
 373    }
 374    /**
 375     * List all replica pools. (pools.listPools)
 376     *
 377     * @param string $projectName
 378     * The project ID for this request.
 379     * @param string $zone
 380     * The zone for this replica pool.
 381     * @param array $optParams Optional parameters.
 382     *
 383     * @opt_param string pageToken
 384     * Set this to the nextPageToken value returned by a previous list request to obtain the next page
 385      * of results from the previous list request.
 386     * @opt_param int maxResults
 387     * Maximum count of results to be returned. Acceptable values are 0 to 100, inclusive. (Default:
 388      * 50)
 389     * @return Google_Service_Replicapool_PoolsListResponse
 390     */
 391    public function listPools($projectName, $zone, $optParams = array())
 392    {
 393      $params = array('projectName' => $projectName, 'zone' => $zone);
 394      $params = array_merge($params, $optParams);
 395      return $this->call('list', array($params), "Google_Service_Replicapool_PoolsListResponse");
 396    }
 397    /**
 398     * Resize a pool. This is an asynchronous operation, and multiple overlapping
 399     * resize requests can be made. Replica Pools will use the information from the
 400     * last resize request. (pools.resize)
 401     *
 402     * @param string $projectName
 403     * The project ID for this replica pool.
 404     * @param string $zone
 405     * The zone for this replica pool.
 406     * @param string $poolName
 407     * The name of the replica pool for this request.
 408     * @param array $optParams Optional parameters.
 409     *
 410     * @opt_param int numReplicas
 411     * The desired number of replicas to resize to. If this number is larger than the existing number
 412      * of replicas, new replicas will be added. If the number is smaller, then existing replicas will
 413      * be deleted.
 414     * @return Google_Service_Replicapool_Pool
 415     */
 416    public function resize($projectName, $zone, $poolName, $optParams = array())
 417    {
 418      $params = array('projectName' => $projectName, 'zone' => $zone, 'poolName' => $poolName);
 419      $params = array_merge($params, $optParams);
 420      return $this->call('resize', array($params), "Google_Service_Replicapool_Pool");
 421    }
 422    /**
 423     * Update the template used by the pool. (pools.updatetemplate)
 424     *
 425     * @param string $projectName
 426     * The project ID for this replica pool.
 427     * @param string $zone
 428     * The zone for this replica pool.
 429     * @param string $poolName
 430     * The name of the replica pool for this request.
 431     * @param Google_Template $postBody
 432     * @param array $optParams Optional parameters.
 433     */
 434    public function updatetemplate($projectName, $zone, $poolName, Google_Service_Replicapool_Template $postBody, $optParams = array())
 435    {
 436      $params = array('projectName' => $projectName, 'zone' => $zone, 'poolName' => $poolName, 'postBody' => $postBody);
 437      $params = array_merge($params, $optParams);
 438      return $this->call('updatetemplate', array($params));
 439    }
 440  }
 441  
 442  /**
 443   * The "replicas" collection of methods.
 444   * Typical usage is:
 445   *  <code>
 446   *   $replicapoolService = new Google_Service_Replicapool(...);
 447   *   $replicas = $replicapoolService->replicas;
 448   *  </code>
 449   */
 450  class Google_Service_Replicapool_Replicas_Resource extends Google_Service_Resource
 451  {
 452  
 453    /**
 454     * Deletes a replica from the pool. (replicas.delete)
 455     *
 456     * @param string $projectName
 457     * The project ID for this request.
 458     * @param string $zone
 459     * The zone where the replica lives.
 460     * @param string $poolName
 461     * The replica pool name for this request.
 462     * @param string $replicaName
 463     * The name of the replica for this request.
 464     * @param Google_ReplicasDeleteRequest $postBody
 465     * @param array $optParams Optional parameters.
 466     * @return Google_Service_Replicapool_Replica
 467     */
 468    public function delete($projectName, $zone, $poolName, $replicaName, Google_Service_Replicapool_ReplicasDeleteRequest $postBody, $optParams = array())
 469    {
 470      $params = array('projectName' => $projectName, 'zone' => $zone, 'poolName' => $poolName, 'replicaName' => $replicaName, 'postBody' => $postBody);
 471      $params = array_merge($params, $optParams);
 472      return $this->call('delete', array($params), "Google_Service_Replicapool_Replica");
 473    }
 474    /**
 475     * Gets information about a specific replica. (replicas.get)
 476     *
 477     * @param string $projectName
 478     * The project ID for this request.
 479     * @param string $zone
 480     * The zone where the replica lives.
 481     * @param string $poolName
 482     * The replica pool name for this request.
 483     * @param string $replicaName
 484     * The name of the replica for this request.
 485     * @param array $optParams Optional parameters.
 486     * @return Google_Service_Replicapool_Replica
 487     */
 488    public function get($projectName, $zone, $poolName, $replicaName, $optParams = array())
 489    {
 490      $params = array('projectName' => $projectName, 'zone' => $zone, 'poolName' => $poolName, 'replicaName' => $replicaName);
 491      $params = array_merge($params, $optParams);
 492      return $this->call('get', array($params), "Google_Service_Replicapool_Replica");
 493    }
 494    /**
 495     * Lists all replicas in a pool. (replicas.listReplicas)
 496     *
 497     * @param string $projectName
 498     * The project ID for this request.
 499     * @param string $zone
 500     * The zone where the replica pool lives.
 501     * @param string $poolName
 502     * The replica pool name for this request.
 503     * @param array $optParams Optional parameters.
 504     *
 505     * @opt_param string pageToken
 506     * Set this to the nextPageToken value returned by a previous list request to obtain the next page
 507      * of results from the previous list request.
 508     * @opt_param int maxResults
 509     * Maximum count of results to be returned. Acceptable values are 0 to 100, inclusive. (Default:
 510      * 50)
 511     * @return Google_Service_Replicapool_ReplicasListResponse
 512     */
 513    public function listReplicas($projectName, $zone, $poolName, $optParams = array())
 514    {
 515      $params = array('projectName' => $projectName, 'zone' => $zone, 'poolName' => $poolName);
 516      $params = array_merge($params, $optParams);
 517      return $this->call('list', array($params), "Google_Service_Replicapool_ReplicasListResponse");
 518    }
 519    /**
 520     * Restarts a replica in a pool. (replicas.restart)
 521     *
 522     * @param string $projectName
 523     * The project ID for this request.
 524     * @param string $zone
 525     * The zone where the replica lives.
 526     * @param string $poolName
 527     * The replica pool name for this request.
 528     * @param string $replicaName
 529     * The name of the replica for this request.
 530     * @param array $optParams Optional parameters.
 531     * @return Google_Service_Replicapool_Replica
 532     */
 533    public function restart($projectName, $zone, $poolName, $replicaName, $optParams = array())
 534    {
 535      $params = array('projectName' => $projectName, 'zone' => $zone, 'poolName' => $poolName, 'replicaName' => $replicaName);
 536      $params = array_merge($params, $optParams);
 537      return $this->call('restart', array($params), "Google_Service_Replicapool_Replica");
 538    }
 539  }
 540  
 541  
 542  
 543  
 544  class Google_Service_Replicapool_AccessConfig extends Google_Model
 545  {
 546    public $name;
 547    public $natIp;
 548    public $type;
 549  
 550    public function setName($name)
 551    {
 552      $this->name = $name;
 553    }
 554  
 555    public function getName()
 556    {
 557      return $this->name;
 558    }
 559  
 560    public function setNatIp($natIp)
 561    {
 562      $this->natIp = $natIp;
 563    }
 564  
 565    public function getNatIp()
 566    {
 567      return $this->natIp;
 568    }
 569  
 570    public function setType($type)
 571    {
 572      $this->type = $type;
 573    }
 574  
 575    public function getType()
 576    {
 577      return $this->type;
 578    }
 579  }
 580  
 581  class Google_Service_Replicapool_Action extends Google_Collection
 582  {
 583    protected $collection_key = 'envVariables';
 584    public $commands;
 585    protected $envVariablesType = 'Google_Service_Replicapool_EnvVariable';
 586    protected $envVariablesDataType = 'array';
 587    public $timeoutMilliSeconds;
 588  
 589    public function setCommands($commands)
 590    {
 591      $this->commands = $commands;
 592    }
 593  
 594    public function getCommands()
 595    {
 596      return $this->commands;
 597    }
 598  
 599    public function setEnvVariables($envVariables)
 600    {
 601      $this->envVariables = $envVariables;
 602    }
 603  
 604    public function getEnvVariables()
 605    {
 606      return $this->envVariables;
 607    }
 608  
 609    public function setTimeoutMilliSeconds($timeoutMilliSeconds)
 610    {
 611      $this->timeoutMilliSeconds = $timeoutMilliSeconds;
 612    }
 613  
 614    public function getTimeoutMilliSeconds()
 615    {
 616      return $this->timeoutMilliSeconds;
 617    }
 618  }
 619  
 620  class Google_Service_Replicapool_DiskAttachment extends Google_Model
 621  {
 622    public $deviceName;
 623    public $index;
 624  
 625    public function setDeviceName($deviceName)
 626    {
 627      $this->deviceName = $deviceName;
 628    }
 629  
 630    public function getDeviceName()
 631    {
 632      return $this->deviceName;
 633    }
 634  
 635    public function setIndex($index)
 636    {
 637      $this->index = $index;
 638    }
 639  
 640    public function getIndex()
 641    {
 642      return $this->index;
 643    }
 644  }
 645  
 646  class Google_Service_Replicapool_EnvVariable extends Google_Model
 647  {
 648    public $hidden;
 649    public $name;
 650    public $value;
 651  
 652    public function setHidden($hidden)
 653    {
 654      $this->hidden = $hidden;
 655    }
 656  
 657    public function getHidden()
 658    {
 659      return $this->hidden;
 660    }
 661  
 662    public function setName($name)
 663    {
 664      $this->name = $name;
 665    }
 666  
 667    public function getName()
 668    {
 669      return $this->name;
 670    }
 671  
 672    public function setValue($value)
 673    {
 674      $this->value = $value;
 675    }
 676  
 677    public function getValue()
 678    {
 679      return $this->value;
 680    }
 681  }
 682  
 683  class Google_Service_Replicapool_ExistingDisk extends Google_Model
 684  {
 685    protected $attachmentType = 'Google_Service_Replicapool_DiskAttachment';
 686    protected $attachmentDataType = '';
 687    public $source;
 688  
 689    public function setAttachment(Google_Service_Replicapool_DiskAttachment $attachment)
 690    {
 691      $this->attachment = $attachment;
 692    }
 693  
 694    public function getAttachment()
 695    {
 696      return $this->attachment;
 697    }
 698  
 699    public function setSource($source)
 700    {
 701      $this->source = $source;
 702    }
 703  
 704    public function getSource()
 705    {
 706      return $this->source;
 707    }
 708  }
 709  
 710  class Google_Service_Replicapool_HealthCheck extends Google_Model
 711  {
 712    public $checkIntervalSec;
 713    public $description;
 714    public $healthyThreshold;
 715    public $host;
 716    public $name;
 717    public $path;
 718    public $port;
 719    public $timeoutSec;
 720    public $unhealthyThreshold;
 721  
 722    public function setCheckIntervalSec($checkIntervalSec)
 723    {
 724      $this->checkIntervalSec = $checkIntervalSec;
 725    }
 726  
 727    public function getCheckIntervalSec()
 728    {
 729      return $this->checkIntervalSec;
 730    }
 731  
 732    public function setDescription($description)
 733    {
 734      $this->description = $description;
 735    }
 736  
 737    public function getDescription()
 738    {
 739      return $this->description;
 740    }
 741  
 742    public function setHealthyThreshold($healthyThreshold)
 743    {
 744      $this->healthyThreshold = $healthyThreshold;
 745    }
 746  
 747    public function getHealthyThreshold()
 748    {
 749      return $this->healthyThreshold;
 750    }
 751  
 752    public function setHost($host)
 753    {
 754      $this->host = $host;
 755    }
 756  
 757    public function getHost()
 758    {
 759      return $this->host;
 760    }
 761  
 762    public function setName($name)
 763    {
 764      $this->name = $name;
 765    }
 766  
 767    public function getName()
 768    {
 769      return $this->name;
 770    }
 771  
 772    public function setPath($path)
 773    {
 774      $this->path = $path;
 775    }
 776  
 777    public function getPath()
 778    {
 779      return $this->path;
 780    }
 781  
 782    public function setPort($port)
 783    {
 784      $this->port = $port;
 785    }
 786  
 787    public function getPort()
 788    {
 789      return $this->port;
 790    }
 791  
 792    public function setTimeoutSec($timeoutSec)
 793    {
 794      $this->timeoutSec = $timeoutSec;
 795    }
 796  
 797    public function getTimeoutSec()
 798    {
 799      return $this->timeoutSec;
 800    }
 801  
 802    public function setUnhealthyThreshold($unhealthyThreshold)
 803    {
 804      $this->unhealthyThreshold = $unhealthyThreshold;
 805    }
 806  
 807    public function getUnhealthyThreshold()
 808    {
 809      return $this->unhealthyThreshold;
 810    }
 811  }
 812  
 813  class Google_Service_Replicapool_Label extends Google_Model
 814  {
 815    public $key;
 816    public $value;
 817  
 818    public function setKey($key)
 819    {
 820      $this->key = $key;
 821    }
 822  
 823    public function getKey()
 824    {
 825      return $this->key;
 826    }
 827  
 828    public function setValue($value)
 829    {
 830      $this->value = $value;
 831    }
 832  
 833    public function getValue()
 834    {
 835      return $this->value;
 836    }
 837  }
 838  
 839  class Google_Service_Replicapool_Metadata extends Google_Collection
 840  {
 841    protected $collection_key = 'items';
 842    public $fingerPrint;
 843    protected $itemsType = 'Google_Service_Replicapool_MetadataItem';
 844    protected $itemsDataType = 'array';
 845  
 846    public function setFingerPrint($fingerPrint)
 847    {
 848      $this->fingerPrint = $fingerPrint;
 849    }
 850  
 851    public function getFingerPrint()
 852    {
 853      return $this->fingerPrint;
 854    }
 855  
 856    public function setItems($items)
 857    {
 858      $this->items = $items;
 859    }
 860  
 861    public function getItems()
 862    {
 863      return $this->items;
 864    }
 865  }
 866  
 867  class Google_Service_Replicapool_MetadataItem extends Google_Model
 868  {
 869    public $key;
 870    public $value;
 871  
 872    public function setKey($key)
 873    {
 874      $this->key = $key;
 875    }
 876  
 877    public function getKey()
 878    {
 879      return $this->key;
 880    }
 881  
 882    public function setValue($value)
 883    {
 884      $this->value = $value;
 885    }
 886  
 887    public function getValue()
 888    {
 889      return $this->value;
 890    }
 891  }
 892  
 893  class Google_Service_Replicapool_NetworkInterface extends Google_Collection
 894  {
 895    protected $collection_key = 'accessConfigs';
 896    protected $accessConfigsType = 'Google_Service_Replicapool_AccessConfig';
 897    protected $accessConfigsDataType = 'array';
 898    public $network;
 899    public $networkIp;
 900  
 901    public function setAccessConfigs($accessConfigs)
 902    {
 903      $this->accessConfigs = $accessConfigs;
 904    }
 905  
 906    public function getAccessConfigs()
 907    {
 908      return $this->accessConfigs;
 909    }
 910  
 911    public function setNetwork($network)
 912    {
 913      $this->network = $network;
 914    }
 915  
 916    public function getNetwork()
 917    {
 918      return $this->network;
 919    }
 920  
 921    public function setNetworkIp($networkIp)
 922    {
 923      $this->networkIp = $networkIp;
 924    }
 925  
 926    public function getNetworkIp()
 927    {
 928      return $this->networkIp;
 929    }
 930  }
 931  
 932  class Google_Service_Replicapool_NewDisk extends Google_Model
 933  {
 934    protected $attachmentType = 'Google_Service_Replicapool_DiskAttachment';
 935    protected $attachmentDataType = '';
 936    public $autoDelete;
 937    public $boot;
 938    protected $initializeParamsType = 'Google_Service_Replicapool_NewDiskInitializeParams';
 939    protected $initializeParamsDataType = '';
 940  
 941    public function setAttachment(Google_Service_Replicapool_DiskAttachment $attachment)
 942    {
 943      $this->attachment = $attachment;
 944    }
 945  
 946    public function getAttachment()
 947    {
 948      return $this->attachment;
 949    }
 950  
 951    public function setAutoDelete($autoDelete)
 952    {
 953      $this->autoDelete = $autoDelete;
 954    }
 955  
 956    public function getAutoDelete()
 957    {
 958      return $this->autoDelete;
 959    }
 960  
 961    public function setBoot($boot)
 962    {
 963      $this->boot = $boot;
 964    }
 965  
 966    public function getBoot()
 967    {
 968      return $this->boot;
 969    }
 970  
 971    public function setInitializeParams(Google_Service_Replicapool_NewDiskInitializeParams $initializeParams)
 972    {
 973      $this->initializeParams = $initializeParams;
 974    }
 975  
 976    public function getInitializeParams()
 977    {
 978      return $this->initializeParams;
 979    }
 980  }
 981  
 982  class Google_Service_Replicapool_NewDiskInitializeParams extends Google_Model
 983  {
 984    public $diskSizeGb;
 985    public $diskType;
 986    public $sourceImage;
 987  
 988    public function setDiskSizeGb($diskSizeGb)
 989    {
 990      $this->diskSizeGb = $diskSizeGb;
 991    }
 992  
 993    public function getDiskSizeGb()
 994    {
 995      return $this->diskSizeGb;
 996    }
 997  
 998    public function setDiskType($diskType)
 999    {
1000      $this->diskType = $diskType;
1001    }
1002  
1003    public function getDiskType()
1004    {
1005      return $this->diskType;
1006    }
1007  
1008    public function setSourceImage($sourceImage)
1009    {
1010      $this->sourceImage = $sourceImage;
1011    }
1012  
1013    public function getSourceImage()
1014    {
1015      return $this->sourceImage;
1016    }
1017  }
1018  
1019  class Google_Service_Replicapool_Pool extends Google_Collection
1020  {
1021    protected $collection_key = 'targetPools';
1022    public $autoRestart;
1023    public $baseInstanceName;
1024    public $currentNumReplicas;
1025    public $description;
1026    protected $healthChecksType = 'Google_Service_Replicapool_HealthCheck';
1027    protected $healthChecksDataType = 'array';
1028    public $initialNumReplicas;
1029    protected $labelsType = 'Google_Service_Replicapool_Label';
1030    protected $labelsDataType = 'array';
1031    public $name;
1032    public $numReplicas;
1033    public $resourceViews;
1034    public $selfLink;
1035    public $targetPool;
1036    public $targetPools;
1037    protected $templateType = 'Google_Service_Replicapool_Template';
1038    protected $templateDataType = '';
1039    public $type;
1040  
1041    public function setAutoRestart($autoRestart)
1042    {
1043      $this->autoRestart = $autoRestart;
1044    }
1045  
1046    public function getAutoRestart()
1047    {
1048      return $this->autoRestart;
1049    }
1050  
1051    public function setBaseInstanceName($baseInstanceName)
1052    {
1053      $this->baseInstanceName = $baseInstanceName;
1054    }
1055  
1056    public function getBaseInstanceName()
1057    {
1058      return $this->baseInstanceName;
1059    }
1060  
1061    public function setCurrentNumReplicas($currentNumReplicas)
1062    {
1063      $this->currentNumReplicas = $currentNumReplicas;
1064    }
1065  
1066    public function getCurrentNumReplicas()
1067    {
1068      return $this->currentNumReplicas;
1069    }
1070  
1071    public function setDescription($description)
1072    {
1073      $this->description = $description;
1074    }
1075  
1076    public function getDescription()
1077    {
1078      return $this->description;
1079    }
1080  
1081    public function setHealthChecks($healthChecks)
1082    {
1083      $this->healthChecks = $healthChecks;
1084    }
1085  
1086    public function getHealthChecks()
1087    {
1088      return $this->healthChecks;
1089    }
1090  
1091    public function setInitialNumReplicas($initialNumReplicas)
1092    {
1093      $this->initialNumReplicas = $initialNumReplicas;
1094    }
1095  
1096    public function getInitialNumReplicas()
1097    {
1098      return $this->initialNumReplicas;
1099    }
1100  
1101    public function setLabels($labels)
1102    {
1103      $this->labels = $labels;
1104    }
1105  
1106    public function getLabels()
1107    {
1108      return $this->labels;
1109    }
1110  
1111    public function setName($name)
1112    {
1113      $this->name = $name;
1114    }
1115  
1116    public function getName()
1117    {
1118      return $this->name;
1119    }
1120  
1121    public function setNumReplicas($numReplicas)
1122    {
1123      $this->numReplicas = $numReplicas;
1124    }
1125  
1126    public function getNumReplicas()
1127    {
1128      return $this->numReplicas;
1129    }
1130  
1131    public function setResourceViews($resourceViews)
1132    {
1133      $this->resourceViews = $resourceViews;
1134    }
1135  
1136    public function getResourceViews()
1137    {
1138      return $this->resourceViews;
1139    }
1140  
1141    public function setSelfLink($selfLink)
1142    {
1143      $this->selfLink = $selfLink;
1144    }
1145  
1146    public function getSelfLink()
1147    {
1148      return $this->selfLink;
1149    }
1150  
1151    public function setTargetPool($targetPool)
1152    {
1153      $this->targetPool = $targetPool;
1154    }
1155  
1156    public function getTargetPool()
1157    {
1158      return $this->targetPool;
1159    }
1160  
1161    public function setTargetPools($targetPools)
1162    {
1163      $this->targetPools = $targetPools;
1164    }
1165  
1166    public function getTargetPools()
1167    {
1168      return $this->targetPools;
1169    }
1170  
1171    public function setTemplate(Google_Service_Replicapool_Template $template)
1172    {
1173      $this->template = $template;
1174    }
1175  
1176    public function getTemplate()
1177    {
1178      return $this->template;
1179    }
1180  
1181    public function setType($type)
1182    {
1183      $this->type = $type;
1184    }
1185  
1186    public function getType()
1187    {
1188      return $this->type;
1189    }
1190  }
1191  
1192  class Google_Service_Replicapool_PoolsDeleteRequest extends Google_Collection
1193  {
1194    protected $collection_key = 'abandonInstances';
1195    public $abandonInstances;
1196  
1197    public function setAbandonInstances($abandonInstances)
1198    {
1199      $this->abandonInstances = $abandonInstances;
1200    }
1201  
1202    public function getAbandonInstances()
1203    {
1204      return $this->abandonInstances;
1205    }
1206  }
1207  
1208  class Google_Service_Replicapool_PoolsListResponse extends Google_Collection
1209  {
1210    protected $collection_key = 'resources';
1211    public $nextPageToken;
1212    protected $resourcesType = 'Google_Service_Replicapool_Pool';
1213    protected $resourcesDataType = 'array';
1214  
1215    public function setNextPageToken($nextPageToken)
1216    {
1217      $this->nextPageToken = $nextPageToken;
1218    }
1219  
1220    public function getNextPageToken()
1221    {
1222      return $this->nextPageToken;
1223    }
1224  
1225    public function setResources($resources)
1226    {
1227      $this->resources = $resources;
1228    }
1229  
1230    public function getResources()
1231    {
1232      return $this->resources;
1233    }
1234  }
1235  
1236  class Google_Service_Replicapool_Replica extends Google_Model
1237  {
1238    public $name;
1239    public $selfLink;
1240    protected $statusType = 'Google_Service_Replicapool_ReplicaStatus';
1241    protected $statusDataType = '';
1242  
1243    public function setName($name)
1244    {
1245      $this->name = $name;
1246    }
1247  
1248    public function getName()
1249    {
1250      return $this->name;
1251    }
1252  
1253    public function setSelfLink($selfLink)
1254    {
1255      $this->selfLink = $selfLink;
1256    }
1257  
1258    public function getSelfLink()
1259    {
1260      return $this->selfLink;
1261    }
1262  
1263    public function setStatus(Google_Service_Replicapool_ReplicaStatus $status)
1264    {
1265      $this->status = $status;
1266    }
1267  
1268    public function getStatus()
1269    {
1270      return $this->status;
1271    }
1272  }
1273  
1274  class Google_Service_Replicapool_ReplicaStatus extends Google_Model
1275  {
1276    public $details;
1277    public $state;
1278    public $templateVersion;
1279    public $vmLink;
1280    public $vmStartTime;
1281  
1282    public function setDetails($details)
1283    {
1284      $this->details = $details;
1285    }
1286  
1287    public function getDetails()
1288    {
1289      return $this->details;
1290    }
1291  
1292    public function setState($state)
1293    {
1294      $this->state = $state;
1295    }
1296  
1297    public function getState()
1298    {
1299      return $this->state;
1300    }
1301  
1302    public function setTemplateVersion($templateVersion)
1303    {
1304      $this->templateVersion = $templateVersion;
1305    }
1306  
1307    public function getTemplateVersion()
1308    {
1309      return $this->templateVersion;
1310    }
1311  
1312    public function setVmLink($vmLink)
1313    {
1314      $this->vmLink = $vmLink;
1315    }
1316  
1317    public function getVmLink()
1318    {
1319      return $this->vmLink;
1320    }
1321  
1322    public function setVmStartTime($vmStartTime)
1323    {
1324      $this->vmStartTime = $vmStartTime;
1325    }
1326  
1327    public function getVmStartTime()
1328    {
1329      return $this->vmStartTime;
1330    }
1331  }
1332  
1333  class Google_Service_Replicapool_ReplicasDeleteRequest extends Google_Model
1334  {
1335    public $abandonInstance;
1336  
1337    public function setAbandonInstance($abandonInstance)
1338    {
1339      $this->abandonInstance = $abandonInstance;
1340    }
1341  
1342    public function getAbandonInstance()
1343    {
1344      return $this->abandonInstance;
1345    }
1346  }
1347  
1348  class Google_Service_Replicapool_ReplicasListResponse extends Google_Collection
1349  {
1350    protected $collection_key = 'resources';
1351    public $nextPageToken;
1352    protected $resourcesType = 'Google_Service_Replicapool_Replica';
1353    protected $resourcesDataType = 'array';
1354  
1355    public function setNextPageToken($nextPageToken)
1356    {
1357      $this->nextPageToken = $nextPageToken;
1358    }
1359  
1360    public function getNextPageToken()
1361    {
1362      return $this->nextPageToken;
1363    }
1364  
1365    public function setResources($resources)
1366    {
1367      $this->resources = $resources;
1368    }
1369  
1370    public function getResources()
1371    {
1372      return $this->resources;
1373    }
1374  }
1375  
1376  class Google_Service_Replicapool_ServiceAccount extends Google_Collection
1377  {
1378    protected $collection_key = 'scopes';
1379    public $email;
1380    public $scopes;
1381  
1382    public function setEmail($email)
1383    {
1384      $this->email = $email;
1385    }
1386  
1387    public function getEmail()
1388    {
1389      return $this->email;
1390    }
1391  
1392    public function setScopes($scopes)
1393    {
1394      $this->scopes = $scopes;
1395    }
1396  
1397    public function getScopes()
1398    {
1399      return $this->scopes;
1400    }
1401  }
1402  
1403  class Google_Service_Replicapool_Tag extends Google_Collection
1404  {
1405    protected $collection_key = 'items';
1406    public $fingerPrint;
1407    public $items;
1408  
1409    public function setFingerPrint($fingerPrint)
1410    {
1411      $this->fingerPrint = $fingerPrint;
1412    }
1413  
1414    public function getFingerPrint()
1415    {
1416      return $this->fingerPrint;
1417    }
1418  
1419    public function setItems($items)
1420    {
1421      $this->items = $items;
1422    }
1423  
1424    public function getItems()
1425    {
1426      return $this->items;
1427    }
1428  }
1429  
1430  class Google_Service_Replicapool_Template extends Google_Collection
1431  {
1432    protected $collection_key = 'healthChecks';
1433    protected $actionType = 'Google_Service_Replicapool_Action';
1434    protected $actionDataType = '';
1435    protected $healthChecksType = 'Google_Service_Replicapool_HealthCheck';
1436    protected $healthChecksDataType = 'array';
1437    public $version;
1438    protected $vmParamsType = 'Google_Service_Replicapool_VmParams';
1439    protected $vmParamsDataType = '';
1440  
1441    public function setAction(Google_Service_Replicapool_Action $action)
1442    {
1443      $this->action = $action;
1444    }
1445  
1446    public function getAction()
1447    {
1448      return $this->action;
1449    }
1450  
1451    public function setHealthChecks($healthChecks)
1452    {
1453      $this->healthChecks = $healthChecks;
1454    }
1455  
1456    public function getHealthChecks()
1457    {
1458      return $this->healthChecks;
1459    }
1460  
1461    public function setVersion($version)
1462    {
1463      $this->version = $version;
1464    }
1465  
1466    public function getVersion()
1467    {
1468      return $this->version;
1469    }
1470  
1471    public function setVmParams(Google_Service_Replicapool_VmParams $vmParams)
1472    {
1473      $this->vmParams = $vmParams;
1474    }
1475  
1476    public function getVmParams()
1477    {
1478      return $this->vmParams;
1479    }
1480  }
1481  
1482  class Google_Service_Replicapool_VmParams extends Google_Collection
1483  {
1484    protected $collection_key = 'serviceAccounts';
1485    public $baseInstanceName;
1486    public $canIpForward;
1487    public $description;
1488    protected $disksToAttachType = 'Google_Service_Replicapool_ExistingDisk';
1489    protected $disksToAttachDataType = 'array';
1490    protected $disksToCreateType = 'Google_Service_Replicapool_NewDisk';
1491    protected $disksToCreateDataType = 'array';
1492    public $machineType;
1493    protected $metadataType = 'Google_Service_Replicapool_Metadata';
1494    protected $metadataDataType = '';
1495    protected $networkInterfacesType = 'Google_Service_Replicapool_NetworkInterface';
1496    protected $networkInterfacesDataType = 'array';
1497    public $onHostMaintenance;
1498    protected $serviceAccountsType = 'Google_Service_Replicapool_ServiceAccount';
1499    protected $serviceAccountsDataType = 'array';
1500    protected $tagsType = 'Google_Service_Replicapool_Tag';
1501    protected $tagsDataType = '';
1502  
1503    public function setBaseInstanceName($baseInstanceName)
1504    {
1505      $this->baseInstanceName = $baseInstanceName;
1506    }
1507  
1508    public function getBaseInstanceName()
1509    {
1510      return $this->baseInstanceName;
1511    }
1512  
1513    public function setCanIpForward($canIpForward)
1514    {
1515      $this->canIpForward = $canIpForward;
1516    }
1517  
1518    public function getCanIpForward()
1519    {
1520      return $this->canIpForward;
1521    }
1522  
1523    public function setDescription($description)
1524    {
1525      $this->description = $description;
1526    }
1527  
1528    public function getDescription()
1529    {
1530      return $this->description;
1531    }
1532  
1533    public function setDisksToAttach($disksToAttach)
1534    {
1535      $this->disksToAttach = $disksToAttach;
1536    }
1537  
1538    public function getDisksToAttach()
1539    {
1540      return $this->disksToAttach;
1541    }
1542  
1543    public function setDisksToCreate($disksToCreate)
1544    {
1545      $this->disksToCreate = $disksToCreate;
1546    }
1547  
1548    public function getDisksToCreate()
1549    {
1550      return $this->disksToCreate;
1551    }
1552  
1553    public function setMachineType($machineType)
1554    {
1555      $this->machineType = $machineType;
1556    }
1557  
1558    public function getMachineType()
1559    {
1560      return $this->machineType;
1561    }
1562  
1563    public function setMetadata(Google_Service_Replicapool_Metadata $metadata)
1564    {
1565      $this->metadata = $metadata;
1566    }
1567  
1568    public function getMetadata()
1569    {
1570      return $this->metadata;
1571    }
1572  
1573    public function setNetworkInterfaces($networkInterfaces)
1574    {
1575      $this->networkInterfaces = $networkInterfaces;
1576    }
1577  
1578    public function getNetworkInterfaces()
1579    {
1580      return $this->networkInterfaces;
1581    }
1582  
1583    public function setOnHostMaintenance($onHostMaintenance)
1584    {
1585      $this->onHostMaintenance = $onHostMaintenance;
1586    }
1587  
1588    public function getOnHostMaintenance()
1589    {
1590      return $this->onHostMaintenance;
1591    }
1592  
1593    public function setServiceAccounts($serviceAccounts)
1594    {
1595      $this->serviceAccounts = $serviceAccounts;
1596    }
1597  
1598    public function getServiceAccounts()
1599    {
1600      return $this->serviceAccounts;
1601    }
1602  
1603    public function setTags(Google_Service_Replicapool_Tag $tags)
1604    {
1605      $this->tags = $tags;
1606    }
1607  
1608    public function getTags()
1609    {
1610      return $this->tags;
1611    }
1612  }