[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 Datastore (v1beta2).
  20   *
  21   * <p>
  22   * API for accessing Google Cloud Datastore.</p>
  23   *
  24   * <p>
  25   * For more information about this service, see the API
  26   * <a href="https://developers.google.com/datastore/" target="_blank">Documentation</a>
  27   * </p>
  28   *
  29   * @author Google, Inc.
  30   */
  31  class Google_Service_Datastore extends Google_Service
  32  {
  33    /** View and manage your data across Google Cloud Platform services. */
  34    const CLOUD_PLATFORM =
  35        "https://www.googleapis.com/auth/cloud-platform";
  36    /** View and manage your Google Cloud Datastore data. */
  37    const DATASTORE =
  38        "https://www.googleapis.com/auth/datastore";
  39    /** View your email address. */
  40    const USERINFO_EMAIL =
  41        "https://www.googleapis.com/auth/userinfo.email";
  42  
  43    public $datasets;
  44    
  45  
  46    /**
  47     * Constructs the internal representation of the Datastore service.
  48     *
  49     * @param Google_Client $client
  50     */
  51    public function __construct(Google_Client $client)
  52    {
  53      parent::__construct($client);
  54      $this->rootUrl = 'https://www.googleapis.com/';
  55      $this->servicePath = 'datastore/v1beta2/datasets/';
  56      $this->version = 'v1beta2';
  57      $this->serviceName = 'datastore';
  58  
  59      $this->datasets = new Google_Service_Datastore_Datasets_Resource(
  60          $this,
  61          $this->serviceName,
  62          'datasets',
  63          array(
  64            'methods' => array(
  65              'allocateIds' => array(
  66                'path' => '{datasetId}/allocateIds',
  67                'httpMethod' => 'POST',
  68                'parameters' => array(
  69                  'datasetId' => array(
  70                    'location' => 'path',
  71                    'type' => 'string',
  72                    'required' => true,
  73                  ),
  74                ),
  75              ),'beginTransaction' => array(
  76                'path' => '{datasetId}/beginTransaction',
  77                'httpMethod' => 'POST',
  78                'parameters' => array(
  79                  'datasetId' => array(
  80                    'location' => 'path',
  81                    'type' => 'string',
  82                    'required' => true,
  83                  ),
  84                ),
  85              ),'commit' => array(
  86                'path' => '{datasetId}/commit',
  87                'httpMethod' => 'POST',
  88                'parameters' => array(
  89                  'datasetId' => array(
  90                    'location' => 'path',
  91                    'type' => 'string',
  92                    'required' => true,
  93                  ),
  94                ),
  95              ),'lookup' => array(
  96                'path' => '{datasetId}/lookup',
  97                'httpMethod' => 'POST',
  98                'parameters' => array(
  99                  'datasetId' => array(
 100                    'location' => 'path',
 101                    'type' => 'string',
 102                    'required' => true,
 103                  ),
 104                ),
 105              ),'rollback' => array(
 106                'path' => '{datasetId}/rollback',
 107                'httpMethod' => 'POST',
 108                'parameters' => array(
 109                  'datasetId' => array(
 110                    'location' => 'path',
 111                    'type' => 'string',
 112                    'required' => true,
 113                  ),
 114                ),
 115              ),'runQuery' => array(
 116                'path' => '{datasetId}/runQuery',
 117                'httpMethod' => 'POST',
 118                'parameters' => array(
 119                  'datasetId' => array(
 120                    'location' => 'path',
 121                    'type' => 'string',
 122                    'required' => true,
 123                  ),
 124                ),
 125              ),
 126            )
 127          )
 128      );
 129    }
 130  }
 131  
 132  
 133  /**
 134   * The "datasets" collection of methods.
 135   * Typical usage is:
 136   *  <code>
 137   *   $datastoreService = new Google_Service_Datastore(...);
 138   *   $datasets = $datastoreService->datasets;
 139   *  </code>
 140   */
 141  class Google_Service_Datastore_Datasets_Resource extends Google_Service_Resource
 142  {
 143  
 144    /**
 145     * Allocate IDs for incomplete keys (useful for referencing an entity before it
 146     * is inserted). (datasets.allocateIds)
 147     *
 148     * @param string $datasetId Identifies the dataset.
 149     * @param Google_AllocateIdsRequest $postBody
 150     * @param array $optParams Optional parameters.
 151     * @return Google_Service_Datastore_AllocateIdsResponse
 152     */
 153    public function allocateIds($datasetId, Google_Service_Datastore_AllocateIdsRequest $postBody, $optParams = array())
 154    {
 155      $params = array('datasetId' => $datasetId, 'postBody' => $postBody);
 156      $params = array_merge($params, $optParams);
 157      return $this->call('allocateIds', array($params), "Google_Service_Datastore_AllocateIdsResponse");
 158    }
 159  
 160    /**
 161     * Begin a new transaction. (datasets.beginTransaction)
 162     *
 163     * @param string $datasetId Identifies the dataset.
 164     * @param Google_BeginTransactionRequest $postBody
 165     * @param array $optParams Optional parameters.
 166     * @return Google_Service_Datastore_BeginTransactionResponse
 167     */
 168    public function beginTransaction($datasetId, Google_Service_Datastore_BeginTransactionRequest $postBody, $optParams = array())
 169    {
 170      $params = array('datasetId' => $datasetId, 'postBody' => $postBody);
 171      $params = array_merge($params, $optParams);
 172      return $this->call('beginTransaction', array($params), "Google_Service_Datastore_BeginTransactionResponse");
 173    }
 174  
 175    /**
 176     * Commit a transaction, optionally creating, deleting or modifying some
 177     * entities. (datasets.commit)
 178     *
 179     * @param string $datasetId Identifies the dataset.
 180     * @param Google_CommitRequest $postBody
 181     * @param array $optParams Optional parameters.
 182     * @return Google_Service_Datastore_CommitResponse
 183     */
 184    public function commit($datasetId, Google_Service_Datastore_CommitRequest $postBody, $optParams = array())
 185    {
 186      $params = array('datasetId' => $datasetId, 'postBody' => $postBody);
 187      $params = array_merge($params, $optParams);
 188      return $this->call('commit', array($params), "Google_Service_Datastore_CommitResponse");
 189    }
 190  
 191    /**
 192     * Look up some entities by key. (datasets.lookup)
 193     *
 194     * @param string $datasetId Identifies the dataset.
 195     * @param Google_LookupRequest $postBody
 196     * @param array $optParams Optional parameters.
 197     * @return Google_Service_Datastore_LookupResponse
 198     */
 199    public function lookup($datasetId, Google_Service_Datastore_LookupRequest $postBody, $optParams = array())
 200    {
 201      $params = array('datasetId' => $datasetId, 'postBody' => $postBody);
 202      $params = array_merge($params, $optParams);
 203      return $this->call('lookup', array($params), "Google_Service_Datastore_LookupResponse");
 204    }
 205  
 206    /**
 207     * Roll back a transaction. (datasets.rollback)
 208     *
 209     * @param string $datasetId Identifies the dataset.
 210     * @param Google_RollbackRequest $postBody
 211     * @param array $optParams Optional parameters.
 212     * @return Google_Service_Datastore_RollbackResponse
 213     */
 214    public function rollback($datasetId, Google_Service_Datastore_RollbackRequest $postBody, $optParams = array())
 215    {
 216      $params = array('datasetId' => $datasetId, 'postBody' => $postBody);
 217      $params = array_merge($params, $optParams);
 218      return $this->call('rollback', array($params), "Google_Service_Datastore_RollbackResponse");
 219    }
 220  
 221    /**
 222     * Query for entities. (datasets.runQuery)
 223     *
 224     * @param string $datasetId Identifies the dataset.
 225     * @param Google_RunQueryRequest $postBody
 226     * @param array $optParams Optional parameters.
 227     * @return Google_Service_Datastore_RunQueryResponse
 228     */
 229    public function runQuery($datasetId, Google_Service_Datastore_RunQueryRequest $postBody, $optParams = array())
 230    {
 231      $params = array('datasetId' => $datasetId, 'postBody' => $postBody);
 232      $params = array_merge($params, $optParams);
 233      return $this->call('runQuery', array($params), "Google_Service_Datastore_RunQueryResponse");
 234    }
 235  }
 236  
 237  
 238  
 239  
 240  class Google_Service_Datastore_AllocateIdsRequest extends Google_Collection
 241  {
 242    protected $collection_key = 'keys';
 243    protected $internal_gapi_mappings = array(
 244    );
 245    protected $keysType = 'Google_Service_Datastore_Key';
 246    protected $keysDataType = 'array';
 247  
 248  
 249    public function setKeys($keys)
 250    {
 251      $this->keys = $keys;
 252    }
 253    public function getKeys()
 254    {
 255      return $this->keys;
 256    }
 257  }
 258  
 259  class Google_Service_Datastore_AllocateIdsResponse extends Google_Collection
 260  {
 261    protected $collection_key = 'keys';
 262    protected $internal_gapi_mappings = array(
 263    );
 264    protected $headerType = 'Google_Service_Datastore_ResponseHeader';
 265    protected $headerDataType = '';
 266    protected $keysType = 'Google_Service_Datastore_Key';
 267    protected $keysDataType = 'array';
 268  
 269  
 270    public function setHeader(Google_Service_Datastore_ResponseHeader $header)
 271    {
 272      $this->header = $header;
 273    }
 274    public function getHeader()
 275    {
 276      return $this->header;
 277    }
 278    public function setKeys($keys)
 279    {
 280      $this->keys = $keys;
 281    }
 282    public function getKeys()
 283    {
 284      return $this->keys;
 285    }
 286  }
 287  
 288  class Google_Service_Datastore_BeginTransactionRequest extends Google_Model
 289  {
 290    protected $internal_gapi_mappings = array(
 291    );
 292    public $isolationLevel;
 293  
 294  
 295    public function setIsolationLevel($isolationLevel)
 296    {
 297      $this->isolationLevel = $isolationLevel;
 298    }
 299    public function getIsolationLevel()
 300    {
 301      return $this->isolationLevel;
 302    }
 303  }
 304  
 305  class Google_Service_Datastore_BeginTransactionResponse extends Google_Model
 306  {
 307    protected $internal_gapi_mappings = array(
 308    );
 309    protected $headerType = 'Google_Service_Datastore_ResponseHeader';
 310    protected $headerDataType = '';
 311    public $transaction;
 312  
 313  
 314    public function setHeader(Google_Service_Datastore_ResponseHeader $header)
 315    {
 316      $this->header = $header;
 317    }
 318    public function getHeader()
 319    {
 320      return $this->header;
 321    }
 322    public function setTransaction($transaction)
 323    {
 324      $this->transaction = $transaction;
 325    }
 326    public function getTransaction()
 327    {
 328      return $this->transaction;
 329    }
 330  }
 331  
 332  class Google_Service_Datastore_CommitRequest extends Google_Model
 333  {
 334    protected $internal_gapi_mappings = array(
 335    );
 336    public $ignoreReadOnly;
 337    public $mode;
 338    protected $mutationType = 'Google_Service_Datastore_Mutation';
 339    protected $mutationDataType = '';
 340    public $transaction;
 341  
 342  
 343    public function setIgnoreReadOnly($ignoreReadOnly)
 344    {
 345      $this->ignoreReadOnly = $ignoreReadOnly;
 346    }
 347    public function getIgnoreReadOnly()
 348    {
 349      return $this->ignoreReadOnly;
 350    }
 351    public function setMode($mode)
 352    {
 353      $this->mode = $mode;
 354    }
 355    public function getMode()
 356    {
 357      return $this->mode;
 358    }
 359    public function setMutation(Google_Service_Datastore_Mutation $mutation)
 360    {
 361      $this->mutation = $mutation;
 362    }
 363    public function getMutation()
 364    {
 365      return $this->mutation;
 366    }
 367    public function setTransaction($transaction)
 368    {
 369      $this->transaction = $transaction;
 370    }
 371    public function getTransaction()
 372    {
 373      return $this->transaction;
 374    }
 375  }
 376  
 377  class Google_Service_Datastore_CommitResponse extends Google_Model
 378  {
 379    protected $internal_gapi_mappings = array(
 380    );
 381    protected $headerType = 'Google_Service_Datastore_ResponseHeader';
 382    protected $headerDataType = '';
 383    protected $mutationResultType = 'Google_Service_Datastore_MutationResult';
 384    protected $mutationResultDataType = '';
 385  
 386  
 387    public function setHeader(Google_Service_Datastore_ResponseHeader $header)
 388    {
 389      $this->header = $header;
 390    }
 391    public function getHeader()
 392    {
 393      return $this->header;
 394    }
 395    public function setMutationResult(Google_Service_Datastore_MutationResult $mutationResult)
 396    {
 397      $this->mutationResult = $mutationResult;
 398    }
 399    public function getMutationResult()
 400    {
 401      return $this->mutationResult;
 402    }
 403  }
 404  
 405  class Google_Service_Datastore_CompositeFilter extends Google_Collection
 406  {
 407    protected $collection_key = 'filters';
 408    protected $internal_gapi_mappings = array(
 409    );
 410    protected $filtersType = 'Google_Service_Datastore_Filter';
 411    protected $filtersDataType = 'array';
 412    public $operator;
 413  
 414  
 415    public function setFilters($filters)
 416    {
 417      $this->filters = $filters;
 418    }
 419    public function getFilters()
 420    {
 421      return $this->filters;
 422    }
 423    public function setOperator($operator)
 424    {
 425      $this->operator = $operator;
 426    }
 427    public function getOperator()
 428    {
 429      return $this->operator;
 430    }
 431  }
 432  
 433  class Google_Service_Datastore_Entity extends Google_Model
 434  {
 435    protected $internal_gapi_mappings = array(
 436    );
 437    protected $keyType = 'Google_Service_Datastore_Key';
 438    protected $keyDataType = '';
 439    protected $propertiesType = 'Google_Service_Datastore_Property';
 440    protected $propertiesDataType = 'map';
 441  
 442  
 443    public function setKey(Google_Service_Datastore_Key $key)
 444    {
 445      $this->key = $key;
 446    }
 447    public function getKey()
 448    {
 449      return $this->key;
 450    }
 451    public function setProperties($properties)
 452    {
 453      $this->properties = $properties;
 454    }
 455    public function getProperties()
 456    {
 457      return $this->properties;
 458    }
 459  }
 460  
 461  class Google_Service_Datastore_EntityProperties extends Google_Model
 462  {
 463  }
 464  
 465  class Google_Service_Datastore_EntityResult extends Google_Model
 466  {
 467    protected $internal_gapi_mappings = array(
 468    );
 469    protected $entityType = 'Google_Service_Datastore_Entity';
 470    protected $entityDataType = '';
 471  
 472  
 473    public function setEntity(Google_Service_Datastore_Entity $entity)
 474    {
 475      $this->entity = $entity;
 476    }
 477    public function getEntity()
 478    {
 479      return $this->entity;
 480    }
 481  }
 482  
 483  class Google_Service_Datastore_Filter extends Google_Model
 484  {
 485    protected $internal_gapi_mappings = array(
 486    );
 487    protected $compositeFilterType = 'Google_Service_Datastore_CompositeFilter';
 488    protected $compositeFilterDataType = '';
 489    protected $propertyFilterType = 'Google_Service_Datastore_PropertyFilter';
 490    protected $propertyFilterDataType = '';
 491  
 492  
 493    public function setCompositeFilter(Google_Service_Datastore_CompositeFilter $compositeFilter)
 494    {
 495      $this->compositeFilter = $compositeFilter;
 496    }
 497    public function getCompositeFilter()
 498    {
 499      return $this->compositeFilter;
 500    }
 501    public function setPropertyFilter(Google_Service_Datastore_PropertyFilter $propertyFilter)
 502    {
 503      $this->propertyFilter = $propertyFilter;
 504    }
 505    public function getPropertyFilter()
 506    {
 507      return $this->propertyFilter;
 508    }
 509  }
 510  
 511  class Google_Service_Datastore_GqlQuery extends Google_Collection
 512  {
 513    protected $collection_key = 'numberArgs';
 514    protected $internal_gapi_mappings = array(
 515    );
 516    public $allowLiteral;
 517    protected $nameArgsType = 'Google_Service_Datastore_GqlQueryArg';
 518    protected $nameArgsDataType = 'array';
 519    protected $numberArgsType = 'Google_Service_Datastore_GqlQueryArg';
 520    protected $numberArgsDataType = 'array';
 521    public $queryString;
 522  
 523  
 524    public function setAllowLiteral($allowLiteral)
 525    {
 526      $this->allowLiteral = $allowLiteral;
 527    }
 528    public function getAllowLiteral()
 529    {
 530      return $this->allowLiteral;
 531    }
 532    public function setNameArgs($nameArgs)
 533    {
 534      $this->nameArgs = $nameArgs;
 535    }
 536    public function getNameArgs()
 537    {
 538      return $this->nameArgs;
 539    }
 540    public function setNumberArgs($numberArgs)
 541    {
 542      $this->numberArgs = $numberArgs;
 543    }
 544    public function getNumberArgs()
 545    {
 546      return $this->numberArgs;
 547    }
 548    public function setQueryString($queryString)
 549    {
 550      $this->queryString = $queryString;
 551    }
 552    public function getQueryString()
 553    {
 554      return $this->queryString;
 555    }
 556  }
 557  
 558  class Google_Service_Datastore_GqlQueryArg extends Google_Model
 559  {
 560    protected $internal_gapi_mappings = array(
 561    );
 562    public $cursor;
 563    public $name;
 564    protected $valueType = 'Google_Service_Datastore_Value';
 565    protected $valueDataType = '';
 566  
 567  
 568    public function setCursor($cursor)
 569    {
 570      $this->cursor = $cursor;
 571    }
 572    public function getCursor()
 573    {
 574      return $this->cursor;
 575    }
 576    public function setName($name)
 577    {
 578      $this->name = $name;
 579    }
 580    public function getName()
 581    {
 582      return $this->name;
 583    }
 584    public function setValue(Google_Service_Datastore_Value $value)
 585    {
 586      $this->value = $value;
 587    }
 588    public function getValue()
 589    {
 590      return $this->value;
 591    }
 592  }
 593  
 594  class Google_Service_Datastore_Key extends Google_Collection
 595  {
 596    protected $collection_key = 'path';
 597    protected $internal_gapi_mappings = array(
 598    );
 599    protected $partitionIdType = 'Google_Service_Datastore_PartitionId';
 600    protected $partitionIdDataType = '';
 601    protected $pathType = 'Google_Service_Datastore_KeyPathElement';
 602    protected $pathDataType = 'array';
 603  
 604  
 605    public function setPartitionId(Google_Service_Datastore_PartitionId $partitionId)
 606    {
 607      $this->partitionId = $partitionId;
 608    }
 609    public function getPartitionId()
 610    {
 611      return $this->partitionId;
 612    }
 613    public function setPath($path)
 614    {
 615      $this->path = $path;
 616    }
 617    public function getPath()
 618    {
 619      return $this->path;
 620    }
 621  }
 622  
 623  class Google_Service_Datastore_KeyPathElement extends Google_Model
 624  {
 625    protected $internal_gapi_mappings = array(
 626    );
 627    public $id;
 628    public $kind;
 629    public $name;
 630  
 631  
 632    public function setId($id)
 633    {
 634      $this->id = $id;
 635    }
 636    public function getId()
 637    {
 638      return $this->id;
 639    }
 640    public function setKind($kind)
 641    {
 642      $this->kind = $kind;
 643    }
 644    public function getKind()
 645    {
 646      return $this->kind;
 647    }
 648    public function setName($name)
 649    {
 650      $this->name = $name;
 651    }
 652    public function getName()
 653    {
 654      return $this->name;
 655    }
 656  }
 657  
 658  class Google_Service_Datastore_KindExpression extends Google_Model
 659  {
 660    protected $internal_gapi_mappings = array(
 661    );
 662    public $name;
 663  
 664  
 665    public function setName($name)
 666    {
 667      $this->name = $name;
 668    }
 669    public function getName()
 670    {
 671      return $this->name;
 672    }
 673  }
 674  
 675  class Google_Service_Datastore_LookupRequest extends Google_Collection
 676  {
 677    protected $collection_key = 'keys';
 678    protected $internal_gapi_mappings = array(
 679    );
 680    protected $keysType = 'Google_Service_Datastore_Key';
 681    protected $keysDataType = 'array';
 682    protected $readOptionsType = 'Google_Service_Datastore_ReadOptions';
 683    protected $readOptionsDataType = '';
 684  
 685  
 686    public function setKeys($keys)
 687    {
 688      $this->keys = $keys;
 689    }
 690    public function getKeys()
 691    {
 692      return $this->keys;
 693    }
 694    public function setReadOptions(Google_Service_Datastore_ReadOptions $readOptions)
 695    {
 696      $this->readOptions = $readOptions;
 697    }
 698    public function getReadOptions()
 699    {
 700      return $this->readOptions;
 701    }
 702  }
 703  
 704  class Google_Service_Datastore_LookupResponse extends Google_Collection
 705  {
 706    protected $collection_key = 'missing';
 707    protected $internal_gapi_mappings = array(
 708    );
 709    protected $deferredType = 'Google_Service_Datastore_Key';
 710    protected $deferredDataType = 'array';
 711    protected $foundType = 'Google_Service_Datastore_EntityResult';
 712    protected $foundDataType = 'array';
 713    protected $headerType = 'Google_Service_Datastore_ResponseHeader';
 714    protected $headerDataType = '';
 715    protected $missingType = 'Google_Service_Datastore_EntityResult';
 716    protected $missingDataType = 'array';
 717  
 718  
 719    public function setDeferred($deferred)
 720    {
 721      $this->deferred = $deferred;
 722    }
 723    public function getDeferred()
 724    {
 725      return $this->deferred;
 726    }
 727    public function setFound($found)
 728    {
 729      $this->found = $found;
 730    }
 731    public function getFound()
 732    {
 733      return $this->found;
 734    }
 735    public function setHeader(Google_Service_Datastore_ResponseHeader $header)
 736    {
 737      $this->header = $header;
 738    }
 739    public function getHeader()
 740    {
 741      return $this->header;
 742    }
 743    public function setMissing($missing)
 744    {
 745      $this->missing = $missing;
 746    }
 747    public function getMissing()
 748    {
 749      return $this->missing;
 750    }
 751  }
 752  
 753  class Google_Service_Datastore_Mutation extends Google_Collection
 754  {
 755    protected $collection_key = 'upsert';
 756    protected $internal_gapi_mappings = array(
 757    );
 758    protected $deleteType = 'Google_Service_Datastore_Key';
 759    protected $deleteDataType = 'array';
 760    public $force;
 761    protected $insertType = 'Google_Service_Datastore_Entity';
 762    protected $insertDataType = 'array';
 763    protected $insertAutoIdType = 'Google_Service_Datastore_Entity';
 764    protected $insertAutoIdDataType = 'array';
 765    protected $updateType = 'Google_Service_Datastore_Entity';
 766    protected $updateDataType = 'array';
 767    protected $upsertType = 'Google_Service_Datastore_Entity';
 768    protected $upsertDataType = 'array';
 769  
 770  
 771    public function setDelete($delete)
 772    {
 773      $this->delete = $delete;
 774    }
 775    public function getDelete()
 776    {
 777      return $this->delete;
 778    }
 779    public function setForce($force)
 780    {
 781      $this->force = $force;
 782    }
 783    public function getForce()
 784    {
 785      return $this->force;
 786    }
 787    public function setInsert($insert)
 788    {
 789      $this->insert = $insert;
 790    }
 791    public function getInsert()
 792    {
 793      return $this->insert;
 794    }
 795    public function setInsertAutoId($insertAutoId)
 796    {
 797      $this->insertAutoId = $insertAutoId;
 798    }
 799    public function getInsertAutoId()
 800    {
 801      return $this->insertAutoId;
 802    }
 803    public function setUpdate($update)
 804    {
 805      $this->update = $update;
 806    }
 807    public function getUpdate()
 808    {
 809      return $this->update;
 810    }
 811    public function setUpsert($upsert)
 812    {
 813      $this->upsert = $upsert;
 814    }
 815    public function getUpsert()
 816    {
 817      return $this->upsert;
 818    }
 819  }
 820  
 821  class Google_Service_Datastore_MutationResult extends Google_Collection
 822  {
 823    protected $collection_key = 'insertAutoIdKeys';
 824    protected $internal_gapi_mappings = array(
 825    );
 826    public $indexUpdates;
 827    protected $insertAutoIdKeysType = 'Google_Service_Datastore_Key';
 828    protected $insertAutoIdKeysDataType = 'array';
 829  
 830  
 831    public function setIndexUpdates($indexUpdates)
 832    {
 833      $this->indexUpdates = $indexUpdates;
 834    }
 835    public function getIndexUpdates()
 836    {
 837      return $this->indexUpdates;
 838    }
 839    public function setInsertAutoIdKeys($insertAutoIdKeys)
 840    {
 841      $this->insertAutoIdKeys = $insertAutoIdKeys;
 842    }
 843    public function getInsertAutoIdKeys()
 844    {
 845      return $this->insertAutoIdKeys;
 846    }
 847  }
 848  
 849  class Google_Service_Datastore_PartitionId extends Google_Model
 850  {
 851    protected $internal_gapi_mappings = array(
 852    );
 853    public $datasetId;
 854    public $namespace;
 855  
 856  
 857    public function setDatasetId($datasetId)
 858    {
 859      $this->datasetId = $datasetId;
 860    }
 861    public function getDatasetId()
 862    {
 863      return $this->datasetId;
 864    }
 865    public function setNamespace($namespace)
 866    {
 867      $this->namespace = $namespace;
 868    }
 869    public function getNamespace()
 870    {
 871      return $this->namespace;
 872    }
 873  }
 874  
 875  class Google_Service_Datastore_Property extends Google_Collection
 876  {
 877    protected $collection_key = 'listValue';
 878    protected $internal_gapi_mappings = array(
 879    );
 880    public $blobKeyValue;
 881    public $blobValue;
 882    public $booleanValue;
 883    public $dateTimeValue;
 884    public $doubleValue;
 885    protected $entityValueType = 'Google_Service_Datastore_Entity';
 886    protected $entityValueDataType = '';
 887    public $indexed;
 888    public $integerValue;
 889    protected $keyValueType = 'Google_Service_Datastore_Key';
 890    protected $keyValueDataType = '';
 891    protected $listValueType = 'Google_Service_Datastore_Value';
 892    protected $listValueDataType = 'array';
 893    public $meaning;
 894    public $stringValue;
 895  
 896  
 897    public function setBlobKeyValue($blobKeyValue)
 898    {
 899      $this->blobKeyValue = $blobKeyValue;
 900    }
 901    public function getBlobKeyValue()
 902    {
 903      return $this->blobKeyValue;
 904    }
 905    public function setBlobValue($blobValue)
 906    {
 907      $this->blobValue = $blobValue;
 908    }
 909    public function getBlobValue()
 910    {
 911      return $this->blobValue;
 912    }
 913    public function setBooleanValue($booleanValue)
 914    {
 915      $this->booleanValue = $booleanValue;
 916    }
 917    public function getBooleanValue()
 918    {
 919      return $this->booleanValue;
 920    }
 921    public function setDateTimeValue($dateTimeValue)
 922    {
 923      $this->dateTimeValue = $dateTimeValue;
 924    }
 925    public function getDateTimeValue()
 926    {
 927      return $this->dateTimeValue;
 928    }
 929    public function setDoubleValue($doubleValue)
 930    {
 931      $this->doubleValue = $doubleValue;
 932    }
 933    public function getDoubleValue()
 934    {
 935      return $this->doubleValue;
 936    }
 937    public function setEntityValue(Google_Service_Datastore_Entity $entityValue)
 938    {
 939      $this->entityValue = $entityValue;
 940    }
 941    public function getEntityValue()
 942    {
 943      return $this->entityValue;
 944    }
 945    public function setIndexed($indexed)
 946    {
 947      $this->indexed = $indexed;
 948    }
 949    public function getIndexed()
 950    {
 951      return $this->indexed;
 952    }
 953    public function setIntegerValue($integerValue)
 954    {
 955      $this->integerValue = $integerValue;
 956    }
 957    public function getIntegerValue()
 958    {
 959      return $this->integerValue;
 960    }
 961    public function setKeyValue(Google_Service_Datastore_Key $keyValue)
 962    {
 963      $this->keyValue = $keyValue;
 964    }
 965    public function getKeyValue()
 966    {
 967      return $this->keyValue;
 968    }
 969    public function setListValue($listValue)
 970    {
 971      $this->listValue = $listValue;
 972    }
 973    public function getListValue()
 974    {
 975      return $this->listValue;
 976    }
 977    public function setMeaning($meaning)
 978    {
 979      $this->meaning = $meaning;
 980    }
 981    public function getMeaning()
 982    {
 983      return $this->meaning;
 984    }
 985    public function setStringValue($stringValue)
 986    {
 987      $this->stringValue = $stringValue;
 988    }
 989    public function getStringValue()
 990    {
 991      return $this->stringValue;
 992    }
 993  }
 994  
 995  class Google_Service_Datastore_PropertyExpression extends Google_Model
 996  {
 997    protected $internal_gapi_mappings = array(
 998    );
 999    public $aggregationFunction;
1000    protected $propertyType = 'Google_Service_Datastore_PropertyReference';
1001    protected $propertyDataType = '';
1002  
1003  
1004    public function setAggregationFunction($aggregationFunction)
1005    {
1006      $this->aggregationFunction = $aggregationFunction;
1007    }
1008    public function getAggregationFunction()
1009    {
1010      return $this->aggregationFunction;
1011    }
1012    public function setProperty(Google_Service_Datastore_PropertyReference $property)
1013    {
1014      $this->property = $property;
1015    }
1016    public function getProperty()
1017    {
1018      return $this->property;
1019    }
1020  }
1021  
1022  class Google_Service_Datastore_PropertyFilter extends Google_Model
1023  {
1024    protected $internal_gapi_mappings = array(
1025    );
1026    public $operator;
1027    protected $propertyType = 'Google_Service_Datastore_PropertyReference';
1028    protected $propertyDataType = '';
1029    protected $valueType = 'Google_Service_Datastore_Value';
1030    protected $valueDataType = '';
1031  
1032  
1033    public function setOperator($operator)
1034    {
1035      $this->operator = $operator;
1036    }
1037    public function getOperator()
1038    {
1039      return $this->operator;
1040    }
1041    public function setProperty(Google_Service_Datastore_PropertyReference $property)
1042    {
1043      $this->property = $property;
1044    }
1045    public function getProperty()
1046    {
1047      return $this->property;
1048    }
1049    public function setValue(Google_Service_Datastore_Value $value)
1050    {
1051      $this->value = $value;
1052    }
1053    public function getValue()
1054    {
1055      return $this->value;
1056    }
1057  }
1058  
1059  class Google_Service_Datastore_PropertyOrder extends Google_Model
1060  {
1061    protected $internal_gapi_mappings = array(
1062    );
1063    public $direction;
1064    protected $propertyType = 'Google_Service_Datastore_PropertyReference';
1065    protected $propertyDataType = '';
1066  
1067  
1068    public function setDirection($direction)
1069    {
1070      $this->direction = $direction;
1071    }
1072    public function getDirection()
1073    {
1074      return $this->direction;
1075    }
1076    public function setProperty(Google_Service_Datastore_PropertyReference $property)
1077    {
1078      $this->property = $property;
1079    }
1080    public function getProperty()
1081    {
1082      return $this->property;
1083    }
1084  }
1085  
1086  class Google_Service_Datastore_PropertyReference extends Google_Model
1087  {
1088    protected $internal_gapi_mappings = array(
1089    );
1090    public $name;
1091  
1092  
1093    public function setName($name)
1094    {
1095      $this->name = $name;
1096    }
1097    public function getName()
1098    {
1099      return $this->name;
1100    }
1101  }
1102  
1103  class Google_Service_Datastore_Query extends Google_Collection
1104  {
1105    protected $collection_key = 'projection';
1106    protected $internal_gapi_mappings = array(
1107    );
1108    public $endCursor;
1109    protected $filterType = 'Google_Service_Datastore_Filter';
1110    protected $filterDataType = '';
1111    protected $groupByType = 'Google_Service_Datastore_PropertyReference';
1112    protected $groupByDataType = 'array';
1113    protected $kindsType = 'Google_Service_Datastore_KindExpression';
1114    protected $kindsDataType = 'array';
1115    public $limit;
1116    public $offset;
1117    protected $orderType = 'Google_Service_Datastore_PropertyOrder';
1118    protected $orderDataType = 'array';
1119    protected $projectionType = 'Google_Service_Datastore_PropertyExpression';
1120    protected $projectionDataType = 'array';
1121    public $startCursor;
1122  
1123  
1124    public function setEndCursor($endCursor)
1125    {
1126      $this->endCursor = $endCursor;
1127    }
1128    public function getEndCursor()
1129    {
1130      return $this->endCursor;
1131    }
1132    public function setFilter(Google_Service_Datastore_Filter $filter)
1133    {
1134      $this->filter = $filter;
1135    }
1136    public function getFilter()
1137    {
1138      return $this->filter;
1139    }
1140    public function setGroupBy($groupBy)
1141    {
1142      $this->groupBy = $groupBy;
1143    }
1144    public function getGroupBy()
1145    {
1146      return $this->groupBy;
1147    }
1148    public function setKinds($kinds)
1149    {
1150      $this->kinds = $kinds;
1151    }
1152    public function getKinds()
1153    {
1154      return $this->kinds;
1155    }
1156    public function setLimit($limit)
1157    {
1158      $this->limit = $limit;
1159    }
1160    public function getLimit()
1161    {
1162      return $this->limit;
1163    }
1164    public function setOffset($offset)
1165    {
1166      $this->offset = $offset;
1167    }
1168    public function getOffset()
1169    {
1170      return $this->offset;
1171    }
1172    public function setOrder($order)
1173    {
1174      $this->order = $order;
1175    }
1176    public function getOrder()
1177    {
1178      return $this->order;
1179    }
1180    public function setProjection($projection)
1181    {
1182      $this->projection = $projection;
1183    }
1184    public function getProjection()
1185    {
1186      return $this->projection;
1187    }
1188    public function setStartCursor($startCursor)
1189    {
1190      $this->startCursor = $startCursor;
1191    }
1192    public function getStartCursor()
1193    {
1194      return $this->startCursor;
1195    }
1196  }
1197  
1198  class Google_Service_Datastore_QueryResultBatch extends Google_Collection
1199  {
1200    protected $collection_key = 'entityResults';
1201    protected $internal_gapi_mappings = array(
1202    );
1203    public $endCursor;
1204    public $entityResultType;
1205    protected $entityResultsType = 'Google_Service_Datastore_EntityResult';
1206    protected $entityResultsDataType = 'array';
1207    public $moreResults;
1208    public $skippedResults;
1209  
1210  
1211    public function setEndCursor($endCursor)
1212    {
1213      $this->endCursor = $endCursor;
1214    }
1215    public function getEndCursor()
1216    {
1217      return $this->endCursor;
1218    }
1219    public function setEntityResultType($entityResultType)
1220    {
1221      $this->entityResultType = $entityResultType;
1222    }
1223    public function getEntityResultType()
1224    {
1225      return $this->entityResultType;
1226    }
1227    public function setEntityResults($entityResults)
1228    {
1229      $this->entityResults = $entityResults;
1230    }
1231    public function getEntityResults()
1232    {
1233      return $this->entityResults;
1234    }
1235    public function setMoreResults($moreResults)
1236    {
1237      $this->moreResults = $moreResults;
1238    }
1239    public function getMoreResults()
1240    {
1241      return $this->moreResults;
1242    }
1243    public function setSkippedResults($skippedResults)
1244    {
1245      $this->skippedResults = $skippedResults;
1246    }
1247    public function getSkippedResults()
1248    {
1249      return $this->skippedResults;
1250    }
1251  }
1252  
1253  class Google_Service_Datastore_ReadOptions extends Google_Model
1254  {
1255    protected $internal_gapi_mappings = array(
1256    );
1257    public $readConsistency;
1258    public $transaction;
1259  
1260  
1261    public function setReadConsistency($readConsistency)
1262    {
1263      $this->readConsistency = $readConsistency;
1264    }
1265    public function getReadConsistency()
1266    {
1267      return $this->readConsistency;
1268    }
1269    public function setTransaction($transaction)
1270    {
1271      $this->transaction = $transaction;
1272    }
1273    public function getTransaction()
1274    {
1275      return $this->transaction;
1276    }
1277  }
1278  
1279  class Google_Service_Datastore_ResponseHeader extends Google_Model
1280  {
1281    protected $internal_gapi_mappings = array(
1282    );
1283    public $kind;
1284  
1285  
1286    public function setKind($kind)
1287    {
1288      $this->kind = $kind;
1289    }
1290    public function getKind()
1291    {
1292      return $this->kind;
1293    }
1294  }
1295  
1296  class Google_Service_Datastore_RollbackRequest extends Google_Model
1297  {
1298    protected $internal_gapi_mappings = array(
1299    );
1300    public $transaction;
1301  
1302  
1303    public function setTransaction($transaction)
1304    {
1305      $this->transaction = $transaction;
1306    }
1307    public function getTransaction()
1308    {
1309      return $this->transaction;
1310    }
1311  }
1312  
1313  class Google_Service_Datastore_RollbackResponse extends Google_Model
1314  {
1315    protected $internal_gapi_mappings = array(
1316    );
1317    protected $headerType = 'Google_Service_Datastore_ResponseHeader';
1318    protected $headerDataType = '';
1319  
1320  
1321    public function setHeader(Google_Service_Datastore_ResponseHeader $header)
1322    {
1323      $this->header = $header;
1324    }
1325    public function getHeader()
1326    {
1327      return $this->header;
1328    }
1329  }
1330  
1331  class Google_Service_Datastore_RunQueryRequest extends Google_Model
1332  {
1333    protected $internal_gapi_mappings = array(
1334    );
1335    protected $gqlQueryType = 'Google_Service_Datastore_GqlQuery';
1336    protected $gqlQueryDataType = '';
1337    protected $partitionIdType = 'Google_Service_Datastore_PartitionId';
1338    protected $partitionIdDataType = '';
1339    protected $queryType = 'Google_Service_Datastore_Query';
1340    protected $queryDataType = '';
1341    protected $readOptionsType = 'Google_Service_Datastore_ReadOptions';
1342    protected $readOptionsDataType = '';
1343  
1344  
1345    public function setGqlQuery(Google_Service_Datastore_GqlQuery $gqlQuery)
1346    {
1347      $this->gqlQuery = $gqlQuery;
1348    }
1349    public function getGqlQuery()
1350    {
1351      return $this->gqlQuery;
1352    }
1353    public function setPartitionId(Google_Service_Datastore_PartitionId $partitionId)
1354    {
1355      $this->partitionId = $partitionId;
1356    }
1357    public function getPartitionId()
1358    {
1359      return $this->partitionId;
1360    }
1361    public function setQuery(Google_Service_Datastore_Query $query)
1362    {
1363      $this->query = $query;
1364    }
1365    public function getQuery()
1366    {
1367      return $this->query;
1368    }
1369    public function setReadOptions(Google_Service_Datastore_ReadOptions $readOptions)
1370    {
1371      $this->readOptions = $readOptions;
1372    }
1373    public function getReadOptions()
1374    {
1375      return $this->readOptions;
1376    }
1377  }
1378  
1379  class Google_Service_Datastore_RunQueryResponse extends Google_Model
1380  {
1381    protected $internal_gapi_mappings = array(
1382    );
1383    protected $batchType = 'Google_Service_Datastore_QueryResultBatch';
1384    protected $batchDataType = '';
1385    protected $headerType = 'Google_Service_Datastore_ResponseHeader';
1386    protected $headerDataType = '';
1387  
1388  
1389    public function setBatch(Google_Service_Datastore_QueryResultBatch $batch)
1390    {
1391      $this->batch = $batch;
1392    }
1393    public function getBatch()
1394    {
1395      return $this->batch;
1396    }
1397    public function setHeader(Google_Service_Datastore_ResponseHeader $header)
1398    {
1399      $this->header = $header;
1400    }
1401    public function getHeader()
1402    {
1403      return $this->header;
1404    }
1405  }
1406  
1407  class Google_Service_Datastore_Value extends Google_Collection
1408  {
1409    protected $collection_key = 'listValue';
1410    protected $internal_gapi_mappings = array(
1411    );
1412    public $blobKeyValue;
1413    public $blobValue;
1414    public $booleanValue;
1415    public $dateTimeValue;
1416    public $doubleValue;
1417    protected $entityValueType = 'Google_Service_Datastore_Entity';
1418    protected $entityValueDataType = '';
1419    public $indexed;
1420    public $integerValue;
1421    protected $keyValueType = 'Google_Service_Datastore_Key';
1422    protected $keyValueDataType = '';
1423    protected $listValueType = 'Google_Service_Datastore_Value';
1424    protected $listValueDataType = 'array';
1425    public $meaning;
1426    public $stringValue;
1427  
1428  
1429    public function setBlobKeyValue($blobKeyValue)
1430    {
1431      $this->blobKeyValue = $blobKeyValue;
1432    }
1433    public function getBlobKeyValue()
1434    {
1435      return $this->blobKeyValue;
1436    }
1437    public function setBlobValue($blobValue)
1438    {
1439      $this->blobValue = $blobValue;
1440    }
1441    public function getBlobValue()
1442    {
1443      return $this->blobValue;
1444    }
1445    public function setBooleanValue($booleanValue)
1446    {
1447      $this->booleanValue = $booleanValue;
1448    }
1449    public function getBooleanValue()
1450    {
1451      return $this->booleanValue;
1452    }
1453    public function setDateTimeValue($dateTimeValue)
1454    {
1455      $this->dateTimeValue = $dateTimeValue;
1456    }
1457    public function getDateTimeValue()
1458    {
1459      return $this->dateTimeValue;
1460    }
1461    public function setDoubleValue($doubleValue)
1462    {
1463      $this->doubleValue = $doubleValue;
1464    }
1465    public function getDoubleValue()
1466    {
1467      return $this->doubleValue;
1468    }
1469    public function setEntityValue(Google_Service_Datastore_Entity $entityValue)
1470    {
1471      $this->entityValue = $entityValue;
1472    }
1473    public function getEntityValue()
1474    {
1475      return $this->entityValue;
1476    }
1477    public function setIndexed($indexed)
1478    {
1479      $this->indexed = $indexed;
1480    }
1481    public function getIndexed()
1482    {
1483      return $this->indexed;
1484    }
1485    public function setIntegerValue($integerValue)
1486    {
1487      $this->integerValue = $integerValue;
1488    }
1489    public function getIntegerValue()
1490    {
1491      return $this->integerValue;
1492    }
1493    public function setKeyValue(Google_Service_Datastore_Key $keyValue)
1494    {
1495      $this->keyValue = $keyValue;
1496    }
1497    public function getKeyValue()
1498    {
1499      return $this->keyValue;
1500    }
1501    public function setListValue($listValue)
1502    {
1503      $this->listValue = $listValue;
1504    }
1505    public function getListValue()
1506    {
1507      return $this->listValue;
1508    }
1509    public function setMeaning($meaning)
1510    {
1511      $this->meaning = $meaning;
1512    }
1513    public function getMeaning()
1514    {
1515      return $this->meaning;
1516    }
1517    public function setStringValue($stringValue)
1518    {
1519      $this->stringValue = $stringValue;
1520    }
1521    public function getStringValue()
1522    {
1523      return $this->stringValue;
1524    }
1525  }