[Summary view]

Differences Between: [Versions 401 and 402] [Versions 401 and 403]

   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 Manager (v1beta2).
  20   *
  21   * <p>
  22   * The Deployment Manager API allows users to declaratively configure, deploy
  23   * and run complex solutions on the Google Cloud Platform.</p>
  24   *
  25   * <p>
  26   * For more information about this service, see the API
  27   * <a href="https://developers.google.com/deployment-manager/" target="_blank">Documentation</a>
  28   * </p>
  29   *
  30   * @author Google, Inc.
  31   */
  32  class Google_Service_Manager extends Google_Service
  33  {
  34    /** View and manage your applications deployed on Google App Engine. */
  35    const APPENGINE_ADMIN =
  36        "https://www.googleapis.com/auth/appengine.admin";
  37    /** View and manage your data across Google Cloud Platform services. */
  38    const CLOUD_PLATFORM =
  39        "https://www.googleapis.com/auth/cloud-platform";
  40    /** View your data across Google Cloud Platform services. */
  41    const CLOUD_PLATFORM_READ_ONLY =
  42        "https://www.googleapis.com/auth/cloud-platform.read-only";
  43    /** View and manage your Google Compute Engine resources. */
  44    const COMPUTE =
  45        "https://www.googleapis.com/auth/compute";
  46    /** Manage your data in Google Cloud Storage. */
  47    const DEVSTORAGE_READ_WRITE =
  48        "https://www.googleapis.com/auth/devstorage.read_write";
  49    /** View and manage your Google Cloud Platform management resources and deployment status information. */
  50    const NDEV_CLOUDMAN =
  51        "https://www.googleapis.com/auth/ndev.cloudman";
  52    /** View your Google Cloud Platform management resources and deployment status information. */
  53    const NDEV_CLOUDMAN_READONLY =
  54        "https://www.googleapis.com/auth/ndev.cloudman.readonly";
  55  
  56    public $deployments;
  57    public $templates;
  58    
  59  
  60    /**
  61     * Constructs the internal representation of the Manager service.
  62     *
  63     * @param Google_Client $client
  64     */
  65    public function __construct(Google_Client $client)
  66    {
  67      parent::__construct($client);
  68      $this->rootUrl = 'https://www.googleapis.com/';
  69      $this->servicePath = 'manager/v1beta2/projects/';
  70      $this->version = 'v1beta2';
  71      $this->serviceName = 'manager';
  72  
  73      $this->deployments = new Google_Service_Manager_Deployments_Resource(
  74          $this,
  75          $this->serviceName,
  76          'deployments',
  77          array(
  78            'methods' => array(
  79              'delete' => array(
  80                'path' => '{projectId}/regions/{region}/deployments/{deploymentName}',
  81                'httpMethod' => 'DELETE',
  82                'parameters' => array(
  83                  'projectId' => array(
  84                    'location' => 'path',
  85                    'type' => 'string',
  86                    'required' => true,
  87                  ),
  88                  'region' => array(
  89                    'location' => 'path',
  90                    'type' => 'string',
  91                    'required' => true,
  92                  ),
  93                  'deploymentName' => array(
  94                    'location' => 'path',
  95                    'type' => 'string',
  96                    'required' => true,
  97                  ),
  98                ),
  99              ),'get' => array(
 100                'path' => '{projectId}/regions/{region}/deployments/{deploymentName}',
 101                'httpMethod' => 'GET',
 102                'parameters' => array(
 103                  'projectId' => array(
 104                    'location' => 'path',
 105                    'type' => 'string',
 106                    'required' => true,
 107                  ),
 108                  'region' => array(
 109                    'location' => 'path',
 110                    'type' => 'string',
 111                    'required' => true,
 112                  ),
 113                  'deploymentName' => array(
 114                    'location' => 'path',
 115                    'type' => 'string',
 116                    'required' => true,
 117                  ),
 118                ),
 119              ),'insert' => array(
 120                'path' => '{projectId}/regions/{region}/deployments',
 121                'httpMethod' => 'POST',
 122                'parameters' => array(
 123                  'projectId' => array(
 124                    'location' => 'path',
 125                    'type' => 'string',
 126                    'required' => true,
 127                  ),
 128                  'region' => array(
 129                    'location' => 'path',
 130                    'type' => 'string',
 131                    'required' => true,
 132                  ),
 133                ),
 134              ),'list' => array(
 135                'path' => '{projectId}/regions/{region}/deployments',
 136                'httpMethod' => 'GET',
 137                'parameters' => array(
 138                  'projectId' => array(
 139                    'location' => 'path',
 140                    'type' => 'string',
 141                    'required' => true,
 142                  ),
 143                  'region' => array(
 144                    'location' => 'path',
 145                    'type' => 'string',
 146                    'required' => true,
 147                  ),
 148                  'pageToken' => array(
 149                    'location' => 'query',
 150                    'type' => 'string',
 151                  ),
 152                  'maxResults' => array(
 153                    'location' => 'query',
 154                    'type' => 'integer',
 155                  ),
 156                ),
 157              ),
 158            )
 159          )
 160      );
 161      $this->templates = new Google_Service_Manager_Templates_Resource(
 162          $this,
 163          $this->serviceName,
 164          'templates',
 165          array(
 166            'methods' => array(
 167              'delete' => array(
 168                'path' => '{projectId}/templates/{templateName}',
 169                'httpMethod' => 'DELETE',
 170                'parameters' => array(
 171                  'projectId' => array(
 172                    'location' => 'path',
 173                    'type' => 'string',
 174                    'required' => true,
 175                  ),
 176                  'templateName' => array(
 177                    'location' => 'path',
 178                    'type' => 'string',
 179                    'required' => true,
 180                  ),
 181                ),
 182              ),'get' => array(
 183                'path' => '{projectId}/templates/{templateName}',
 184                'httpMethod' => 'GET',
 185                'parameters' => array(
 186                  'projectId' => array(
 187                    'location' => 'path',
 188                    'type' => 'string',
 189                    'required' => true,
 190                  ),
 191                  'templateName' => array(
 192                    'location' => 'path',
 193                    'type' => 'string',
 194                    'required' => true,
 195                  ),
 196                ),
 197              ),'insert' => array(
 198                'path' => '{projectId}/templates',
 199                'httpMethod' => 'POST',
 200                'parameters' => array(
 201                  'projectId' => array(
 202                    'location' => 'path',
 203                    'type' => 'string',
 204                    'required' => true,
 205                  ),
 206                ),
 207              ),'list' => array(
 208                'path' => '{projectId}/templates',
 209                'httpMethod' => 'GET',
 210                'parameters' => array(
 211                  'projectId' => array(
 212                    'location' => 'path',
 213                    'type' => 'string',
 214                    'required' => true,
 215                  ),
 216                  'pageToken' => array(
 217                    'location' => 'query',
 218                    'type' => 'string',
 219                  ),
 220                  'maxResults' => array(
 221                    'location' => 'query',
 222                    'type' => 'integer',
 223                  ),
 224                ),
 225              ),
 226            )
 227          )
 228      );
 229    }
 230  }
 231  
 232  
 233  /**
 234   * The "deployments" collection of methods.
 235   * Typical usage is:
 236   *  <code>
 237   *   $managerService = new Google_Service_Manager(...);
 238   *   $deployments = $managerService->deployments;
 239   *  </code>
 240   */
 241  class Google_Service_Manager_Deployments_Resource extends Google_Service_Resource
 242  {
 243  
 244    /**
 245     * (deployments.delete)
 246     *
 247     * @param string $projectId
 248     * @param string $region
 249     * @param string $deploymentName
 250     * @param array $optParams Optional parameters.
 251     */
 252    public function delete($projectId, $region, $deploymentName, $optParams = array())
 253    {
 254      $params = array('projectId' => $projectId, 'region' => $region, 'deploymentName' => $deploymentName);
 255      $params = array_merge($params, $optParams);
 256      return $this->call('delete', array($params));
 257    }
 258  
 259    /**
 260     * (deployments.get)
 261     *
 262     * @param string $projectId
 263     * @param string $region
 264     * @param string $deploymentName
 265     * @param array $optParams Optional parameters.
 266     * @return Google_Service_Manager_Deployment
 267     */
 268    public function get($projectId, $region, $deploymentName, $optParams = array())
 269    {
 270      $params = array('projectId' => $projectId, 'region' => $region, 'deploymentName' => $deploymentName);
 271      $params = array_merge($params, $optParams);
 272      return $this->call('get', array($params), "Google_Service_Manager_Deployment");
 273    }
 274  
 275    /**
 276     * (deployments.insert)
 277     *
 278     * @param string $projectId
 279     * @param string $region
 280     * @param Google_Deployment $postBody
 281     * @param array $optParams Optional parameters.
 282     * @return Google_Service_Manager_Deployment
 283     */
 284    public function insert($projectId, $region, Google_Service_Manager_Deployment $postBody, $optParams = array())
 285    {
 286      $params = array('projectId' => $projectId, 'region' => $region, 'postBody' => $postBody);
 287      $params = array_merge($params, $optParams);
 288      return $this->call('insert', array($params), "Google_Service_Manager_Deployment");
 289    }
 290  
 291    /**
 292     * (deployments.listDeployments)
 293     *
 294     * @param string $projectId
 295     * @param string $region
 296     * @param array $optParams Optional parameters.
 297     *
 298     * @opt_param string pageToken Specifies a nextPageToken returned by a previous
 299     * list request. This token can be used to request the next page of results from
 300     * a previous list request.
 301     * @opt_param int maxResults Maximum count of results to be returned. Acceptable
 302     * values are 0 to 100, inclusive. (Default: 50)
 303     * @return Google_Service_Manager_DeploymentsListResponse
 304     */
 305    public function listDeployments($projectId, $region, $optParams = array())
 306    {
 307      $params = array('projectId' => $projectId, 'region' => $region);
 308      $params = array_merge($params, $optParams);
 309      return $this->call('list', array($params), "Google_Service_Manager_DeploymentsListResponse");
 310    }
 311  }
 312  
 313  /**
 314   * The "templates" collection of methods.
 315   * Typical usage is:
 316   *  <code>
 317   *   $managerService = new Google_Service_Manager(...);
 318   *   $templates = $managerService->templates;
 319   *  </code>
 320   */
 321  class Google_Service_Manager_Templates_Resource extends Google_Service_Resource
 322  {
 323  
 324    /**
 325     * (templates.delete)
 326     *
 327     * @param string $projectId
 328     * @param string $templateName
 329     * @param array $optParams Optional parameters.
 330     */
 331    public function delete($projectId, $templateName, $optParams = array())
 332    {
 333      $params = array('projectId' => $projectId, 'templateName' => $templateName);
 334      $params = array_merge($params, $optParams);
 335      return $this->call('delete', array($params));
 336    }
 337  
 338    /**
 339     * (templates.get)
 340     *
 341     * @param string $projectId
 342     * @param string $templateName
 343     * @param array $optParams Optional parameters.
 344     * @return Google_Service_Manager_Template
 345     */
 346    public function get($projectId, $templateName, $optParams = array())
 347    {
 348      $params = array('projectId' => $projectId, 'templateName' => $templateName);
 349      $params = array_merge($params, $optParams);
 350      return $this->call('get', array($params), "Google_Service_Manager_Template");
 351    }
 352  
 353    /**
 354     * (templates.insert)
 355     *
 356     * @param string $projectId
 357     * @param Google_Template $postBody
 358     * @param array $optParams Optional parameters.
 359     * @return Google_Service_Manager_Template
 360     */
 361    public function insert($projectId, Google_Service_Manager_Template $postBody, $optParams = array())
 362    {
 363      $params = array('projectId' => $projectId, 'postBody' => $postBody);
 364      $params = array_merge($params, $optParams);
 365      return $this->call('insert', array($params), "Google_Service_Manager_Template");
 366    }
 367  
 368    /**
 369     * (templates.listTemplates)
 370     *
 371     * @param string $projectId
 372     * @param array $optParams Optional parameters.
 373     *
 374     * @opt_param string pageToken Specifies a nextPageToken returned by a previous
 375     * list request. This token can be used to request the next page of results from
 376     * a previous list request.
 377     * @opt_param int maxResults Maximum count of results to be returned. Acceptable
 378     * values are 0 to 100, inclusive. (Default: 50)
 379     * @return Google_Service_Manager_TemplatesListResponse
 380     */
 381    public function listTemplates($projectId, $optParams = array())
 382    {
 383      $params = array('projectId' => $projectId);
 384      $params = array_merge($params, $optParams);
 385      return $this->call('list', array($params), "Google_Service_Manager_TemplatesListResponse");
 386    }
 387  }
 388  
 389  
 390  
 391  
 392  class Google_Service_Manager_AccessConfig extends Google_Model
 393  {
 394    protected $internal_gapi_mappings = array(
 395    );
 396    public $name;
 397    public $natIp;
 398    public $type;
 399  
 400  
 401    public function setName($name)
 402    {
 403      $this->name = $name;
 404    }
 405    public function getName()
 406    {
 407      return $this->name;
 408    }
 409    public function setNatIp($natIp)
 410    {
 411      $this->natIp = $natIp;
 412    }
 413    public function getNatIp()
 414    {
 415      return $this->natIp;
 416    }
 417    public function setType($type)
 418    {
 419      $this->type = $type;
 420    }
 421    public function getType()
 422    {
 423      return $this->type;
 424    }
 425  }
 426  
 427  class Google_Service_Manager_Action extends Google_Collection
 428  {
 429    protected $collection_key = 'commands';
 430    protected $internal_gapi_mappings = array(
 431    );
 432    public $commands;
 433    public $timeoutMs;
 434  
 435  
 436    public function setCommands($commands)
 437    {
 438      $this->commands = $commands;
 439    }
 440    public function getCommands()
 441    {
 442      return $this->commands;
 443    }
 444    public function setTimeoutMs($timeoutMs)
 445    {
 446      $this->timeoutMs = $timeoutMs;
 447    }
 448    public function getTimeoutMs()
 449    {
 450      return $this->timeoutMs;
 451    }
 452  }
 453  
 454  class Google_Service_Manager_AllowedRule extends Google_Collection
 455  {
 456    protected $collection_key = 'ports';
 457    protected $internal_gapi_mappings = array(
 458          "iPProtocol" => "IPProtocol",
 459    );
 460    public $iPProtocol;
 461    public $ports;
 462  
 463  
 464    public function setIPProtocol($iPProtocol)
 465    {
 466      $this->iPProtocol = $iPProtocol;
 467    }
 468    public function getIPProtocol()
 469    {
 470      return $this->iPProtocol;
 471    }
 472    public function setPorts($ports)
 473    {
 474      $this->ports = $ports;
 475    }
 476    public function getPorts()
 477    {
 478      return $this->ports;
 479    }
 480  }
 481  
 482  class Google_Service_Manager_AutoscalingModule extends Google_Model
 483  {
 484    protected $internal_gapi_mappings = array(
 485    );
 486    public $coolDownPeriodSec;
 487    public $description;
 488    public $maxNumReplicas;
 489    public $minNumReplicas;
 490    public $signalType;
 491    public $targetModule;
 492    public $targetUtilization;
 493  
 494  
 495    public function setCoolDownPeriodSec($coolDownPeriodSec)
 496    {
 497      $this->coolDownPeriodSec = $coolDownPeriodSec;
 498    }
 499    public function getCoolDownPeriodSec()
 500    {
 501      return $this->coolDownPeriodSec;
 502    }
 503    public function setDescription($description)
 504    {
 505      $this->description = $description;
 506    }
 507    public function getDescription()
 508    {
 509      return $this->description;
 510    }
 511    public function setMaxNumReplicas($maxNumReplicas)
 512    {
 513      $this->maxNumReplicas = $maxNumReplicas;
 514    }
 515    public function getMaxNumReplicas()
 516    {
 517      return $this->maxNumReplicas;
 518    }
 519    public function setMinNumReplicas($minNumReplicas)
 520    {
 521      $this->minNumReplicas = $minNumReplicas;
 522    }
 523    public function getMinNumReplicas()
 524    {
 525      return $this->minNumReplicas;
 526    }
 527    public function setSignalType($signalType)
 528    {
 529      $this->signalType = $signalType;
 530    }
 531    public function getSignalType()
 532    {
 533      return $this->signalType;
 534    }
 535    public function setTargetModule($targetModule)
 536    {
 537      $this->targetModule = $targetModule;
 538    }
 539    public function getTargetModule()
 540    {
 541      return $this->targetModule;
 542    }
 543    public function setTargetUtilization($targetUtilization)
 544    {
 545      $this->targetUtilization = $targetUtilization;
 546    }
 547    public function getTargetUtilization()
 548    {
 549      return $this->targetUtilization;
 550    }
 551  }
 552  
 553  class Google_Service_Manager_AutoscalingModuleStatus extends Google_Model
 554  {
 555    protected $internal_gapi_mappings = array(
 556    );
 557    public $autoscalingConfigUrl;
 558  
 559  
 560    public function setAutoscalingConfigUrl($autoscalingConfigUrl)
 561    {
 562      $this->autoscalingConfigUrl = $autoscalingConfigUrl;
 563    }
 564    public function getAutoscalingConfigUrl()
 565    {
 566      return $this->autoscalingConfigUrl;
 567    }
 568  }
 569  
 570  class Google_Service_Manager_DeployState extends Google_Model
 571  {
 572    protected $internal_gapi_mappings = array(
 573    );
 574    public $details;
 575    public $status;
 576  
 577  
 578    public function setDetails($details)
 579    {
 580      $this->details = $details;
 581    }
 582    public function getDetails()
 583    {
 584      return $this->details;
 585    }
 586    public function setStatus($status)
 587    {
 588      $this->status = $status;
 589    }
 590    public function getStatus()
 591    {
 592      return $this->status;
 593    }
 594  }
 595  
 596  class Google_Service_Manager_Deployment extends Google_Collection
 597  {
 598    protected $collection_key = 'overrides';
 599    protected $internal_gapi_mappings = array(
 600    );
 601    public $creationDate;
 602    public $description;
 603    protected $modulesType = 'Google_Service_Manager_ModuleStatus';
 604    protected $modulesDataType = 'map';
 605    public $name;
 606    protected $overridesType = 'Google_Service_Manager_ParamOverride';
 607    protected $overridesDataType = 'array';
 608    protected $stateType = 'Google_Service_Manager_DeployState';
 609    protected $stateDataType = '';
 610    public $templateName;
 611  
 612  
 613    public function setCreationDate($creationDate)
 614    {
 615      $this->creationDate = $creationDate;
 616    }
 617    public function getCreationDate()
 618    {
 619      return $this->creationDate;
 620    }
 621    public function setDescription($description)
 622    {
 623      $this->description = $description;
 624    }
 625    public function getDescription()
 626    {
 627      return $this->description;
 628    }
 629    public function setModules($modules)
 630    {
 631      $this->modules = $modules;
 632    }
 633    public function getModules()
 634    {
 635      return $this->modules;
 636    }
 637    public function setName($name)
 638    {
 639      $this->name = $name;
 640    }
 641    public function getName()
 642    {
 643      return $this->name;
 644    }
 645    public function setOverrides($overrides)
 646    {
 647      $this->overrides = $overrides;
 648    }
 649    public function getOverrides()
 650    {
 651      return $this->overrides;
 652    }
 653    public function setState(Google_Service_Manager_DeployState $state)
 654    {
 655      $this->state = $state;
 656    }
 657    public function getState()
 658    {
 659      return $this->state;
 660    }
 661    public function setTemplateName($templateName)
 662    {
 663      $this->templateName = $templateName;
 664    }
 665    public function getTemplateName()
 666    {
 667      return $this->templateName;
 668    }
 669  }
 670  
 671  class Google_Service_Manager_DeploymentModules extends Google_Model
 672  {
 673  }
 674  
 675  class Google_Service_Manager_DeploymentsListResponse extends Google_Collection
 676  {
 677    protected $collection_key = 'resources';
 678    protected $internal_gapi_mappings = array(
 679    );
 680    public $nextPageToken;
 681    protected $resourcesType = 'Google_Service_Manager_Deployment';
 682    protected $resourcesDataType = 'array';
 683  
 684  
 685    public function setNextPageToken($nextPageToken)
 686    {
 687      $this->nextPageToken = $nextPageToken;
 688    }
 689    public function getNextPageToken()
 690    {
 691      return $this->nextPageToken;
 692    }
 693    public function setResources($resources)
 694    {
 695      $this->resources = $resources;
 696    }
 697    public function getResources()
 698    {
 699      return $this->resources;
 700    }
 701  }
 702  
 703  class Google_Service_Manager_DiskAttachment extends Google_Model
 704  {
 705    protected $internal_gapi_mappings = array(
 706    );
 707    public $deviceName;
 708    public $index;
 709  
 710  
 711    public function setDeviceName($deviceName)
 712    {
 713      $this->deviceName = $deviceName;
 714    }
 715    public function getDeviceName()
 716    {
 717      return $this->deviceName;
 718    }
 719    public function setIndex($index)
 720    {
 721      $this->index = $index;
 722    }
 723    public function getIndex()
 724    {
 725      return $this->index;
 726    }
 727  }
 728  
 729  class Google_Service_Manager_EnvVariable extends Google_Model
 730  {
 731    protected $internal_gapi_mappings = array(
 732    );
 733    public $hidden;
 734    public $value;
 735  
 736  
 737    public function setHidden($hidden)
 738    {
 739      $this->hidden = $hidden;
 740    }
 741    public function getHidden()
 742    {
 743      return $this->hidden;
 744    }
 745    public function setValue($value)
 746    {
 747      $this->value = $value;
 748    }
 749    public function getValue()
 750    {
 751      return $this->value;
 752    }
 753  }
 754  
 755  class Google_Service_Manager_ExistingDisk extends Google_Model
 756  {
 757    protected $internal_gapi_mappings = array(
 758    );
 759    protected $attachmentType = 'Google_Service_Manager_DiskAttachment';
 760    protected $attachmentDataType = '';
 761    public $source;
 762  
 763  
 764    public function setAttachment(Google_Service_Manager_DiskAttachment $attachment)
 765    {
 766      $this->attachment = $attachment;
 767    }
 768    public function getAttachment()
 769    {
 770      return $this->attachment;
 771    }
 772    public function setSource($source)
 773    {
 774      $this->source = $source;
 775    }
 776    public function getSource()
 777    {
 778      return $this->source;
 779    }
 780  }
 781  
 782  class Google_Service_Manager_FirewallModule extends Google_Collection
 783  {
 784    protected $collection_key = 'targetTags';
 785    protected $internal_gapi_mappings = array(
 786    );
 787    protected $allowedType = 'Google_Service_Manager_AllowedRule';
 788    protected $allowedDataType = 'array';
 789    public $description;
 790    public $network;
 791    public $sourceRanges;
 792    public $sourceTags;
 793    public $targetTags;
 794  
 795  
 796    public function setAllowed($allowed)
 797    {
 798      $this->allowed = $allowed;
 799    }
 800    public function getAllowed()
 801    {
 802      return $this->allowed;
 803    }
 804    public function setDescription($description)
 805    {
 806      $this->description = $description;
 807    }
 808    public function getDescription()
 809    {
 810      return $this->description;
 811    }
 812    public function setNetwork($network)
 813    {
 814      $this->network = $network;
 815    }
 816    public function getNetwork()
 817    {
 818      return $this->network;
 819    }
 820    public function setSourceRanges($sourceRanges)
 821    {
 822      $this->sourceRanges = $sourceRanges;
 823    }
 824    public function getSourceRanges()
 825    {
 826      return $this->sourceRanges;
 827    }
 828    public function setSourceTags($sourceTags)
 829    {
 830      $this->sourceTags = $sourceTags;
 831    }
 832    public function getSourceTags()
 833    {
 834      return $this->sourceTags;
 835    }
 836    public function setTargetTags($targetTags)
 837    {
 838      $this->targetTags = $targetTags;
 839    }
 840    public function getTargetTags()
 841    {
 842      return $this->targetTags;
 843    }
 844  }
 845  
 846  class Google_Service_Manager_FirewallModuleStatus extends Google_Model
 847  {
 848    protected $internal_gapi_mappings = array(
 849    );
 850    public $firewallUrl;
 851  
 852  
 853    public function setFirewallUrl($firewallUrl)
 854    {
 855      $this->firewallUrl = $firewallUrl;
 856    }
 857    public function getFirewallUrl()
 858    {
 859      return $this->firewallUrl;
 860    }
 861  }
 862  
 863  class Google_Service_Manager_HealthCheckModule extends Google_Model
 864  {
 865    protected $internal_gapi_mappings = array(
 866    );
 867    public $checkIntervalSec;
 868    public $description;
 869    public $healthyThreshold;
 870    public $host;
 871    public $path;
 872    public $port;
 873    public $timeoutSec;
 874    public $unhealthyThreshold;
 875  
 876  
 877    public function setCheckIntervalSec($checkIntervalSec)
 878    {
 879      $this->checkIntervalSec = $checkIntervalSec;
 880    }
 881    public function getCheckIntervalSec()
 882    {
 883      return $this->checkIntervalSec;
 884    }
 885    public function setDescription($description)
 886    {
 887      $this->description = $description;
 888    }
 889    public function getDescription()
 890    {
 891      return $this->description;
 892    }
 893    public function setHealthyThreshold($healthyThreshold)
 894    {
 895      $this->healthyThreshold = $healthyThreshold;
 896    }
 897    public function getHealthyThreshold()
 898    {
 899      return $this->healthyThreshold;
 900    }
 901    public function setHost($host)
 902    {
 903      $this->host = $host;
 904    }
 905    public function getHost()
 906    {
 907      return $this->host;
 908    }
 909    public function setPath($path)
 910    {
 911      $this->path = $path;
 912    }
 913    public function getPath()
 914    {
 915      return $this->path;
 916    }
 917    public function setPort($port)
 918    {
 919      $this->port = $port;
 920    }
 921    public function getPort()
 922    {
 923      return $this->port;
 924    }
 925    public function setTimeoutSec($timeoutSec)
 926    {
 927      $this->timeoutSec = $timeoutSec;
 928    }
 929    public function getTimeoutSec()
 930    {
 931      return $this->timeoutSec;
 932    }
 933    public function setUnhealthyThreshold($unhealthyThreshold)
 934    {
 935      $this->unhealthyThreshold = $unhealthyThreshold;
 936    }
 937    public function getUnhealthyThreshold()
 938    {
 939      return $this->unhealthyThreshold;
 940    }
 941  }
 942  
 943  class Google_Service_Manager_HealthCheckModuleStatus extends Google_Model
 944  {
 945    protected $internal_gapi_mappings = array(
 946    );
 947    public $healthCheckUrl;
 948  
 949  
 950    public function setHealthCheckUrl($healthCheckUrl)
 951    {
 952      $this->healthCheckUrl = $healthCheckUrl;
 953    }
 954    public function getHealthCheckUrl()
 955    {
 956      return $this->healthCheckUrl;
 957    }
 958  }
 959  
 960  class Google_Service_Manager_LbModule extends Google_Collection
 961  {
 962    protected $collection_key = 'targetModules';
 963    protected $internal_gapi_mappings = array(
 964    );
 965    public $description;
 966    public $healthChecks;
 967    public $ipAddress;
 968    public $ipProtocol;
 969    public $portRange;
 970    public $sessionAffinity;
 971    public $targetModules;
 972  
 973  
 974    public function setDescription($description)
 975    {
 976      $this->description = $description;
 977    }
 978    public function getDescription()
 979    {
 980      return $this->description;
 981    }
 982    public function setHealthChecks($healthChecks)
 983    {
 984      $this->healthChecks = $healthChecks;
 985    }
 986    public function getHealthChecks()
 987    {
 988      return $this->healthChecks;
 989    }
 990    public function setIpAddress($ipAddress)
 991    {
 992      $this->ipAddress = $ipAddress;
 993    }
 994    public function getIpAddress()
 995    {
 996      return $this->ipAddress;
 997    }
 998    public function setIpProtocol($ipProtocol)
 999    {
1000      $this->ipProtocol = $ipProtocol;
1001    }
1002    public function getIpProtocol()
1003    {
1004      return $this->ipProtocol;
1005    }
1006    public function setPortRange($portRange)
1007    {
1008      $this->portRange = $portRange;
1009    }
1010    public function getPortRange()
1011    {
1012      return $this->portRange;
1013    }
1014    public function setSessionAffinity($sessionAffinity)
1015    {
1016      $this->sessionAffinity = $sessionAffinity;
1017    }
1018    public function getSessionAffinity()
1019    {
1020      return $this->sessionAffinity;
1021    }
1022    public function setTargetModules($targetModules)
1023    {
1024      $this->targetModules = $targetModules;
1025    }
1026    public function getTargetModules()
1027    {
1028      return $this->targetModules;
1029    }
1030  }
1031  
1032  class Google_Service_Manager_LbModuleStatus extends Google_Model
1033  {
1034    protected $internal_gapi_mappings = array(
1035    );
1036    public $forwardingRuleUrl;
1037    public $targetPoolUrl;
1038  
1039  
1040    public function setForwardingRuleUrl($forwardingRuleUrl)
1041    {
1042      $this->forwardingRuleUrl = $forwardingRuleUrl;
1043    }
1044    public function getForwardingRuleUrl()
1045    {
1046      return $this->forwardingRuleUrl;
1047    }
1048    public function setTargetPoolUrl($targetPoolUrl)
1049    {
1050      $this->targetPoolUrl = $targetPoolUrl;
1051    }
1052    public function getTargetPoolUrl()
1053    {
1054      return $this->targetPoolUrl;
1055    }
1056  }
1057  
1058  class Google_Service_Manager_Metadata extends Google_Collection
1059  {
1060    protected $collection_key = 'items';
1061    protected $internal_gapi_mappings = array(
1062    );
1063    public $fingerPrint;
1064    protected $itemsType = 'Google_Service_Manager_MetadataItem';
1065    protected $itemsDataType = 'array';
1066  
1067  
1068    public function setFingerPrint($fingerPrint)
1069    {
1070      $this->fingerPrint = $fingerPrint;
1071    }
1072    public function getFingerPrint()
1073    {
1074      return $this->fingerPrint;
1075    }
1076    public function setItems($items)
1077    {
1078      $this->items = $items;
1079    }
1080    public function getItems()
1081    {
1082      return $this->items;
1083    }
1084  }
1085  
1086  class Google_Service_Manager_MetadataItem extends Google_Model
1087  {
1088    protected $internal_gapi_mappings = array(
1089    );
1090    public $key;
1091    public $value;
1092  
1093  
1094    public function setKey($key)
1095    {
1096      $this->key = $key;
1097    }
1098    public function getKey()
1099    {
1100      return $this->key;
1101    }
1102    public function setValue($value)
1103    {
1104      $this->value = $value;
1105    }
1106    public function getValue()
1107    {
1108      return $this->value;
1109    }
1110  }
1111  
1112  class Google_Service_Manager_Module extends Google_Model
1113  {
1114    protected $internal_gapi_mappings = array(
1115    );
1116    protected $autoscalingModuleType = 'Google_Service_Manager_AutoscalingModule';
1117    protected $autoscalingModuleDataType = '';
1118    protected $firewallModuleType = 'Google_Service_Manager_FirewallModule';
1119    protected $firewallModuleDataType = '';
1120    protected $healthCheckModuleType = 'Google_Service_Manager_HealthCheckModule';
1121    protected $healthCheckModuleDataType = '';
1122    protected $lbModuleType = 'Google_Service_Manager_LbModule';
1123    protected $lbModuleDataType = '';
1124    protected $networkModuleType = 'Google_Service_Manager_NetworkModule';
1125    protected $networkModuleDataType = '';
1126    protected $replicaPoolModuleType = 'Google_Service_Manager_ReplicaPoolModule';
1127    protected $replicaPoolModuleDataType = '';
1128    public $type;
1129  
1130  
1131    public function setAutoscalingModule(Google_Service_Manager_AutoscalingModule $autoscalingModule)
1132    {
1133      $this->autoscalingModule = $autoscalingModule;
1134    }
1135    public function getAutoscalingModule()
1136    {
1137      return $this->autoscalingModule;
1138    }
1139    public function setFirewallModule(Google_Service_Manager_FirewallModule $firewallModule)
1140    {
1141      $this->firewallModule = $firewallModule;
1142    }
1143    public function getFirewallModule()
1144    {
1145      return $this->firewallModule;
1146    }
1147    public function setHealthCheckModule(Google_Service_Manager_HealthCheckModule $healthCheckModule)
1148    {
1149      $this->healthCheckModule = $healthCheckModule;
1150    }
1151    public function getHealthCheckModule()
1152    {
1153      return $this->healthCheckModule;
1154    }
1155    public function setLbModule(Google_Service_Manager_LbModule $lbModule)
1156    {
1157      $this->lbModule = $lbModule;
1158    }
1159    public function getLbModule()
1160    {
1161      return $this->lbModule;
1162    }
1163    public function setNetworkModule(Google_Service_Manager_NetworkModule $networkModule)
1164    {
1165      $this->networkModule = $networkModule;
1166    }
1167    public function getNetworkModule()
1168    {
1169      return $this->networkModule;
1170    }
1171    public function setReplicaPoolModule(Google_Service_Manager_ReplicaPoolModule $replicaPoolModule)
1172    {
1173      $this->replicaPoolModule = $replicaPoolModule;
1174    }
1175    public function getReplicaPoolModule()
1176    {
1177      return $this->replicaPoolModule;
1178    }
1179    public function setType($type)
1180    {
1181      $this->type = $type;
1182    }
1183    public function getType()
1184    {
1185      return $this->type;
1186    }
1187  }
1188  
1189  class Google_Service_Manager_ModuleStatus extends Google_Model
1190  {
1191    protected $internal_gapi_mappings = array(
1192    );
1193    protected $autoscalingModuleStatusType = 'Google_Service_Manager_AutoscalingModuleStatus';
1194    protected $autoscalingModuleStatusDataType = '';
1195    protected $firewallModuleStatusType = 'Google_Service_Manager_FirewallModuleStatus';
1196    protected $firewallModuleStatusDataType = '';
1197    protected $healthCheckModuleStatusType = 'Google_Service_Manager_HealthCheckModuleStatus';
1198    protected $healthCheckModuleStatusDataType = '';
1199    protected $lbModuleStatusType = 'Google_Service_Manager_LbModuleStatus';
1200    protected $lbModuleStatusDataType = '';
1201    protected $networkModuleStatusType = 'Google_Service_Manager_NetworkModuleStatus';
1202    protected $networkModuleStatusDataType = '';
1203    protected $replicaPoolModuleStatusType = 'Google_Service_Manager_ReplicaPoolModuleStatus';
1204    protected $replicaPoolModuleStatusDataType = '';
1205    protected $stateType = 'Google_Service_Manager_DeployState';
1206    protected $stateDataType = '';
1207    public $type;
1208  
1209  
1210    public function setAutoscalingModuleStatus(Google_Service_Manager_AutoscalingModuleStatus $autoscalingModuleStatus)
1211    {
1212      $this->autoscalingModuleStatus = $autoscalingModuleStatus;
1213    }
1214    public function getAutoscalingModuleStatus()
1215    {
1216      return $this->autoscalingModuleStatus;
1217    }
1218    public function setFirewallModuleStatus(Google_Service_Manager_FirewallModuleStatus $firewallModuleStatus)
1219    {
1220      $this->firewallModuleStatus = $firewallModuleStatus;
1221    }
1222    public function getFirewallModuleStatus()
1223    {
1224      return $this->firewallModuleStatus;
1225    }
1226    public function setHealthCheckModuleStatus(Google_Service_Manager_HealthCheckModuleStatus $healthCheckModuleStatus)
1227    {
1228      $this->healthCheckModuleStatus = $healthCheckModuleStatus;
1229    }
1230    public function getHealthCheckModuleStatus()
1231    {
1232      return $this->healthCheckModuleStatus;
1233    }
1234    public function setLbModuleStatus(Google_Service_Manager_LbModuleStatus $lbModuleStatus)
1235    {
1236      $this->lbModuleStatus = $lbModuleStatus;
1237    }
1238    public function getLbModuleStatus()
1239    {
1240      return $this->lbModuleStatus;
1241    }
1242    public function setNetworkModuleStatus(Google_Service_Manager_NetworkModuleStatus $networkModuleStatus)
1243    {
1244      $this->networkModuleStatus = $networkModuleStatus;
1245    }
1246    public function getNetworkModuleStatus()
1247    {
1248      return $this->networkModuleStatus;
1249    }
1250    public function setReplicaPoolModuleStatus(Google_Service_Manager_ReplicaPoolModuleStatus $replicaPoolModuleStatus)
1251    {
1252      $this->replicaPoolModuleStatus = $replicaPoolModuleStatus;
1253    }
1254    public function getReplicaPoolModuleStatus()
1255    {
1256      return $this->replicaPoolModuleStatus;
1257    }
1258    public function setState(Google_Service_Manager_DeployState $state)
1259    {
1260      $this->state = $state;
1261    }
1262    public function getState()
1263    {
1264      return $this->state;
1265    }
1266    public function setType($type)
1267    {
1268      $this->type = $type;
1269    }
1270    public function getType()
1271    {
1272      return $this->type;
1273    }
1274  }
1275  
1276  class Google_Service_Manager_NetworkInterface extends Google_Collection
1277  {
1278    protected $collection_key = 'accessConfigs';
1279    protected $internal_gapi_mappings = array(
1280    );
1281    protected $accessConfigsType = 'Google_Service_Manager_AccessConfig';
1282    protected $accessConfigsDataType = 'array';
1283    public $name;
1284    public $network;
1285    public $networkIp;
1286  
1287  
1288    public function setAccessConfigs($accessConfigs)
1289    {
1290      $this->accessConfigs = $accessConfigs;
1291    }
1292    public function getAccessConfigs()
1293    {
1294      return $this->accessConfigs;
1295    }
1296    public function setName($name)
1297    {
1298      $this->name = $name;
1299    }
1300    public function getName()
1301    {
1302      return $this->name;
1303    }
1304    public function setNetwork($network)
1305    {
1306      $this->network = $network;
1307    }
1308    public function getNetwork()
1309    {
1310      return $this->network;
1311    }
1312    public function setNetworkIp($networkIp)
1313    {
1314      $this->networkIp = $networkIp;
1315    }
1316    public function getNetworkIp()
1317    {
1318      return $this->networkIp;
1319    }
1320  }
1321  
1322  class Google_Service_Manager_NetworkModule extends Google_Model
1323  {
1324    protected $internal_gapi_mappings = array(
1325          "iPv4Range" => "IPv4Range",
1326    );
1327    public $iPv4Range;
1328    public $description;
1329    public $gatewayIPv4;
1330  
1331  
1332    public function setIPv4Range($iPv4Range)
1333    {
1334      $this->iPv4Range = $iPv4Range;
1335    }
1336    public function getIPv4Range()
1337    {
1338      return $this->iPv4Range;
1339    }
1340    public function setDescription($description)
1341    {
1342      $this->description = $description;
1343    }
1344    public function getDescription()
1345    {
1346      return $this->description;
1347    }
1348    public function setGatewayIPv4($gatewayIPv4)
1349    {
1350      $this->gatewayIPv4 = $gatewayIPv4;
1351    }
1352    public function getGatewayIPv4()
1353    {
1354      return $this->gatewayIPv4;
1355    }
1356  }
1357  
1358  class Google_Service_Manager_NetworkModuleStatus extends Google_Model
1359  {
1360    protected $internal_gapi_mappings = array(
1361    );
1362    public $networkUrl;
1363  
1364  
1365    public function setNetworkUrl($networkUrl)
1366    {
1367      $this->networkUrl = $networkUrl;
1368    }
1369    public function getNetworkUrl()
1370    {
1371      return $this->networkUrl;
1372    }
1373  }
1374  
1375  class Google_Service_Manager_NewDisk extends Google_Model
1376  {
1377    protected $internal_gapi_mappings = array(
1378    );
1379    protected $attachmentType = 'Google_Service_Manager_DiskAttachment';
1380    protected $attachmentDataType = '';
1381    public $autoDelete;
1382    public $boot;
1383    protected $initializeParamsType = 'Google_Service_Manager_NewDiskInitializeParams';
1384    protected $initializeParamsDataType = '';
1385  
1386  
1387    public function setAttachment(Google_Service_Manager_DiskAttachment $attachment)
1388    {
1389      $this->attachment = $attachment;
1390    }
1391    public function getAttachment()
1392    {
1393      return $this->attachment;
1394    }
1395    public function setAutoDelete($autoDelete)
1396    {
1397      $this->autoDelete = $autoDelete;
1398    }
1399    public function getAutoDelete()
1400    {
1401      return $this->autoDelete;
1402    }
1403    public function setBoot($boot)
1404    {
1405      $this->boot = $boot;
1406    }
1407    public function getBoot()
1408    {
1409      return $this->boot;
1410    }
1411    public function setInitializeParams(Google_Service_Manager_NewDiskInitializeParams $initializeParams)
1412    {
1413      $this->initializeParams = $initializeParams;
1414    }
1415    public function getInitializeParams()
1416    {
1417      return $this->initializeParams;
1418    }
1419  }
1420  
1421  class Google_Service_Manager_NewDiskInitializeParams extends Google_Model
1422  {
1423    protected $internal_gapi_mappings = array(
1424    );
1425    public $diskSizeGb;
1426    public $diskType;
1427    public $sourceImage;
1428  
1429  
1430    public function setDiskSizeGb($diskSizeGb)
1431    {
1432      $this->diskSizeGb = $diskSizeGb;
1433    }
1434    public function getDiskSizeGb()
1435    {
1436      return $this->diskSizeGb;
1437    }
1438    public function setDiskType($diskType)
1439    {
1440      $this->diskType = $diskType;
1441    }
1442    public function getDiskType()
1443    {
1444      return $this->diskType;
1445    }
1446    public function setSourceImage($sourceImage)
1447    {
1448      $this->sourceImage = $sourceImage;
1449    }
1450    public function getSourceImage()
1451    {
1452      return $this->sourceImage;
1453    }
1454  }
1455  
1456  class Google_Service_Manager_ParamOverride extends Google_Model
1457  {
1458    protected $internal_gapi_mappings = array(
1459    );
1460    public $path;
1461    public $value;
1462  
1463  
1464    public function setPath($path)
1465    {
1466      $this->path = $path;
1467    }
1468    public function getPath()
1469    {
1470      return $this->path;
1471    }
1472    public function setValue($value)
1473    {
1474      $this->value = $value;
1475    }
1476    public function getValue()
1477    {
1478      return $this->value;
1479    }
1480  }
1481  
1482  class Google_Service_Manager_ReplicaPoolModule extends Google_Collection
1483  {
1484    protected $collection_key = 'healthChecks';
1485    protected $internal_gapi_mappings = array(
1486    );
1487    protected $envVariablesType = 'Google_Service_Manager_EnvVariable';
1488    protected $envVariablesDataType = 'map';
1489    public $healthChecks;
1490    public $numReplicas;
1491    protected $replicaPoolParamsType = 'Google_Service_Manager_ReplicaPoolParams';
1492    protected $replicaPoolParamsDataType = '';
1493    public $resourceView;
1494  
1495  
1496    public function setEnvVariables($envVariables)
1497    {
1498      $this->envVariables = $envVariables;
1499    }
1500    public function getEnvVariables()
1501    {
1502      return $this->envVariables;
1503    }
1504    public function setHealthChecks($healthChecks)
1505    {
1506      $this->healthChecks = $healthChecks;
1507    }
1508    public function getHealthChecks()
1509    {
1510      return $this->healthChecks;
1511    }
1512    public function setNumReplicas($numReplicas)
1513    {
1514      $this->numReplicas = $numReplicas;
1515    }
1516    public function getNumReplicas()
1517    {
1518      return $this->numReplicas;
1519    }
1520    public function setReplicaPoolParams(Google_Service_Manager_ReplicaPoolParams $replicaPoolParams)
1521    {
1522      $this->replicaPoolParams = $replicaPoolParams;
1523    }
1524    public function getReplicaPoolParams()
1525    {
1526      return $this->replicaPoolParams;
1527    }
1528    public function setResourceView($resourceView)
1529    {
1530      $this->resourceView = $resourceView;
1531    }
1532    public function getResourceView()
1533    {
1534      return $this->resourceView;
1535    }
1536  }
1537  
1538  class Google_Service_Manager_ReplicaPoolModuleEnvVariables extends Google_Model
1539  {
1540  }
1541  
1542  class Google_Service_Manager_ReplicaPoolModuleStatus extends Google_Model
1543  {
1544    protected $internal_gapi_mappings = array(
1545    );
1546    public $replicaPoolUrl;
1547    public $resourceViewUrl;
1548  
1549  
1550    public function setReplicaPoolUrl($replicaPoolUrl)
1551    {
1552      $this->replicaPoolUrl = $replicaPoolUrl;
1553    }
1554    public function getReplicaPoolUrl()
1555    {
1556      return $this->replicaPoolUrl;
1557    }
1558    public function setResourceViewUrl($resourceViewUrl)
1559    {
1560      $this->resourceViewUrl = $resourceViewUrl;
1561    }
1562    public function getResourceViewUrl()
1563    {
1564      return $this->resourceViewUrl;
1565    }
1566  }
1567  
1568  class Google_Service_Manager_ReplicaPoolParams extends Google_Model
1569  {
1570    protected $internal_gapi_mappings = array(
1571    );
1572    protected $v1beta1Type = 'Google_Service_Manager_ReplicaPoolParamsV1Beta1';
1573    protected $v1beta1DataType = '';
1574  
1575  
1576    public function setV1beta1(Google_Service_Manager_ReplicaPoolParamsV1Beta1 $v1beta1)
1577    {
1578      $this->v1beta1 = $v1beta1;
1579    }
1580    public function getV1beta1()
1581    {
1582      return $this->v1beta1;
1583    }
1584  }
1585  
1586  class Google_Service_Manager_ReplicaPoolParamsV1Beta1 extends Google_Collection
1587  {
1588    protected $collection_key = 'serviceAccounts';
1589    protected $internal_gapi_mappings = array(
1590    );
1591    public $autoRestart;
1592    public $baseInstanceName;
1593    public $canIpForward;
1594    public $description;
1595    protected $disksToAttachType = 'Google_Service_Manager_ExistingDisk';
1596    protected $disksToAttachDataType = 'array';
1597    protected $disksToCreateType = 'Google_Service_Manager_NewDisk';
1598    protected $disksToCreateDataType = 'array';
1599    public $initAction;
1600    public $machineType;
1601    protected $metadataType = 'Google_Service_Manager_Metadata';
1602    protected $metadataDataType = '';
1603    protected $networkInterfacesType = 'Google_Service_Manager_NetworkInterface';
1604    protected $networkInterfacesDataType = 'array';
1605    public $onHostMaintenance;
1606    protected $serviceAccountsType = 'Google_Service_Manager_ServiceAccount';
1607    protected $serviceAccountsDataType = 'array';
1608    protected $tagsType = 'Google_Service_Manager_Tag';
1609    protected $tagsDataType = '';
1610    public $zone;
1611  
1612  
1613    public function setAutoRestart($autoRestart)
1614    {
1615      $this->autoRestart = $autoRestart;
1616    }
1617    public function getAutoRestart()
1618    {
1619      return $this->autoRestart;
1620    }
1621    public function setBaseInstanceName($baseInstanceName)
1622    {
1623      $this->baseInstanceName = $baseInstanceName;
1624    }
1625    public function getBaseInstanceName()
1626    {
1627      return $this->baseInstanceName;
1628    }
1629    public function setCanIpForward($canIpForward)
1630    {
1631      $this->canIpForward = $canIpForward;
1632    }
1633    public function getCanIpForward()
1634    {
1635      return $this->canIpForward;
1636    }
1637    public function setDescription($description)
1638    {
1639      $this->description = $description;
1640    }
1641    public function getDescription()
1642    {
1643      return $this->description;
1644    }
1645    public function setDisksToAttach($disksToAttach)
1646    {
1647      $this->disksToAttach = $disksToAttach;
1648    }
1649    public function getDisksToAttach()
1650    {
1651      return $this->disksToAttach;
1652    }
1653    public function setDisksToCreate($disksToCreate)
1654    {
1655      $this->disksToCreate = $disksToCreate;
1656    }
1657    public function getDisksToCreate()
1658    {
1659      return $this->disksToCreate;
1660    }
1661    public function setInitAction($initAction)
1662    {
1663      $this->initAction = $initAction;
1664    }
1665    public function getInitAction()
1666    {
1667      return $this->initAction;
1668    }
1669    public function setMachineType($machineType)
1670    {
1671      $this->machineType = $machineType;
1672    }
1673    public function getMachineType()
1674    {
1675      return $this->machineType;
1676    }
1677    public function setMetadata(Google_Service_Manager_Metadata $metadata)
1678    {
1679      $this->metadata = $metadata;
1680    }
1681    public function getMetadata()
1682    {
1683      return $this->metadata;
1684    }
1685    public function setNetworkInterfaces($networkInterfaces)
1686    {
1687      $this->networkInterfaces = $networkInterfaces;
1688    }
1689    public function getNetworkInterfaces()
1690    {
1691      return $this->networkInterfaces;
1692    }
1693    public function setOnHostMaintenance($onHostMaintenance)
1694    {
1695      $this->onHostMaintenance = $onHostMaintenance;
1696    }
1697    public function getOnHostMaintenance()
1698    {
1699      return $this->onHostMaintenance;
1700    }
1701    public function setServiceAccounts($serviceAccounts)
1702    {
1703      $this->serviceAccounts = $serviceAccounts;
1704    }
1705    public function getServiceAccounts()
1706    {
1707      return $this->serviceAccounts;
1708    }
1709    public function setTags(Google_Service_Manager_Tag $tags)
1710    {
1711      $this->tags = $tags;
1712    }
1713    public function getTags()
1714    {
1715      return $this->tags;
1716    }
1717    public function setZone($zone)
1718    {
1719      $this->zone = $zone;
1720    }
1721    public function getZone()
1722    {
1723      return $this->zone;
1724    }
1725  }
1726  
1727  class Google_Service_Manager_ServiceAccount extends Google_Collection
1728  {
1729    protected $collection_key = 'scopes';
1730    protected $internal_gapi_mappings = array(
1731    );
1732    public $email;
1733    public $scopes;
1734  
1735  
1736    public function setEmail($email)
1737    {
1738      $this->email = $email;
1739    }
1740    public function getEmail()
1741    {
1742      return $this->email;
1743    }
1744    public function setScopes($scopes)
1745    {
1746      $this->scopes = $scopes;
1747    }
1748    public function getScopes()
1749    {
1750      return $this->scopes;
1751    }
1752  }
1753  
1754  class Google_Service_Manager_Tag extends Google_Collection
1755  {
1756    protected $collection_key = 'items';
1757    protected $internal_gapi_mappings = array(
1758    );
1759    public $fingerPrint;
1760    public $items;
1761  
1762  
1763    public function setFingerPrint($fingerPrint)
1764    {
1765      $this->fingerPrint = $fingerPrint;
1766    }
1767    public function getFingerPrint()
1768    {
1769      return $this->fingerPrint;
1770    }
1771    public function setItems($items)
1772    {
1773      $this->items = $items;
1774    }
1775    public function getItems()
1776    {
1777      return $this->items;
1778    }
1779  }
1780  
1781  class Google_Service_Manager_Template extends Google_Model
1782  {
1783    protected $internal_gapi_mappings = array(
1784    );
1785    protected $actionsType = 'Google_Service_Manager_Action';
1786    protected $actionsDataType = 'map';
1787    public $description;
1788    protected $modulesType = 'Google_Service_Manager_Module';
1789    protected $modulesDataType = 'map';
1790    public $name;
1791  
1792  
1793    public function setActions($actions)
1794    {
1795      $this->actions = $actions;
1796    }
1797    public function getActions()
1798    {
1799      return $this->actions;
1800    }
1801    public function setDescription($description)
1802    {
1803      $this->description = $description;
1804    }
1805    public function getDescription()
1806    {
1807      return $this->description;
1808    }
1809    public function setModules($modules)
1810    {
1811      $this->modules = $modules;
1812    }
1813    public function getModules()
1814    {
1815      return $this->modules;
1816    }
1817    public function setName($name)
1818    {
1819      $this->name = $name;
1820    }
1821    public function getName()
1822    {
1823      return $this->name;
1824    }
1825  }
1826  
1827  class Google_Service_Manager_TemplateActions extends Google_Model
1828  {
1829  }
1830  
1831  class Google_Service_Manager_TemplateModules extends Google_Model
1832  {
1833  }
1834  
1835  class Google_Service_Manager_TemplatesListResponse extends Google_Collection
1836  {
1837    protected $collection_key = 'resources';
1838    protected $internal_gapi_mappings = array(
1839    );
1840    public $nextPageToken;
1841    protected $resourcesType = 'Google_Service_Manager_Template';
1842    protected $resourcesDataType = 'array';
1843  
1844  
1845    public function setNextPageToken($nextPageToken)
1846    {
1847      $this->nextPageToken = $nextPageToken;
1848    }
1849    public function getNextPageToken()
1850    {
1851      return $this->nextPageToken;
1852    }
1853    public function setResources($resources)
1854    {
1855      $this->resources = $resources;
1856    }
1857    public function getResources()
1858    {
1859      return $this->resources;
1860    }
1861  }