[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 Storagetransfer (v1).
  20   *
  21   * <p>
  22   * Transfers data from external data sources to a Google Cloud Storage bucket or
  23   * between Google Cloud Storage buckets.</p>
  24   *
  25   * <p>
  26   * For more information about this service, see the API
  27   * <a href="https://cloud.google.com/storage/transfer" target="_blank">Documentation</a>
  28   * </p>
  29   *
  30   * @author Google, Inc.
  31   */
  32  class Google_Service_Storagetransfer extends Google_Service
  33  {
  34    /** View and manage your data across Google Cloud Platform services. */
  35    const CLOUD_PLATFORM =
  36        "https://www.googleapis.com/auth/cloud-platform";
  37  
  38    public $googleServiceAccounts;
  39    public $transferJobs;
  40    public $transferOperations;
  41    public $v1;
  42    
  43  
  44    /**
  45     * Constructs the internal representation of the Storagetransfer service.
  46     *
  47     * @param Google_Client $client
  48     */
  49    public function __construct(Google_Client $client)
  50    {
  51      parent::__construct($client);
  52      $this->rootUrl = 'https://storagetransfer.googleapis.com/';
  53      $this->servicePath = '';
  54      $this->version = 'v1';
  55      $this->serviceName = 'storagetransfer';
  56  
  57      $this->googleServiceAccounts = new Google_Service_Storagetransfer_GoogleServiceAccounts_Resource(
  58          $this,
  59          $this->serviceName,
  60          'googleServiceAccounts',
  61          array(
  62            'methods' => array(
  63              'get' => array(
  64                'path' => 'v1/googleServiceAccounts/{projectId}',
  65                'httpMethod' => 'GET',
  66                'parameters' => array(
  67                  'projectId' => array(
  68                    'location' => 'path',
  69                    'type' => 'string',
  70                    'required' => true,
  71                  ),
  72                ),
  73              ),
  74            )
  75          )
  76      );
  77      $this->transferJobs = new Google_Service_Storagetransfer_TransferJobs_Resource(
  78          $this,
  79          $this->serviceName,
  80          'transferJobs',
  81          array(
  82            'methods' => array(
  83              'create' => array(
  84                'path' => 'v1/transferJobs',
  85                'httpMethod' => 'POST',
  86                'parameters' => array(),
  87              ),'get' => array(
  88                'path' => 'v1/{+jobName}',
  89                'httpMethod' => 'GET',
  90                'parameters' => array(
  91                  'jobName' => array(
  92                    'location' => 'path',
  93                    'type' => 'string',
  94                    'required' => true,
  95                  ),
  96                  'projectId' => array(
  97                    'location' => 'query',
  98                    'type' => 'string',
  99                  ),
 100                ),
 101              ),'list' => array(
 102                'path' => 'v1/transferJobs',
 103                'httpMethod' => 'GET',
 104                'parameters' => array(
 105                  'filter' => array(
 106                    'location' => 'query',
 107                    'type' => 'string',
 108                  ),
 109                  'pageToken' => array(
 110                    'location' => 'query',
 111                    'type' => 'string',
 112                  ),
 113                  'pageSize' => array(
 114                    'location' => 'query',
 115                    'type' => 'integer',
 116                  ),
 117                ),
 118              ),'patch' => array(
 119                'path' => 'v1/{+jobName}',
 120                'httpMethod' => 'PATCH',
 121                'parameters' => array(
 122                  'jobName' => array(
 123                    'location' => 'path',
 124                    'type' => 'string',
 125                    'required' => true,
 126                  ),
 127                ),
 128              ),
 129            )
 130          )
 131      );
 132      $this->transferOperations = new Google_Service_Storagetransfer_TransferOperations_Resource(
 133          $this,
 134          $this->serviceName,
 135          'transferOperations',
 136          array(
 137            'methods' => array(
 138              'cancel' => array(
 139                'path' => 'v1/{+name}:cancel',
 140                'httpMethod' => 'POST',
 141                'parameters' => array(
 142                  'name' => array(
 143                    'location' => 'path',
 144                    'type' => 'string',
 145                    'required' => true,
 146                  ),
 147                ),
 148              ),'delete' => array(
 149                'path' => 'v1/{+name}',
 150                'httpMethod' => 'DELETE',
 151                'parameters' => array(
 152                  'name' => array(
 153                    'location' => 'path',
 154                    'type' => 'string',
 155                    'required' => true,
 156                  ),
 157                ),
 158              ),'get' => array(
 159                'path' => 'v1/{+name}',
 160                'httpMethod' => 'GET',
 161                'parameters' => array(
 162                  'name' => array(
 163                    'location' => 'path',
 164                    'type' => 'string',
 165                    'required' => true,
 166                  ),
 167                ),
 168              ),'list' => array(
 169                'path' => 'v1/{+name}',
 170                'httpMethod' => 'GET',
 171                'parameters' => array(
 172                  'name' => array(
 173                    'location' => 'path',
 174                    'type' => 'string',
 175                    'required' => true,
 176                  ),
 177                  'filter' => array(
 178                    'location' => 'query',
 179                    'type' => 'string',
 180                  ),
 181                  'pageToken' => array(
 182                    'location' => 'query',
 183                    'type' => 'string',
 184                  ),
 185                  'pageSize' => array(
 186                    'location' => 'query',
 187                    'type' => 'integer',
 188                  ),
 189                ),
 190              ),'pause' => array(
 191                'path' => 'v1/{+name}:pause',
 192                'httpMethod' => 'POST',
 193                'parameters' => array(
 194                  'name' => array(
 195                    'location' => 'path',
 196                    'type' => 'string',
 197                    'required' => true,
 198                  ),
 199                ),
 200              ),'resume' => array(
 201                'path' => 'v1/{+name}:resume',
 202                'httpMethod' => 'POST',
 203                'parameters' => array(
 204                  'name' => array(
 205                    'location' => 'path',
 206                    'type' => 'string',
 207                    'required' => true,
 208                  ),
 209                ),
 210              ),
 211            )
 212          )
 213      );
 214      $this->v1 = new Google_Service_Storagetransfer_V1_Resource(
 215          $this,
 216          $this->serviceName,
 217          'v1',
 218          array(
 219            'methods' => array(
 220              'getGoogleServiceAccount' => array(
 221                'path' => 'v1:getGoogleServiceAccount',
 222                'httpMethod' => 'GET',
 223                'parameters' => array(
 224                  'projectId' => array(
 225                    'location' => 'query',
 226                    'type' => 'string',
 227                  ),
 228                ),
 229              ),
 230            )
 231          )
 232      );
 233    }
 234  }
 235  
 236  
 237  /**
 238   * The "googleServiceAccounts" collection of methods.
 239   * Typical usage is:
 240   *  <code>
 241   *   $storagetransferService = new Google_Service_Storagetransfer(...);
 242   *   $googleServiceAccounts = $storagetransferService->googleServiceAccounts;
 243   *  </code>
 244   */
 245  class Google_Service_Storagetransfer_GoogleServiceAccounts_Resource extends Google_Service_Resource
 246  {
 247  
 248    /**
 249     * Returns the Google service account that is used by Storage Transfer Service
 250     * to access buckets in the project where transfers run or in other projects.
 251     * Each Google service account is associated with one Google Developers Console
 252     * project. Users should add this service account to the Google Cloud Storage
 253     * bucket ACLs to grant access to Storage Transfer Service. This service account
 254     * is created and owned by Storage Transfer Service and can only be used by
 255     * Storage Transfer Service. (googleServiceAccounts.get)
 256     *
 257     * @param string $projectId The ID of the Google Developers Console project that
 258     * the Google service account is associated with. Required.
 259     * @param array $optParams Optional parameters.
 260     * @return Google_Service_Storagetransfer_GoogleServiceAccount
 261     */
 262    public function get($projectId, $optParams = array())
 263    {
 264      $params = array('projectId' => $projectId);
 265      $params = array_merge($params, $optParams);
 266      return $this->call('get', array($params), "Google_Service_Storagetransfer_GoogleServiceAccount");
 267    }
 268  }
 269  
 270  /**
 271   * The "transferJobs" collection of methods.
 272   * Typical usage is:
 273   *  <code>
 274   *   $storagetransferService = new Google_Service_Storagetransfer(...);
 275   *   $transferJobs = $storagetransferService->transferJobs;
 276   *  </code>
 277   */
 278  class Google_Service_Storagetransfer_TransferJobs_Resource extends Google_Service_Resource
 279  {
 280  
 281    /**
 282     * Creates a transfer job that runs periodically. (transferJobs.create)
 283     *
 284     * @param Google_TransferJob $postBody
 285     * @param array $optParams Optional parameters.
 286     * @return Google_Service_Storagetransfer_TransferJob
 287     */
 288    public function create(Google_Service_Storagetransfer_TransferJob $postBody, $optParams = array())
 289    {
 290      $params = array('postBody' => $postBody);
 291      $params = array_merge($params, $optParams);
 292      return $this->call('create', array($params), "Google_Service_Storagetransfer_TransferJob");
 293    }
 294  
 295    /**
 296     * Gets a transfer job. (transferJobs.get)
 297     *
 298     * @param string $jobName The job to get. Required.
 299     * @param array $optParams Optional parameters.
 300     *
 301     * @opt_param string projectId The ID of the Google Developers Console project
 302     * that owns the job. Required.
 303     * @return Google_Service_Storagetransfer_TransferJob
 304     */
 305    public function get($jobName, $optParams = array())
 306    {
 307      $params = array('jobName' => $jobName);
 308      $params = array_merge($params, $optParams);
 309      return $this->call('get', array($params), "Google_Service_Storagetransfer_TransferJob");
 310    }
 311  
 312    /**
 313     * Lists transfer jobs. (transferJobs.listTransferJobs)
 314     *
 315     * @param array $optParams Optional parameters.
 316     *
 317     * @opt_param string filter A list of query parameters specified as JSON text in
 318     * the form of {"`project_id`":"my_project_id",
 319     * "`job_names`":["jobid1","jobid2",...],
 320     * "`job_statuses`":["status1","status2",...]}. Since `job_names` and
 321     * `job_statuses` support multiple values, their values must be specified with
 322     * array notation. `project_id` is required. `job_names` and `job_statuses` are
 323     * optional. The valid values for `job_statuses` are case-insensitive:
 324     * `ENABLED`, `DISABLED`, and `DELETED`.
 325     * @opt_param string pageToken The list page token.
 326     * @opt_param int pageSize The list page size. The max allowed value is 256.
 327     * @return Google_Service_Storagetransfer_ListTransferJobsResponse
 328     */
 329    public function listTransferJobs($optParams = array())
 330    {
 331      $params = array();
 332      $params = array_merge($params, $optParams);
 333      return $this->call('list', array($params), "Google_Service_Storagetransfer_ListTransferJobsResponse");
 334    }
 335  
 336    /**
 337     * Updates a transfer job. Updating a job's transfer spec does not affect
 338     * transfer operations that are running already. Updating the scheduling of a
 339     * job is not allowed. (transferJobs.patch)
 340     *
 341     * @param string $jobName The name of job to update. Required.
 342     * @param Google_UpdateTransferJobRequest $postBody
 343     * @param array $optParams Optional parameters.
 344     * @return Google_Service_Storagetransfer_TransferJob
 345     */
 346    public function patch($jobName, Google_Service_Storagetransfer_UpdateTransferJobRequest $postBody, $optParams = array())
 347    {
 348      $params = array('jobName' => $jobName, 'postBody' => $postBody);
 349      $params = array_merge($params, $optParams);
 350      return $this->call('patch', array($params), "Google_Service_Storagetransfer_TransferJob");
 351    }
 352  }
 353  
 354  /**
 355   * The "transferOperations" collection of methods.
 356   * Typical usage is:
 357   *  <code>
 358   *   $storagetransferService = new Google_Service_Storagetransfer(...);
 359   *   $transferOperations = $storagetransferService->transferOperations;
 360   *  </code>
 361   */
 362  class Google_Service_Storagetransfer_TransferOperations_Resource extends Google_Service_Resource
 363  {
 364  
 365    /**
 366     * Cancels a transfer. Use the get method to check whether the cancellation
 367     * succeeded or whether the operation completed despite cancellation.
 368     * (transferOperations.cancel)
 369     *
 370     * @param string $name The name of the operation resource to be cancelled.
 371     * @param array $optParams Optional parameters.
 372     * @return Google_Service_Storagetransfer_Empty
 373     */
 374    public function cancel($name, $optParams = array())
 375    {
 376      $params = array('name' => $name);
 377      $params = array_merge($params, $optParams);
 378      return $this->call('cancel', array($params), "Google_Service_Storagetransfer_Empty");
 379    }
 380  
 381    /**
 382     * This method is not supported and the server returns `UNIMPLEMENTED`.
 383     * (transferOperations.delete)
 384     *
 385     * @param string $name The name of the operation resource to be deleted.
 386     * @param array $optParams Optional parameters.
 387     * @return Google_Service_Storagetransfer_Empty
 388     */
 389    public function delete($name, $optParams = array())
 390    {
 391      $params = array('name' => $name);
 392      $params = array_merge($params, $optParams);
 393      return $this->call('delete', array($params), "Google_Service_Storagetransfer_Empty");
 394    }
 395  
 396    /**
 397     * Gets the latest state of a long-running operation. Clients can use this
 398     * method to poll the operation result at intervals as recommended by the API
 399     * service. (transferOperations.get)
 400     *
 401     * @param string $name The name of the operation resource.
 402     * @param array $optParams Optional parameters.
 403     * @return Google_Service_Storagetransfer_Operation
 404     */
 405    public function get($name, $optParams = array())
 406    {
 407      $params = array('name' => $name);
 408      $params = array_merge($params, $optParams);
 409      return $this->call('get', array($params), "Google_Service_Storagetransfer_Operation");
 410    }
 411  
 412    /**
 413     * Lists operations that match the specified filter in the request. If the
 414     * server doesn't support this method, it returns `UNIMPLEMENTED`. NOTE: the
 415     * `name` binding below allows API services to override the binding to use
 416     * different resource name schemes, such as `users/operations`.
 417     * (transferOperations.listTransferOperations)
 418     *
 419     * @param string $name The value `transferOperations`.
 420     * @param array $optParams Optional parameters.
 421     *
 422     * @opt_param string filter The standard list filter.
 423     * @opt_param string pageToken The standard list page token.
 424     * @opt_param int pageSize The standard list page size.
 425     * @return Google_Service_Storagetransfer_ListOperationsResponse
 426     */
 427    public function listTransferOperations($name, $optParams = array())
 428    {
 429      $params = array('name' => $name);
 430      $params = array_merge($params, $optParams);
 431      return $this->call('list', array($params), "Google_Service_Storagetransfer_ListOperationsResponse");
 432    }
 433  
 434    /**
 435     * Pauses a transfer operation. (transferOperations.pause)
 436     *
 437     * @param string $name The name of the transfer operation. Required.
 438     * @param Google_PauseTransferOperationRequest $postBody
 439     * @param array $optParams Optional parameters.
 440     * @return Google_Service_Storagetransfer_Empty
 441     */
 442    public function pause($name, Google_Service_Storagetransfer_PauseTransferOperationRequest $postBody, $optParams = array())
 443    {
 444      $params = array('name' => $name, 'postBody' => $postBody);
 445      $params = array_merge($params, $optParams);
 446      return $this->call('pause', array($params), "Google_Service_Storagetransfer_Empty");
 447    }
 448  
 449    /**
 450     * Resumes a transfer operation that is paused. (transferOperations.resume)
 451     *
 452     * @param string $name The name of the transfer operation. Required.
 453     * @param Google_ResumeTransferOperationRequest $postBody
 454     * @param array $optParams Optional parameters.
 455     * @return Google_Service_Storagetransfer_Empty
 456     */
 457    public function resume($name, Google_Service_Storagetransfer_ResumeTransferOperationRequest $postBody, $optParams = array())
 458    {
 459      $params = array('name' => $name, 'postBody' => $postBody);
 460      $params = array_merge($params, $optParams);
 461      return $this->call('resume', array($params), "Google_Service_Storagetransfer_Empty");
 462    }
 463  }
 464  
 465  /**
 466   * The "v1" collection of methods.
 467   * Typical usage is:
 468   *  <code>
 469   *   $storagetransferService = new Google_Service_Storagetransfer(...);
 470   *   $v1 = $storagetransferService->v1;
 471   *  </code>
 472   */
 473  class Google_Service_Storagetransfer_V1_Resource extends Google_Service_Resource
 474  {
 475  
 476    /**
 477     * Returns the Google service account that is used by Storage Transfer Service
 478     * to access buckets in the project where transfers run or in other projects.
 479     * Each Google service account is associated with one Google Developers Console
 480     * project. Users should add this service account to the Google Cloud Storage
 481     * bucket ACLs to grant access to Storage Transfer Service. This service account
 482     * is created and owned by Storage Transfer Service and can only be used by
 483     * Storage Transfer Service. (v1.getGoogleServiceAccount)
 484     *
 485     * @param array $optParams Optional parameters.
 486     *
 487     * @opt_param string projectId The ID of the Google Developers Console project
 488     * that the Google service account is associated with. Required.
 489     * @return Google_Service_Storagetransfer_GoogleServiceAccount
 490     */
 491    public function getGoogleServiceAccount($optParams = array())
 492    {
 493      $params = array();
 494      $params = array_merge($params, $optParams);
 495      return $this->call('getGoogleServiceAccount', array($params), "Google_Service_Storagetransfer_GoogleServiceAccount");
 496    }
 497  }
 498  
 499  
 500  
 501  
 502  class Google_Service_Storagetransfer_AwsAccessKey extends Google_Model
 503  {
 504    protected $internal_gapi_mappings = array(
 505    );
 506    public $accessKeyId;
 507    public $secretAccessKey;
 508  
 509  
 510    public function setAccessKeyId($accessKeyId)
 511    {
 512      $this->accessKeyId = $accessKeyId;
 513    }
 514    public function getAccessKeyId()
 515    {
 516      return $this->accessKeyId;
 517    }
 518    public function setSecretAccessKey($secretAccessKey)
 519    {
 520      $this->secretAccessKey = $secretAccessKey;
 521    }
 522    public function getSecretAccessKey()
 523    {
 524      return $this->secretAccessKey;
 525    }
 526  }
 527  
 528  class Google_Service_Storagetransfer_AwsS3Data extends Google_Model
 529  {
 530    protected $internal_gapi_mappings = array(
 531    );
 532    protected $awsAccessKeyType = 'Google_Service_Storagetransfer_AwsAccessKey';
 533    protected $awsAccessKeyDataType = '';
 534    public $bucketName;
 535  
 536  
 537    public function setAwsAccessKey(Google_Service_Storagetransfer_AwsAccessKey $awsAccessKey)
 538    {
 539      $this->awsAccessKey = $awsAccessKey;
 540    }
 541    public function getAwsAccessKey()
 542    {
 543      return $this->awsAccessKey;
 544    }
 545    public function setBucketName($bucketName)
 546    {
 547      $this->bucketName = $bucketName;
 548    }
 549    public function getBucketName()
 550    {
 551      return $this->bucketName;
 552    }
 553  }
 554  
 555  class Google_Service_Storagetransfer_Date extends Google_Model
 556  {
 557    protected $internal_gapi_mappings = array(
 558    );
 559    public $day;
 560    public $month;
 561    public $year;
 562  
 563  
 564    public function setDay($day)
 565    {
 566      $this->day = $day;
 567    }
 568    public function getDay()
 569    {
 570      return $this->day;
 571    }
 572    public function setMonth($month)
 573    {
 574      $this->month = $month;
 575    }
 576    public function getMonth()
 577    {
 578      return $this->month;
 579    }
 580    public function setYear($year)
 581    {
 582      $this->year = $year;
 583    }
 584    public function getYear()
 585    {
 586      return $this->year;
 587    }
 588  }
 589  
 590  class Google_Service_Storagetransfer_Empty extends Google_Model
 591  {
 592  }
 593  
 594  class Google_Service_Storagetransfer_ErrorLogEntry extends Google_Collection
 595  {
 596    protected $collection_key = 'errorDetails';
 597    protected $internal_gapi_mappings = array(
 598    );
 599    public $errorDetails;
 600    public $url;
 601  
 602  
 603    public function setErrorDetails($errorDetails)
 604    {
 605      $this->errorDetails = $errorDetails;
 606    }
 607    public function getErrorDetails()
 608    {
 609      return $this->errorDetails;
 610    }
 611    public function setUrl($url)
 612    {
 613      $this->url = $url;
 614    }
 615    public function getUrl()
 616    {
 617      return $this->url;
 618    }
 619  }
 620  
 621  class Google_Service_Storagetransfer_ErrorSummary extends Google_Collection
 622  {
 623    protected $collection_key = 'errorLogEntries';
 624    protected $internal_gapi_mappings = array(
 625    );
 626    public $errorCode;
 627    public $errorCount;
 628    protected $errorLogEntriesType = 'Google_Service_Storagetransfer_ErrorLogEntry';
 629    protected $errorLogEntriesDataType = 'array';
 630  
 631  
 632    public function setErrorCode($errorCode)
 633    {
 634      $this->errorCode = $errorCode;
 635    }
 636    public function getErrorCode()
 637    {
 638      return $this->errorCode;
 639    }
 640    public function setErrorCount($errorCount)
 641    {
 642      $this->errorCount = $errorCount;
 643    }
 644    public function getErrorCount()
 645    {
 646      return $this->errorCount;
 647    }
 648    public function setErrorLogEntries($errorLogEntries)
 649    {
 650      $this->errorLogEntries = $errorLogEntries;
 651    }
 652    public function getErrorLogEntries()
 653    {
 654      return $this->errorLogEntries;
 655    }
 656  }
 657  
 658  class Google_Service_Storagetransfer_GcsData extends Google_Model
 659  {
 660    protected $internal_gapi_mappings = array(
 661    );
 662    public $bucketName;
 663  
 664  
 665    public function setBucketName($bucketName)
 666    {
 667      $this->bucketName = $bucketName;
 668    }
 669    public function getBucketName()
 670    {
 671      return $this->bucketName;
 672    }
 673  }
 674  
 675  class Google_Service_Storagetransfer_GoogleServiceAccount extends Google_Model
 676  {
 677    protected $internal_gapi_mappings = array(
 678    );
 679    public $accountEmail;
 680  
 681  
 682    public function setAccountEmail($accountEmail)
 683    {
 684      $this->accountEmail = $accountEmail;
 685    }
 686    public function getAccountEmail()
 687    {
 688      return $this->accountEmail;
 689    }
 690  }
 691  
 692  class Google_Service_Storagetransfer_HttpData extends Google_Model
 693  {
 694    protected $internal_gapi_mappings = array(
 695    );
 696    public $listUrl;
 697  
 698  
 699    public function setListUrl($listUrl)
 700    {
 701      $this->listUrl = $listUrl;
 702    }
 703    public function getListUrl()
 704    {
 705      return $this->listUrl;
 706    }
 707  }
 708  
 709  class Google_Service_Storagetransfer_ListOperationsResponse extends Google_Collection
 710  {
 711    protected $collection_key = 'operations';
 712    protected $internal_gapi_mappings = array(
 713    );
 714    public $nextPageToken;
 715    protected $operationsType = 'Google_Service_Storagetransfer_Operation';
 716    protected $operationsDataType = 'array';
 717  
 718  
 719    public function setNextPageToken($nextPageToken)
 720    {
 721      $this->nextPageToken = $nextPageToken;
 722    }
 723    public function getNextPageToken()
 724    {
 725      return $this->nextPageToken;
 726    }
 727    public function setOperations($operations)
 728    {
 729      $this->operations = $operations;
 730    }
 731    public function getOperations()
 732    {
 733      return $this->operations;
 734    }
 735  }
 736  
 737  class Google_Service_Storagetransfer_ListTransferJobsResponse extends Google_Collection
 738  {
 739    protected $collection_key = 'transferJobs';
 740    protected $internal_gapi_mappings = array(
 741    );
 742    public $nextPageToken;
 743    protected $transferJobsType = 'Google_Service_Storagetransfer_TransferJob';
 744    protected $transferJobsDataType = 'array';
 745  
 746  
 747    public function setNextPageToken($nextPageToken)
 748    {
 749      $this->nextPageToken = $nextPageToken;
 750    }
 751    public function getNextPageToken()
 752    {
 753      return $this->nextPageToken;
 754    }
 755    public function setTransferJobs($transferJobs)
 756    {
 757      $this->transferJobs = $transferJobs;
 758    }
 759    public function getTransferJobs()
 760    {
 761      return $this->transferJobs;
 762    }
 763  }
 764  
 765  class Google_Service_Storagetransfer_ObjectConditions extends Google_Collection
 766  {
 767    protected $collection_key = 'includePrefixes';
 768    protected $internal_gapi_mappings = array(
 769    );
 770    public $excludePrefixes;
 771    public $includePrefixes;
 772    public $maxTimeElapsedSinceLastModification;
 773    public $minTimeElapsedSinceLastModification;
 774  
 775  
 776    public function setExcludePrefixes($excludePrefixes)
 777    {
 778      $this->excludePrefixes = $excludePrefixes;
 779    }
 780    public function getExcludePrefixes()
 781    {
 782      return $this->excludePrefixes;
 783    }
 784    public function setIncludePrefixes($includePrefixes)
 785    {
 786      $this->includePrefixes = $includePrefixes;
 787    }
 788    public function getIncludePrefixes()
 789    {
 790      return $this->includePrefixes;
 791    }
 792    public function setMaxTimeElapsedSinceLastModification($maxTimeElapsedSinceLastModification)
 793    {
 794      $this->maxTimeElapsedSinceLastModification = $maxTimeElapsedSinceLastModification;
 795    }
 796    public function getMaxTimeElapsedSinceLastModification()
 797    {
 798      return $this->maxTimeElapsedSinceLastModification;
 799    }
 800    public function setMinTimeElapsedSinceLastModification($minTimeElapsedSinceLastModification)
 801    {
 802      $this->minTimeElapsedSinceLastModification = $minTimeElapsedSinceLastModification;
 803    }
 804    public function getMinTimeElapsedSinceLastModification()
 805    {
 806      return $this->minTimeElapsedSinceLastModification;
 807    }
 808  }
 809  
 810  class Google_Service_Storagetransfer_Operation extends Google_Model
 811  {
 812    protected $internal_gapi_mappings = array(
 813    );
 814    public $done;
 815    protected $errorType = 'Google_Service_Storagetransfer_Status';
 816    protected $errorDataType = '';
 817    public $metadata;
 818    public $name;
 819    public $response;
 820  
 821  
 822    public function setDone($done)
 823    {
 824      $this->done = $done;
 825    }
 826    public function getDone()
 827    {
 828      return $this->done;
 829    }
 830    public function setError(Google_Service_Storagetransfer_Status $error)
 831    {
 832      $this->error = $error;
 833    }
 834    public function getError()
 835    {
 836      return $this->error;
 837    }
 838    public function setMetadata($metadata)
 839    {
 840      $this->metadata = $metadata;
 841    }
 842    public function getMetadata()
 843    {
 844      return $this->metadata;
 845    }
 846    public function setName($name)
 847    {
 848      $this->name = $name;
 849    }
 850    public function getName()
 851    {
 852      return $this->name;
 853    }
 854    public function setResponse($response)
 855    {
 856      $this->response = $response;
 857    }
 858    public function getResponse()
 859    {
 860      return $this->response;
 861    }
 862  }
 863  
 864  class Google_Service_Storagetransfer_OperationMetadata extends Google_Model
 865  {
 866  }
 867  
 868  class Google_Service_Storagetransfer_OperationResponse extends Google_Model
 869  {
 870  }
 871  
 872  class Google_Service_Storagetransfer_PauseTransferOperationRequest extends Google_Model
 873  {
 874  }
 875  
 876  class Google_Service_Storagetransfer_ResumeTransferOperationRequest extends Google_Model
 877  {
 878  }
 879  
 880  class Google_Service_Storagetransfer_Schedule extends Google_Model
 881  {
 882    protected $internal_gapi_mappings = array(
 883    );
 884    protected $scheduleEndDateType = 'Google_Service_Storagetransfer_Date';
 885    protected $scheduleEndDateDataType = '';
 886    protected $scheduleStartDateType = 'Google_Service_Storagetransfer_Date';
 887    protected $scheduleStartDateDataType = '';
 888    protected $startTimeOfDayType = 'Google_Service_Storagetransfer_TimeOfDay';
 889    protected $startTimeOfDayDataType = '';
 890  
 891  
 892    public function setScheduleEndDate(Google_Service_Storagetransfer_Date $scheduleEndDate)
 893    {
 894      $this->scheduleEndDate = $scheduleEndDate;
 895    }
 896    public function getScheduleEndDate()
 897    {
 898      return $this->scheduleEndDate;
 899    }
 900    public function setScheduleStartDate(Google_Service_Storagetransfer_Date $scheduleStartDate)
 901    {
 902      $this->scheduleStartDate = $scheduleStartDate;
 903    }
 904    public function getScheduleStartDate()
 905    {
 906      return $this->scheduleStartDate;
 907    }
 908    public function setStartTimeOfDay(Google_Service_Storagetransfer_TimeOfDay $startTimeOfDay)
 909    {
 910      $this->startTimeOfDay = $startTimeOfDay;
 911    }
 912    public function getStartTimeOfDay()
 913    {
 914      return $this->startTimeOfDay;
 915    }
 916  }
 917  
 918  class Google_Service_Storagetransfer_Status extends Google_Collection
 919  {
 920    protected $collection_key = 'details';
 921    protected $internal_gapi_mappings = array(
 922    );
 923    public $code;
 924    public $details;
 925    public $message;
 926  
 927  
 928    public function setCode($code)
 929    {
 930      $this->code = $code;
 931    }
 932    public function getCode()
 933    {
 934      return $this->code;
 935    }
 936    public function setDetails($details)
 937    {
 938      $this->details = $details;
 939    }
 940    public function getDetails()
 941    {
 942      return $this->details;
 943    }
 944    public function setMessage($message)
 945    {
 946      $this->message = $message;
 947    }
 948    public function getMessage()
 949    {
 950      return $this->message;
 951    }
 952  }
 953  
 954  class Google_Service_Storagetransfer_StatusDetails extends Google_Model
 955  {
 956  }
 957  
 958  class Google_Service_Storagetransfer_TimeOfDay extends Google_Model
 959  {
 960    protected $internal_gapi_mappings = array(
 961    );
 962    public $hours;
 963    public $minutes;
 964    public $nanos;
 965    public $seconds;
 966  
 967  
 968    public function setHours($hours)
 969    {
 970      $this->hours = $hours;
 971    }
 972    public function getHours()
 973    {
 974      return $this->hours;
 975    }
 976    public function setMinutes($minutes)
 977    {
 978      $this->minutes = $minutes;
 979    }
 980    public function getMinutes()
 981    {
 982      return $this->minutes;
 983    }
 984    public function setNanos($nanos)
 985    {
 986      $this->nanos = $nanos;
 987    }
 988    public function getNanos()
 989    {
 990      return $this->nanos;
 991    }
 992    public function setSeconds($seconds)
 993    {
 994      $this->seconds = $seconds;
 995    }
 996    public function getSeconds()
 997    {
 998      return $this->seconds;
 999    }
1000  }
1001  
1002  class Google_Service_Storagetransfer_TransferCounters extends Google_Model
1003  {
1004    protected $internal_gapi_mappings = array(
1005    );
1006    public $bytesCopiedToSink;
1007    public $bytesDeletedFromSink;
1008    public $bytesDeletedFromSource;
1009    public $bytesFailedToDeleteFromSink;
1010    public $bytesFoundFromSource;
1011    public $bytesFoundOnlyFromSink;
1012    public $bytesFromSourceFailed;
1013    public $bytesFromSourceSkippedBySync;
1014    public $objectsCopiedToSink;
1015    public $objectsDeletedFromSink;
1016    public $objectsDeletedFromSource;
1017    public $objectsFailedToDeleteFromSink;
1018    public $objectsFoundFromSource;
1019    public $objectsFoundOnlyFromSink;
1020    public $objectsFromSourceFailed;
1021    public $objectsFromSourceSkippedBySync;
1022  
1023  
1024    public function setBytesCopiedToSink($bytesCopiedToSink)
1025    {
1026      $this->bytesCopiedToSink = $bytesCopiedToSink;
1027    }
1028    public function getBytesCopiedToSink()
1029    {
1030      return $this->bytesCopiedToSink;
1031    }
1032    public function setBytesDeletedFromSink($bytesDeletedFromSink)
1033    {
1034      $this->bytesDeletedFromSink = $bytesDeletedFromSink;
1035    }
1036    public function getBytesDeletedFromSink()
1037    {
1038      return $this->bytesDeletedFromSink;
1039    }
1040    public function setBytesDeletedFromSource($bytesDeletedFromSource)
1041    {
1042      $this->bytesDeletedFromSource = $bytesDeletedFromSource;
1043    }
1044    public function getBytesDeletedFromSource()
1045    {
1046      return $this->bytesDeletedFromSource;
1047    }
1048    public function setBytesFailedToDeleteFromSink($bytesFailedToDeleteFromSink)
1049    {
1050      $this->bytesFailedToDeleteFromSink = $bytesFailedToDeleteFromSink;
1051    }
1052    public function getBytesFailedToDeleteFromSink()
1053    {
1054      return $this->bytesFailedToDeleteFromSink;
1055    }
1056    public function setBytesFoundFromSource($bytesFoundFromSource)
1057    {
1058      $this->bytesFoundFromSource = $bytesFoundFromSource;
1059    }
1060    public function getBytesFoundFromSource()
1061    {
1062      return $this->bytesFoundFromSource;
1063    }
1064    public function setBytesFoundOnlyFromSink($bytesFoundOnlyFromSink)
1065    {
1066      $this->bytesFoundOnlyFromSink = $bytesFoundOnlyFromSink;
1067    }
1068    public function getBytesFoundOnlyFromSink()
1069    {
1070      return $this->bytesFoundOnlyFromSink;
1071    }
1072    public function setBytesFromSourceFailed($bytesFromSourceFailed)
1073    {
1074      $this->bytesFromSourceFailed = $bytesFromSourceFailed;
1075    }
1076    public function getBytesFromSourceFailed()
1077    {
1078      return $this->bytesFromSourceFailed;
1079    }
1080    public function setBytesFromSourceSkippedBySync($bytesFromSourceSkippedBySync)
1081    {
1082      $this->bytesFromSourceSkippedBySync = $bytesFromSourceSkippedBySync;
1083    }
1084    public function getBytesFromSourceSkippedBySync()
1085    {
1086      return $this->bytesFromSourceSkippedBySync;
1087    }
1088    public function setObjectsCopiedToSink($objectsCopiedToSink)
1089    {
1090      $this->objectsCopiedToSink = $objectsCopiedToSink;
1091    }
1092    public function getObjectsCopiedToSink()
1093    {
1094      return $this->objectsCopiedToSink;
1095    }
1096    public function setObjectsDeletedFromSink($objectsDeletedFromSink)
1097    {
1098      $this->objectsDeletedFromSink = $objectsDeletedFromSink;
1099    }
1100    public function getObjectsDeletedFromSink()
1101    {
1102      return $this->objectsDeletedFromSink;
1103    }
1104    public function setObjectsDeletedFromSource($objectsDeletedFromSource)
1105    {
1106      $this->objectsDeletedFromSource = $objectsDeletedFromSource;
1107    }
1108    public function getObjectsDeletedFromSource()
1109    {
1110      return $this->objectsDeletedFromSource;
1111    }
1112    public function setObjectsFailedToDeleteFromSink($objectsFailedToDeleteFromSink)
1113    {
1114      $this->objectsFailedToDeleteFromSink = $objectsFailedToDeleteFromSink;
1115    }
1116    public function getObjectsFailedToDeleteFromSink()
1117    {
1118      return $this->objectsFailedToDeleteFromSink;
1119    }
1120    public function setObjectsFoundFromSource($objectsFoundFromSource)
1121    {
1122      $this->objectsFoundFromSource = $objectsFoundFromSource;
1123    }
1124    public function getObjectsFoundFromSource()
1125    {
1126      return $this->objectsFoundFromSource;
1127    }
1128    public function setObjectsFoundOnlyFromSink($objectsFoundOnlyFromSink)
1129    {
1130      $this->objectsFoundOnlyFromSink = $objectsFoundOnlyFromSink;
1131    }
1132    public function getObjectsFoundOnlyFromSink()
1133    {
1134      return $this->objectsFoundOnlyFromSink;
1135    }
1136    public function setObjectsFromSourceFailed($objectsFromSourceFailed)
1137    {
1138      $this->objectsFromSourceFailed = $objectsFromSourceFailed;
1139    }
1140    public function getObjectsFromSourceFailed()
1141    {
1142      return $this->objectsFromSourceFailed;
1143    }
1144    public function setObjectsFromSourceSkippedBySync($objectsFromSourceSkippedBySync)
1145    {
1146      $this->objectsFromSourceSkippedBySync = $objectsFromSourceSkippedBySync;
1147    }
1148    public function getObjectsFromSourceSkippedBySync()
1149    {
1150      return $this->objectsFromSourceSkippedBySync;
1151    }
1152  }
1153  
1154  class Google_Service_Storagetransfer_TransferJob extends Google_Model
1155  {
1156    protected $internal_gapi_mappings = array(
1157    );
1158    public $creationTime;
1159    public $deletionTime;
1160    public $description;
1161    public $lastModificationTime;
1162    public $name;
1163    public $projectId;
1164    protected $scheduleType = 'Google_Service_Storagetransfer_Schedule';
1165    protected $scheduleDataType = '';
1166    public $status;
1167    protected $transferSpecType = 'Google_Service_Storagetransfer_TransferSpec';
1168    protected $transferSpecDataType = '';
1169  
1170  
1171    public function setCreationTime($creationTime)
1172    {
1173      $this->creationTime = $creationTime;
1174    }
1175    public function getCreationTime()
1176    {
1177      return $this->creationTime;
1178    }
1179    public function setDeletionTime($deletionTime)
1180    {
1181      $this->deletionTime = $deletionTime;
1182    }
1183    public function getDeletionTime()
1184    {
1185      return $this->deletionTime;
1186    }
1187    public function setDescription($description)
1188    {
1189      $this->description = $description;
1190    }
1191    public function getDescription()
1192    {
1193      return $this->description;
1194    }
1195    public function setLastModificationTime($lastModificationTime)
1196    {
1197      $this->lastModificationTime = $lastModificationTime;
1198    }
1199    public function getLastModificationTime()
1200    {
1201      return $this->lastModificationTime;
1202    }
1203    public function setName($name)
1204    {
1205      $this->name = $name;
1206    }
1207    public function getName()
1208    {
1209      return $this->name;
1210    }
1211    public function setProjectId($projectId)
1212    {
1213      $this->projectId = $projectId;
1214    }
1215    public function getProjectId()
1216    {
1217      return $this->projectId;
1218    }
1219    public function setSchedule(Google_Service_Storagetransfer_Schedule $schedule)
1220    {
1221      $this->schedule = $schedule;
1222    }
1223    public function getSchedule()
1224    {
1225      return $this->schedule;
1226    }
1227    public function setStatus($status)
1228    {
1229      $this->status = $status;
1230    }
1231    public function getStatus()
1232    {
1233      return $this->status;
1234    }
1235    public function setTransferSpec(Google_Service_Storagetransfer_TransferSpec $transferSpec)
1236    {
1237      $this->transferSpec = $transferSpec;
1238    }
1239    public function getTransferSpec()
1240    {
1241      return $this->transferSpec;
1242    }
1243  }
1244  
1245  class Google_Service_Storagetransfer_TransferOperation extends Google_Collection
1246  {
1247    protected $collection_key = 'errorBreakdowns';
1248    protected $internal_gapi_mappings = array(
1249    );
1250    protected $countersType = 'Google_Service_Storagetransfer_TransferCounters';
1251    protected $countersDataType = '';
1252    public $endTime;
1253    protected $errorBreakdownsType = 'Google_Service_Storagetransfer_ErrorSummary';
1254    protected $errorBreakdownsDataType = 'array';
1255    public $name;
1256    public $projectId;
1257    public $startTime;
1258    public $status;
1259    public $transferJobName;
1260    protected $transferSpecType = 'Google_Service_Storagetransfer_TransferSpec';
1261    protected $transferSpecDataType = '';
1262  
1263  
1264    public function setCounters(Google_Service_Storagetransfer_TransferCounters $counters)
1265    {
1266      $this->counters = $counters;
1267    }
1268    public function getCounters()
1269    {
1270      return $this->counters;
1271    }
1272    public function setEndTime($endTime)
1273    {
1274      $this->endTime = $endTime;
1275    }
1276    public function getEndTime()
1277    {
1278      return $this->endTime;
1279    }
1280    public function setErrorBreakdowns($errorBreakdowns)
1281    {
1282      $this->errorBreakdowns = $errorBreakdowns;
1283    }
1284    public function getErrorBreakdowns()
1285    {
1286      return $this->errorBreakdowns;
1287    }
1288    public function setName($name)
1289    {
1290      $this->name = $name;
1291    }
1292    public function getName()
1293    {
1294      return $this->name;
1295    }
1296    public function setProjectId($projectId)
1297    {
1298      $this->projectId = $projectId;
1299    }
1300    public function getProjectId()
1301    {
1302      return $this->projectId;
1303    }
1304    public function setStartTime($startTime)
1305    {
1306      $this->startTime = $startTime;
1307    }
1308    public function getStartTime()
1309    {
1310      return $this->startTime;
1311    }
1312    public function setStatus($status)
1313    {
1314      $this->status = $status;
1315    }
1316    public function getStatus()
1317    {
1318      return $this->status;
1319    }
1320    public function setTransferJobName($transferJobName)
1321    {
1322      $this->transferJobName = $transferJobName;
1323    }
1324    public function getTransferJobName()
1325    {
1326      return $this->transferJobName;
1327    }
1328    public function setTransferSpec(Google_Service_Storagetransfer_TransferSpec $transferSpec)
1329    {
1330      $this->transferSpec = $transferSpec;
1331    }
1332    public function getTransferSpec()
1333    {
1334      return $this->transferSpec;
1335    }
1336  }
1337  
1338  class Google_Service_Storagetransfer_TransferOptions extends Google_Model
1339  {
1340    protected $internal_gapi_mappings = array(
1341    );
1342    public $deleteObjectsFromSourceAfterTransfer;
1343    public $deleteObjectsUniqueInSink;
1344    public $overwriteObjectsAlreadyExistingInSink;
1345  
1346  
1347    public function setDeleteObjectsFromSourceAfterTransfer($deleteObjectsFromSourceAfterTransfer)
1348    {
1349      $this->deleteObjectsFromSourceAfterTransfer = $deleteObjectsFromSourceAfterTransfer;
1350    }
1351    public function getDeleteObjectsFromSourceAfterTransfer()
1352    {
1353      return $this->deleteObjectsFromSourceAfterTransfer;
1354    }
1355    public function setDeleteObjectsUniqueInSink($deleteObjectsUniqueInSink)
1356    {
1357      $this->deleteObjectsUniqueInSink = $deleteObjectsUniqueInSink;
1358    }
1359    public function getDeleteObjectsUniqueInSink()
1360    {
1361      return $this->deleteObjectsUniqueInSink;
1362    }
1363    public function setOverwriteObjectsAlreadyExistingInSink($overwriteObjectsAlreadyExistingInSink)
1364    {
1365      $this->overwriteObjectsAlreadyExistingInSink = $overwriteObjectsAlreadyExistingInSink;
1366    }
1367    public function getOverwriteObjectsAlreadyExistingInSink()
1368    {
1369      return $this->overwriteObjectsAlreadyExistingInSink;
1370    }
1371  }
1372  
1373  class Google_Service_Storagetransfer_TransferSpec extends Google_Model
1374  {
1375    protected $internal_gapi_mappings = array(
1376    );
1377    protected $awsS3DataSourceType = 'Google_Service_Storagetransfer_AwsS3Data';
1378    protected $awsS3DataSourceDataType = '';
1379    protected $gcsDataSinkType = 'Google_Service_Storagetransfer_GcsData';
1380    protected $gcsDataSinkDataType = '';
1381    protected $gcsDataSourceType = 'Google_Service_Storagetransfer_GcsData';
1382    protected $gcsDataSourceDataType = '';
1383    protected $httpDataSourceType = 'Google_Service_Storagetransfer_HttpData';
1384    protected $httpDataSourceDataType = '';
1385    protected $objectConditionsType = 'Google_Service_Storagetransfer_ObjectConditions';
1386    protected $objectConditionsDataType = '';
1387    protected $transferOptionsType = 'Google_Service_Storagetransfer_TransferOptions';
1388    protected $transferOptionsDataType = '';
1389  
1390  
1391    public function setAwsS3DataSource(Google_Service_Storagetransfer_AwsS3Data $awsS3DataSource)
1392    {
1393      $this->awsS3DataSource = $awsS3DataSource;
1394    }
1395    public function getAwsS3DataSource()
1396    {
1397      return $this->awsS3DataSource;
1398    }
1399    public function setGcsDataSink(Google_Service_Storagetransfer_GcsData $gcsDataSink)
1400    {
1401      $this->gcsDataSink = $gcsDataSink;
1402    }
1403    public function getGcsDataSink()
1404    {
1405      return $this->gcsDataSink;
1406    }
1407    public function setGcsDataSource(Google_Service_Storagetransfer_GcsData $gcsDataSource)
1408    {
1409      $this->gcsDataSource = $gcsDataSource;
1410    }
1411    public function getGcsDataSource()
1412    {
1413      return $this->gcsDataSource;
1414    }
1415    public function setHttpDataSource(Google_Service_Storagetransfer_HttpData $httpDataSource)
1416    {
1417      $this->httpDataSource = $httpDataSource;
1418    }
1419    public function getHttpDataSource()
1420    {
1421      return $this->httpDataSource;
1422    }
1423    public function setObjectConditions(Google_Service_Storagetransfer_ObjectConditions $objectConditions)
1424    {
1425      $this->objectConditions = $objectConditions;
1426    }
1427    public function getObjectConditions()
1428    {
1429      return $this->objectConditions;
1430    }
1431    public function setTransferOptions(Google_Service_Storagetransfer_TransferOptions $transferOptions)
1432    {
1433      $this->transferOptions = $transferOptions;
1434    }
1435    public function getTransferOptions()
1436    {
1437      return $this->transferOptions;
1438    }
1439  }
1440  
1441  class Google_Service_Storagetransfer_UpdateTransferJobRequest extends Google_Model
1442  {
1443    protected $internal_gapi_mappings = array(
1444    );
1445    public $projectId;
1446    protected $transferJobType = 'Google_Service_Storagetransfer_TransferJob';
1447    protected $transferJobDataType = '';
1448    public $updateTransferJobFieldMask;
1449  
1450  
1451    public function setProjectId($projectId)
1452    {
1453      $this->projectId = $projectId;
1454    }
1455    public function getProjectId()
1456    {
1457      return $this->projectId;
1458    }
1459    public function setTransferJob(Google_Service_Storagetransfer_TransferJob $transferJob)
1460    {
1461      $this->transferJob = $transferJob;
1462    }
1463    public function getTransferJob()
1464    {
1465      return $this->transferJob;
1466    }
1467    public function setUpdateTransferJobFieldMask($updateTransferJobFieldMask)
1468    {
1469      $this->updateTransferJobFieldMask = $updateTransferJobFieldMask;
1470    }
1471    public function getUpdateTransferJobFieldMask()
1472    {
1473      return $this->updateTransferJobFieldMask;
1474    }
1475  }