Search moodle.org's
Developer Documentation

See Release Notes
Long Term Support Release

  • Bug fixes for general core bugs in 4.1.x will end 13 November 2023 (12 months).
  • Bug fixes for security issues in 4.1.x will end 10 November 2025 (36 months).
  • PHP version: minimum PHP 7.4.0 Note: minimum PHP version has increased since Moodle 4.0. PHP 8.0.x is supported too.

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 Fitness (v1).
  20   *
  21   * <p>
  22   * Google Fit API</p>
  23   *
  24   * <p>
  25   * For more information about this service, see the API
  26   * <a href="https://developers.google.com/fit/rest/" target="_blank">Documentation</a>
  27   * </p>
  28   *
  29   * @author Google, Inc.
  30   */
  31  class Google_Service_Fitness extends Google_Service
  32  {
  33    /** View your activity information in Google Fit. */
  34    const FITNESS_ACTIVITY_READ =
  35        "https://www.googleapis.com/auth/fitness.activity.read";
  36    /** View and store your activity information in Google Fit. */
  37    const FITNESS_ACTIVITY_WRITE =
  38        "https://www.googleapis.com/auth/fitness.activity.write";
  39    /** View body sensor information in Google Fit. */
  40    const FITNESS_BODY_READ =
  41        "https://www.googleapis.com/auth/fitness.body.read";
  42    /** View and store body sensor data in Google Fit. */
  43    const FITNESS_BODY_WRITE =
  44        "https://www.googleapis.com/auth/fitness.body.write";
  45    /** View your stored location data in Google Fit. */
  46    const FITNESS_LOCATION_READ =
  47        "https://www.googleapis.com/auth/fitness.location.read";
  48    /** View and store your location data in Google Fit. */
  49    const FITNESS_LOCATION_WRITE =
  50        "https://www.googleapis.com/auth/fitness.location.write";
  51  
  52    public $users_dataSources;
  53    public $users_dataSources_datasets;
  54    public $users_dataset;
  55    public $users_sessions;
  56    
  57  
  58    /**
  59     * Constructs the internal representation of the Fitness service.
  60     *
  61     * @param Google_Client $client
  62     */
  63    public function __construct(Google_Client $client)
  64    {
  65      parent::__construct($client);
  66      $this->rootUrl = 'https://www.googleapis.com/';
  67      $this->servicePath = 'fitness/v1/users/';
  68      $this->version = 'v1';
  69      $this->serviceName = 'fitness';
  70  
  71      $this->users_dataSources = new Google_Service_Fitness_UsersDataSources_Resource(
  72          $this,
  73          $this->serviceName,
  74          'dataSources',
  75          array(
  76            'methods' => array(
  77              'create' => array(
  78                'path' => '{userId}/dataSources',
  79                'httpMethod' => 'POST',
  80                'parameters' => array(
  81                  'userId' => array(
  82                    'location' => 'path',
  83                    'type' => 'string',
  84                    'required' => true,
  85                  ),
  86                ),
  87              ),'delete' => array(
  88                'path' => '{userId}/dataSources/{dataSourceId}',
  89                'httpMethod' => 'DELETE',
  90                'parameters' => array(
  91                  'userId' => array(
  92                    'location' => 'path',
  93                    'type' => 'string',
  94                    'required' => true,
  95                  ),
  96                  'dataSourceId' => array(
  97                    'location' => 'path',
  98                    'type' => 'string',
  99                    'required' => true,
 100                  ),
 101                ),
 102              ),'get' => array(
 103                'path' => '{userId}/dataSources/{dataSourceId}',
 104                'httpMethod' => 'GET',
 105                'parameters' => array(
 106                  'userId' => array(
 107                    'location' => 'path',
 108                    'type' => 'string',
 109                    'required' => true,
 110                  ),
 111                  'dataSourceId' => array(
 112                    'location' => 'path',
 113                    'type' => 'string',
 114                    'required' => true,
 115                  ),
 116                ),
 117              ),'list' => array(
 118                'path' => '{userId}/dataSources',
 119                'httpMethod' => 'GET',
 120                'parameters' => array(
 121                  'userId' => array(
 122                    'location' => 'path',
 123                    'type' => 'string',
 124                    'required' => true,
 125                  ),
 126                  'dataTypeName' => array(
 127                    'location' => 'query',
 128                    'type' => 'string',
 129                    'repeated' => true,
 130                  ),
 131                ),
 132              ),'patch' => array(
 133                'path' => '{userId}/dataSources/{dataSourceId}',
 134                'httpMethod' => 'PATCH',
 135                'parameters' => array(
 136                  'userId' => array(
 137                    'location' => 'path',
 138                    'type' => 'string',
 139                    'required' => true,
 140                  ),
 141                  'dataSourceId' => array(
 142                    'location' => 'path',
 143                    'type' => 'string',
 144                    'required' => true,
 145                  ),
 146                ),
 147              ),'update' => array(
 148                'path' => '{userId}/dataSources/{dataSourceId}',
 149                'httpMethod' => 'PUT',
 150                'parameters' => array(
 151                  'userId' => array(
 152                    'location' => 'path',
 153                    'type' => 'string',
 154                    'required' => true,
 155                  ),
 156                  'dataSourceId' => array(
 157                    'location' => 'path',
 158                    'type' => 'string',
 159                    'required' => true,
 160                  ),
 161                ),
 162              ),
 163            )
 164          )
 165      );
 166      $this->users_dataSources_datasets = new Google_Service_Fitness_UsersDataSourcesDatasets_Resource(
 167          $this,
 168          $this->serviceName,
 169          'datasets',
 170          array(
 171            'methods' => array(
 172              'delete' => array(
 173                'path' => '{userId}/dataSources/{dataSourceId}/datasets/{datasetId}',
 174                'httpMethod' => 'DELETE',
 175                'parameters' => array(
 176                  'userId' => array(
 177                    'location' => 'path',
 178                    'type' => 'string',
 179                    'required' => true,
 180                  ),
 181                  'dataSourceId' => array(
 182                    'location' => 'path',
 183                    'type' => 'string',
 184                    'required' => true,
 185                  ),
 186                  'datasetId' => array(
 187                    'location' => 'path',
 188                    'type' => 'string',
 189                    'required' => true,
 190                  ),
 191                  'modifiedTimeMillis' => array(
 192                    'location' => 'query',
 193                    'type' => 'string',
 194                  ),
 195                  'currentTimeMillis' => array(
 196                    'location' => 'query',
 197                    'type' => 'string',
 198                  ),
 199                ),
 200              ),'get' => array(
 201                'path' => '{userId}/dataSources/{dataSourceId}/datasets/{datasetId}',
 202                'httpMethod' => 'GET',
 203                'parameters' => array(
 204                  'userId' => array(
 205                    'location' => 'path',
 206                    'type' => 'string',
 207                    'required' => true,
 208                  ),
 209                  'dataSourceId' => array(
 210                    'location' => 'path',
 211                    'type' => 'string',
 212                    'required' => true,
 213                  ),
 214                  'datasetId' => array(
 215                    'location' => 'path',
 216                    'type' => 'string',
 217                    'required' => true,
 218                  ),
 219                  'limit' => array(
 220                    'location' => 'query',
 221                    'type' => 'integer',
 222                  ),
 223                  'pageToken' => array(
 224                    'location' => 'query',
 225                    'type' => 'string',
 226                  ),
 227                ),
 228              ),'patch' => array(
 229                'path' => '{userId}/dataSources/{dataSourceId}/datasets/{datasetId}',
 230                'httpMethod' => 'PATCH',
 231                'parameters' => array(
 232                  'userId' => array(
 233                    'location' => 'path',
 234                    'type' => 'string',
 235                    'required' => true,
 236                  ),
 237                  'dataSourceId' => array(
 238                    'location' => 'path',
 239                    'type' => 'string',
 240                    'required' => true,
 241                  ),
 242                  'datasetId' => array(
 243                    'location' => 'path',
 244                    'type' => 'string',
 245                    'required' => true,
 246                  ),
 247                  'currentTimeMillis' => array(
 248                    'location' => 'query',
 249                    'type' => 'string',
 250                  ),
 251                ),
 252              ),
 253            )
 254          )
 255      );
 256      $this->users_dataset = new Google_Service_Fitness_UsersDataset_Resource(
 257          $this,
 258          $this->serviceName,
 259          'dataset',
 260          array(
 261            'methods' => array(
 262              'aggregate' => array(
 263                'path' => '{userId}/dataset:aggregate',
 264                'httpMethod' => 'POST',
 265                'parameters' => array(
 266                  'userId' => array(
 267                    'location' => 'path',
 268                    'type' => 'string',
 269                    'required' => true,
 270                  ),
 271                ),
 272              ),
 273            )
 274          )
 275      );
 276      $this->users_sessions = new Google_Service_Fitness_UsersSessions_Resource(
 277          $this,
 278          $this->serviceName,
 279          'sessions',
 280          array(
 281            'methods' => array(
 282              'delete' => array(
 283                'path' => '{userId}/sessions/{sessionId}',
 284                'httpMethod' => 'DELETE',
 285                'parameters' => array(
 286                  'userId' => array(
 287                    'location' => 'path',
 288                    'type' => 'string',
 289                    'required' => true,
 290                  ),
 291                  'sessionId' => array(
 292                    'location' => 'path',
 293                    'type' => 'string',
 294                    'required' => true,
 295                  ),
 296                  'currentTimeMillis' => array(
 297                    'location' => 'query',
 298                    'type' => 'string',
 299                  ),
 300                ),
 301              ),'list' => array(
 302                'path' => '{userId}/sessions',
 303                'httpMethod' => 'GET',
 304                'parameters' => array(
 305                  'userId' => array(
 306                    'location' => 'path',
 307                    'type' => 'string',
 308                    'required' => true,
 309                  ),
 310                  'pageToken' => array(
 311                    'location' => 'query',
 312                    'type' => 'string',
 313                  ),
 314                  'endTime' => array(
 315                    'location' => 'query',
 316                    'type' => 'string',
 317                  ),
 318                  'includeDeleted' => array(
 319                    'location' => 'query',
 320                    'type' => 'boolean',
 321                  ),
 322                  'startTime' => array(
 323                    'location' => 'query',
 324                    'type' => 'string',
 325                  ),
 326                ),
 327              ),'update' => array(
 328                'path' => '{userId}/sessions/{sessionId}',
 329                'httpMethod' => 'PUT',
 330                'parameters' => array(
 331                  'userId' => array(
 332                    'location' => 'path',
 333                    'type' => 'string',
 334                    'required' => true,
 335                  ),
 336                  'sessionId' => array(
 337                    'location' => 'path',
 338                    'type' => 'string',
 339                    'required' => true,
 340                  ),
 341                  'currentTimeMillis' => array(
 342                    'location' => 'query',
 343                    'type' => 'string',
 344                  ),
 345                ),
 346              ),
 347            )
 348          )
 349      );
 350    }
 351  }
 352  
 353  
 354  /**
 355   * The "users" collection of methods.
 356   * Typical usage is:
 357   *  <code>
 358   *   $fitnessService = new Google_Service_Fitness(...);
 359   *   $users = $fitnessService->users;
 360   *  </code>
 361   */
 362  class Google_Service_Fitness_Users_Resource extends Google_Service_Resource
 363  {
 364  }
 365  
 366  /**
 367   * The "dataSources" collection of methods.
 368   * Typical usage is:
 369   *  <code>
 370   *   $fitnessService = new Google_Service_Fitness(...);
 371   *   $dataSources = $fitnessService->dataSources;
 372   *  </code>
 373   */
 374  class Google_Service_Fitness_UsersDataSources_Resource extends Google_Service_Resource
 375  {
 376  
 377    /**
 378     * Creates a new data source that is unique across all data sources belonging to
 379     * this user. The data stream ID field can be omitted and will be generated by
 380     * the server with the correct format. The data stream ID is an ordered
 381     * combination of some fields from the data source. In addition to the data
 382     * source fields reflected into the data source ID, the developer project number
 383     * that is authenticated when creating the data source is included. This
 384     * developer project number is obfuscated when read by any other developer
 385     * reading public data types. (dataSources.create)
 386     *
 387     * @param string $userId Create the data source for the person identified. Use
 388     * me to indicate the authenticated user. Only me is supported at this time.
 389     * @param Google_DataSource $postBody
 390     * @param array $optParams Optional parameters.
 391     * @return Google_Service_Fitness_DataSource
 392     */
 393    public function create($userId, Google_Service_Fitness_DataSource $postBody, $optParams = array())
 394    {
 395      $params = array('userId' => $userId, 'postBody' => $postBody);
 396      $params = array_merge($params, $optParams);
 397      return $this->call('create', array($params), "Google_Service_Fitness_DataSource");
 398    }
 399  
 400    /**
 401     * Delete the data source if there are no datapoints associated with it
 402     * (dataSources.delete)
 403     *
 404     * @param string $userId Retrieve a data source for the person identified. Use
 405     * me to indicate the authenticated user. Only me is supported at this time.
 406     * @param string $dataSourceId The data stream ID of the data source to delete.
 407     * @param array $optParams Optional parameters.
 408     * @return Google_Service_Fitness_DataSource
 409     */
 410    public function delete($userId, $dataSourceId, $optParams = array())
 411    {
 412      $params = array('userId' => $userId, 'dataSourceId' => $dataSourceId);
 413      $params = array_merge($params, $optParams);
 414      return $this->call('delete', array($params), "Google_Service_Fitness_DataSource");
 415    }
 416  
 417    /**
 418     * Returns a data source identified by a data stream ID. (dataSources.get)
 419     *
 420     * @param string $userId Retrieve a data source for the person identified. Use
 421     * me to indicate the authenticated user. Only me is supported at this time.
 422     * @param string $dataSourceId The data stream ID of the data source to
 423     * retrieve.
 424     * @param array $optParams Optional parameters.
 425     * @return Google_Service_Fitness_DataSource
 426     */
 427    public function get($userId, $dataSourceId, $optParams = array())
 428    {
 429      $params = array('userId' => $userId, 'dataSourceId' => $dataSourceId);
 430      $params = array_merge($params, $optParams);
 431      return $this->call('get', array($params), "Google_Service_Fitness_DataSource");
 432    }
 433  
 434    /**
 435     * Lists all data sources that are visible to the developer, using the OAuth
 436     * scopes provided. The list is not exhaustive: the user may have private data
 437     * sources that are only visible to other developers or calls using other
 438     * scopes. (dataSources.listUsersDataSources)
 439     *
 440     * @param string $userId List data sources for the person identified. Use me to
 441     * indicate the authenticated user. Only me is supported at this time.
 442     * @param array $optParams Optional parameters.
 443     *
 444     * @opt_param string dataTypeName The names of data types to include in the
 445     * list. If not specified, all data sources will be returned.
 446     * @return Google_Service_Fitness_ListDataSourcesResponse
 447     */
 448    public function listUsersDataSources($userId, $optParams = array())
 449    {
 450      $params = array('userId' => $userId);
 451      $params = array_merge($params, $optParams);
 452      return $this->call('list', array($params), "Google_Service_Fitness_ListDataSourcesResponse");
 453    }
 454  
 455    /**
 456     * Updates a given data source. It is an error to modify the data source's data
 457     * stream ID, data type, type, stream name or device information apart from the
 458     * device version. Changing these fields would require a new unique data stream
 459     * ID and separate data source.
 460     *
 461     * Data sources are identified by their data stream ID. This method supports
 462     * patch semantics. (dataSources.patch)
 463     *
 464     * @param string $userId Update the data source for the person identified. Use
 465     * me to indicate the authenticated user. Only me is supported at this time.
 466     * @param string $dataSourceId The data stream ID of the data source to update.
 467     * @param Google_DataSource $postBody
 468     * @param array $optParams Optional parameters.
 469     * @return Google_Service_Fitness_DataSource
 470     */
 471    public function patch($userId, $dataSourceId, Google_Service_Fitness_DataSource $postBody, $optParams = array())
 472    {
 473      $params = array('userId' => $userId, 'dataSourceId' => $dataSourceId, 'postBody' => $postBody);
 474      $params = array_merge($params, $optParams);
 475      return $this->call('patch', array($params), "Google_Service_Fitness_DataSource");
 476    }
 477  
 478    /**
 479     * Updates a given data source. It is an error to modify the data source's data
 480     * stream ID, data type, type, stream name or device information apart from the
 481     * device version. Changing these fields would require a new unique data stream
 482     * ID and separate data source.
 483     *
 484     * Data sources are identified by their data stream ID. (dataSources.update)
 485     *
 486     * @param string $userId Update the data source for the person identified. Use
 487     * me to indicate the authenticated user. Only me is supported at this time.
 488     * @param string $dataSourceId The data stream ID of the data source to update.
 489     * @param Google_DataSource $postBody
 490     * @param array $optParams Optional parameters.
 491     * @return Google_Service_Fitness_DataSource
 492     */
 493    public function update($userId, $dataSourceId, Google_Service_Fitness_DataSource $postBody, $optParams = array())
 494    {
 495      $params = array('userId' => $userId, 'dataSourceId' => $dataSourceId, 'postBody' => $postBody);
 496      $params = array_merge($params, $optParams);
 497      return $this->call('update', array($params), "Google_Service_Fitness_DataSource");
 498    }
 499  }
 500  
 501  /**
 502   * The "datasets" collection of methods.
 503   * Typical usage is:
 504   *  <code>
 505   *   $fitnessService = new Google_Service_Fitness(...);
 506   *   $datasets = $fitnessService->datasets;
 507   *  </code>
 508   */
 509  class Google_Service_Fitness_UsersDataSourcesDatasets_Resource extends Google_Service_Resource
 510  {
 511  
 512    /**
 513     * Performs an inclusive delete of all data points whose start and end times
 514     * have any overlap with the time range specified by the dataset ID. For most
 515     * data types, the entire data point will be deleted. For data types where the
 516     * time span represents a consistent value (such as
 517     * com.google.activity.segment), and a data point straddles either end point of
 518     * the dataset, only the overlapping portion of the data point will be deleted.
 519     * (datasets.delete)
 520     *
 521     * @param string $userId Delete a dataset for the person identified. Use me to
 522     * indicate the authenticated user. Only me is supported at this time.
 523     * @param string $dataSourceId The data stream ID of the data source that
 524     * created the dataset.
 525     * @param string $datasetId Dataset identifier that is a composite of the
 526     * minimum data point start time and maximum data point end time represented as
 527     * nanoseconds from the epoch. The ID is formatted like: "startTime-endTime"
 528     * where startTime and endTime are 64 bit integers.
 529     * @param array $optParams Optional parameters.
 530     *
 531     * @opt_param string modifiedTimeMillis When the operation was performed on the
 532     * client.
 533     * @opt_param string currentTimeMillis The client's current time in milliseconds
 534     * since epoch.
 535     */
 536    public function delete($userId, $dataSourceId, $datasetId, $optParams = array())
 537    {
 538      $params = array('userId' => $userId, 'dataSourceId' => $dataSourceId, 'datasetId' => $datasetId);
 539      $params = array_merge($params, $optParams);
 540      return $this->call('delete', array($params));
 541    }
 542  
 543    /**
 544     * Returns a dataset containing all data points whose start and end times
 545     * overlap with the specified range of the dataset minimum start time and
 546     * maximum end time. Specifically, any data point whose start time is less than
 547     * or equal to the dataset end time and whose end time is greater than or equal
 548     * to the dataset start time. (datasets.get)
 549     *
 550     * @param string $userId Retrieve a dataset for the person identified. Use me to
 551     * indicate the authenticated user. Only me is supported at this time.
 552     * @param string $dataSourceId The data stream ID of the data source that
 553     * created the dataset.
 554     * @param string $datasetId Dataset identifier that is a composite of the
 555     * minimum data point start time and maximum data point end time represented as
 556     * nanoseconds from the epoch. The ID is formatted like: "startTime-endTime"
 557     * where startTime and endTime are 64 bit integers.
 558     * @param array $optParams Optional parameters.
 559     *
 560     * @opt_param int limit If specified, no more than this many data points will be
 561     * included in the dataset. If the there are more data points in the dataset,
 562     * nextPageToken will be set in the dataset response.
 563     * @opt_param string pageToken The continuation token, which is used to page
 564     * through large datasets. To get the next page of a dataset, set this parameter
 565     * to the value of nextPageToken from the previous response. Each subsequent
 566     * call will yield a partial dataset with data point end timestamps that are
 567     * strictly smaller than those in the previous partial response.
 568     * @return Google_Service_Fitness_Dataset
 569     */
 570    public function get($userId, $dataSourceId, $datasetId, $optParams = array())
 571    {
 572      $params = array('userId' => $userId, 'dataSourceId' => $dataSourceId, 'datasetId' => $datasetId);
 573      $params = array_merge($params, $optParams);
 574      return $this->call('get', array($params), "Google_Service_Fitness_Dataset");
 575    }
 576  
 577    /**
 578     * Adds data points to a dataset. The dataset need not be previously created.
 579     * All points within the given dataset will be returned with subsquent calls to
 580     * retrieve this dataset. Data points can belong to more than one dataset. This
 581     * method does not use patch semantics. (datasets.patch)
 582     *
 583     * @param string $userId Patch a dataset for the person identified. Use me to
 584     * indicate the authenticated user. Only me is supported at this time.
 585     * @param string $dataSourceId The data stream ID of the data source that
 586     * created the dataset.
 587     * @param string $datasetId Dataset identifier that is a composite of the
 588     * minimum data point start time and maximum data point end time represented as
 589     * nanoseconds from the epoch. The ID is formatted like: "startTime-endTime"
 590     * where startTime and endTime are 64 bit integers.
 591     * @param Google_Dataset $postBody
 592     * @param array $optParams Optional parameters.
 593     *
 594     * @opt_param string currentTimeMillis The client's current time in milliseconds
 595     * since epoch. Note that the minStartTimeNs and maxEndTimeNs properties in the
 596     * request body are in nanoseconds instead of milliseconds.
 597     * @return Google_Service_Fitness_Dataset
 598     */
 599    public function patch($userId, $dataSourceId, $datasetId, Google_Service_Fitness_Dataset $postBody, $optParams = array())
 600    {
 601      $params = array('userId' => $userId, 'dataSourceId' => $dataSourceId, 'datasetId' => $datasetId, 'postBody' => $postBody);
 602      $params = array_merge($params, $optParams);
 603      return $this->call('patch', array($params), "Google_Service_Fitness_Dataset");
 604    }
 605  }
 606  /**
 607   * The "dataset" collection of methods.
 608   * Typical usage is:
 609   *  <code>
 610   *   $fitnessService = new Google_Service_Fitness(...);
 611   *   $dataset = $fitnessService->dataset;
 612   *  </code>
 613   */
 614  class Google_Service_Fitness_UsersDataset_Resource extends Google_Service_Resource
 615  {
 616  
 617    /**
 618     * Aggregates data of a certain type or stream into buckets divided by a given
 619     * type of boundary. Multiple data sets of multiple types and from multiple
 620     * sources can be aggreated into exactly one bucket type per request.
 621     * (dataset.aggregate)
 622     *
 623     * @param string $userId Aggregate data for the person identified. Use me to
 624     * indicate the authenticated user. Only me is supported at this time.
 625     * @param Google_AggregateRequest $postBody
 626     * @param array $optParams Optional parameters.
 627     * @return Google_Service_Fitness_AggregateResponse
 628     */
 629    public function aggregate($userId, Google_Service_Fitness_AggregateRequest $postBody, $optParams = array())
 630    {
 631      $params = array('userId' => $userId, 'postBody' => $postBody);
 632      $params = array_merge($params, $optParams);
 633      return $this->call('aggregate', array($params), "Google_Service_Fitness_AggregateResponse");
 634    }
 635  }
 636  /**
 637   * The "sessions" collection of methods.
 638   * Typical usage is:
 639   *  <code>
 640   *   $fitnessService = new Google_Service_Fitness(...);
 641   *   $sessions = $fitnessService->sessions;
 642   *  </code>
 643   */
 644  class Google_Service_Fitness_UsersSessions_Resource extends Google_Service_Resource
 645  {
 646  
 647    /**
 648     * Deletes a session specified by the given session ID. (sessions.delete)
 649     *
 650     * @param string $userId Delete a session for the person identified. Use me to
 651     * indicate the authenticated user. Only me is supported at this time.
 652     * @param string $sessionId The ID of the session to be deleted.
 653     * @param array $optParams Optional parameters.
 654     *
 655     * @opt_param string currentTimeMillis The client's current time in milliseconds
 656     * since epoch.
 657     */
 658    public function delete($userId, $sessionId, $optParams = array())
 659    {
 660      $params = array('userId' => $userId, 'sessionId' => $sessionId);
 661      $params = array_merge($params, $optParams);
 662      return $this->call('delete', array($params));
 663    }
 664  
 665    /**
 666     * Lists sessions previously created. (sessions.listUsersSessions)
 667     *
 668     * @param string $userId List sessions for the person identified. Use me to
 669     * indicate the authenticated user. Only me is supported at this time.
 670     * @param array $optParams Optional parameters.
 671     *
 672     * @opt_param string pageToken The continuation token, which is used to page
 673     * through large result sets. To get the next page of results, set this
 674     * parameter to the value of nextPageToken from the previous response.
 675     * @opt_param string endTime An RFC3339 timestamp. Only sessions ending between
 676     * the start and end times will be included in the response.
 677     * @opt_param bool includeDeleted If true, deleted sessions will be returned.
 678     * When set to true, sessions returned in this response will only have an ID and
 679     * will not have any other fields.
 680     * @opt_param string startTime An RFC3339 timestamp. Only sessions ending
 681     * between the start and end times will be included in the response.
 682     * @return Google_Service_Fitness_ListSessionsResponse
 683     */
 684    public function listUsersSessions($userId, $optParams = array())
 685    {
 686      $params = array('userId' => $userId);
 687      $params = array_merge($params, $optParams);
 688      return $this->call('list', array($params), "Google_Service_Fitness_ListSessionsResponse");
 689    }
 690  
 691    /**
 692     * Updates or insert a given session. (sessions.update)
 693     *
 694     * @param string $userId Create sessions for the person identified. Use me to
 695     * indicate the authenticated user. Only me is supported at this time.
 696     * @param string $sessionId The ID of the session to be created.
 697     * @param Google_Session $postBody
 698     * @param array $optParams Optional parameters.
 699     *
 700     * @opt_param string currentTimeMillis The client's current time in milliseconds
 701     * since epoch.
 702     * @return Google_Service_Fitness_Session
 703     */
 704    public function update($userId, $sessionId, Google_Service_Fitness_Session $postBody, $optParams = array())
 705    {
 706      $params = array('userId' => $userId, 'sessionId' => $sessionId, 'postBody' => $postBody);
 707      $params = array_merge($params, $optParams);
 708      return $this->call('update', array($params), "Google_Service_Fitness_Session");
 709    }
 710  }
 711  
 712  
 713  
 714  
 715  class Google_Service_Fitness_AggregateBucket extends Google_Collection
 716  {
 717    protected $collection_key = 'dataset';
 718    protected $internal_gapi_mappings = array(
 719    );
 720    public $activity;
 721    protected $datasetType = 'Google_Service_Fitness_Dataset';
 722    protected $datasetDataType = 'array';
 723    public $endTimeMillis;
 724    protected $sessionType = 'Google_Service_Fitness_Session';
 725    protected $sessionDataType = '';
 726    public $startTimeMillis;
 727    public $type;
 728  
 729  
 730    public function setActivity($activity)
 731    {
 732      $this->activity = $activity;
 733    }
 734    public function getActivity()
 735    {
 736      return $this->activity;
 737    }
 738    public function setDataset($dataset)
 739    {
 740      $this->dataset = $dataset;
 741    }
 742    public function getDataset()
 743    {
 744      return $this->dataset;
 745    }
 746    public function setEndTimeMillis($endTimeMillis)
 747    {
 748      $this->endTimeMillis = $endTimeMillis;
 749    }
 750    public function getEndTimeMillis()
 751    {
 752      return $this->endTimeMillis;
 753    }
 754    public function setSession(Google_Service_Fitness_Session $session)
 755    {
 756      $this->session = $session;
 757    }
 758    public function getSession()
 759    {
 760      return $this->session;
 761    }
 762    public function setStartTimeMillis($startTimeMillis)
 763    {
 764      $this->startTimeMillis = $startTimeMillis;
 765    }
 766    public function getStartTimeMillis()
 767    {
 768      return $this->startTimeMillis;
 769    }
 770    public function setType($type)
 771    {
 772      $this->type = $type;
 773    }
 774    public function getType()
 775    {
 776      return $this->type;
 777    }
 778  }
 779  
 780  class Google_Service_Fitness_AggregateBy extends Google_Model
 781  {
 782    protected $internal_gapi_mappings = array(
 783    );
 784    public $dataSourceId;
 785    public $dataTypeName;
 786  
 787  
 788    public function setDataSourceId($dataSourceId)
 789    {
 790      $this->dataSourceId = $dataSourceId;
 791    }
 792    public function getDataSourceId()
 793    {
 794      return $this->dataSourceId;
 795    }
 796    public function setDataTypeName($dataTypeName)
 797    {
 798      $this->dataTypeName = $dataTypeName;
 799    }
 800    public function getDataTypeName()
 801    {
 802      return $this->dataTypeName;
 803    }
 804  }
 805  
 806  class Google_Service_Fitness_AggregateRequest extends Google_Collection
 807  {
 808    protected $collection_key = 'aggregateBy';
 809    protected $internal_gapi_mappings = array(
 810    );
 811    protected $aggregateByType = 'Google_Service_Fitness_AggregateBy';
 812    protected $aggregateByDataType = 'array';
 813    protected $bucketByActivitySegmentType = 'Google_Service_Fitness_BucketByActivity';
 814    protected $bucketByActivitySegmentDataType = '';
 815    protected $bucketByActivityTypeType = 'Google_Service_Fitness_BucketByActivity';
 816    protected $bucketByActivityTypeDataType = '';
 817    protected $bucketBySessionType = 'Google_Service_Fitness_BucketBySession';
 818    protected $bucketBySessionDataType = '';
 819    protected $bucketByTimeType = 'Google_Service_Fitness_BucketByTime';
 820    protected $bucketByTimeDataType = '';
 821    public $endTimeMillis;
 822    public $startTimeMillis;
 823  
 824  
 825    public function setAggregateBy($aggregateBy)
 826    {
 827      $this->aggregateBy = $aggregateBy;
 828    }
 829    public function getAggregateBy()
 830    {
 831      return $this->aggregateBy;
 832    }
 833    public function setBucketByActivitySegment(Google_Service_Fitness_BucketByActivity $bucketByActivitySegment)
 834    {
 835      $this->bucketByActivitySegment = $bucketByActivitySegment;
 836    }
 837    public function getBucketByActivitySegment()
 838    {
 839      return $this->bucketByActivitySegment;
 840    }
 841    public function setBucketByActivityType(Google_Service_Fitness_BucketByActivity $bucketByActivityType)
 842    {
 843      $this->bucketByActivityType = $bucketByActivityType;
 844    }
 845    public function getBucketByActivityType()
 846    {
 847      return $this->bucketByActivityType;
 848    }
 849    public function setBucketBySession(Google_Service_Fitness_BucketBySession $bucketBySession)
 850    {
 851      $this->bucketBySession = $bucketBySession;
 852    }
 853    public function getBucketBySession()
 854    {
 855      return $this->bucketBySession;
 856    }
 857    public function setBucketByTime(Google_Service_Fitness_BucketByTime $bucketByTime)
 858    {
 859      $this->bucketByTime = $bucketByTime;
 860    }
 861    public function getBucketByTime()
 862    {
 863      return $this->bucketByTime;
 864    }
 865    public function setEndTimeMillis($endTimeMillis)
 866    {
 867      $this->endTimeMillis = $endTimeMillis;
 868    }
 869    public function getEndTimeMillis()
 870    {
 871      return $this->endTimeMillis;
 872    }
 873    public function setStartTimeMillis($startTimeMillis)
 874    {
 875      $this->startTimeMillis = $startTimeMillis;
 876    }
 877    public function getStartTimeMillis()
 878    {
 879      return $this->startTimeMillis;
 880    }
 881  }
 882  
 883  class Google_Service_Fitness_AggregateResponse extends Google_Collection
 884  {
 885    protected $collection_key = 'bucket';
 886    protected $internal_gapi_mappings = array(
 887    );
 888    protected $bucketType = 'Google_Service_Fitness_AggregateBucket';
 889    protected $bucketDataType = 'array';
 890  
 891  
 892    public function setBucket($bucket)
 893    {
 894      $this->bucket = $bucket;
 895    }
 896    public function getBucket()
 897    {
 898      return $this->bucket;
 899    }
 900  }
 901  
 902  class Google_Service_Fitness_Application extends Google_Model
 903  {
 904    protected $internal_gapi_mappings = array(
 905    );
 906    public $detailsUrl;
 907    public $name;
 908    public $packageName;
 909    public $version;
 910  
 911  
 912    public function setDetailsUrl($detailsUrl)
 913    {
 914      $this->detailsUrl = $detailsUrl;
 915    }
 916    public function getDetailsUrl()
 917    {
 918      return $this->detailsUrl;
 919    }
 920    public function setName($name)
 921    {
 922      $this->name = $name;
 923    }
 924    public function getName()
 925    {
 926      return $this->name;
 927    }
 928    public function setPackageName($packageName)
 929    {
 930      $this->packageName = $packageName;
 931    }
 932    public function getPackageName()
 933    {
 934      return $this->packageName;
 935    }
 936    public function setVersion($version)
 937    {
 938      $this->version = $version;
 939    }
 940    public function getVersion()
 941    {
 942      return $this->version;
 943    }
 944  }
 945  
 946  class Google_Service_Fitness_BucketByActivity extends Google_Model
 947  {
 948    protected $internal_gapi_mappings = array(
 949    );
 950    public $activityDataSourceId;
 951    public $minDurationMillis;
 952  
 953  
 954    public function setActivityDataSourceId($activityDataSourceId)
 955    {
 956      $this->activityDataSourceId = $activityDataSourceId;
 957    }
 958    public function getActivityDataSourceId()
 959    {
 960      return $this->activityDataSourceId;
 961    }
 962    public function setMinDurationMillis($minDurationMillis)
 963    {
 964      $this->minDurationMillis = $minDurationMillis;
 965    }
 966    public function getMinDurationMillis()
 967    {
 968      return $this->minDurationMillis;
 969    }
 970  }
 971  
 972  class Google_Service_Fitness_BucketBySession extends Google_Model
 973  {
 974    protected $internal_gapi_mappings = array(
 975    );
 976    public $minDurationMillis;
 977  
 978  
 979    public function setMinDurationMillis($minDurationMillis)
 980    {
 981      $this->minDurationMillis = $minDurationMillis;
 982    }
 983    public function getMinDurationMillis()
 984    {
 985      return $this->minDurationMillis;
 986    }
 987  }
 988  
 989  class Google_Service_Fitness_BucketByTime extends Google_Model
 990  {
 991    protected $internal_gapi_mappings = array(
 992    );
 993    public $durationMillis;
 994  
 995  
 996    public function setDurationMillis($durationMillis)
 997    {
 998      $this->durationMillis = $durationMillis;
 999    }
1000    public function getDurationMillis()
1001    {
1002      return $this->durationMillis;
1003    }
1004  }
1005  
1006  class Google_Service_Fitness_DataPoint extends Google_Collection
1007  {
1008    protected $collection_key = 'value';
1009    protected $internal_gapi_mappings = array(
1010    );
1011    public $computationTimeMillis;
1012    public $dataTypeName;
1013    public $endTimeNanos;
1014    public $modifiedTimeMillis;
1015    public $originDataSourceId;
1016    public $rawTimestampNanos;
1017    public $startTimeNanos;
1018    protected $valueType = 'Google_Service_Fitness_Value';
1019    protected $valueDataType = 'array';
1020  
1021  
1022    public function setComputationTimeMillis($computationTimeMillis)
1023    {
1024      $this->computationTimeMillis = $computationTimeMillis;
1025    }
1026    public function getComputationTimeMillis()
1027    {
1028      return $this->computationTimeMillis;
1029    }
1030    public function setDataTypeName($dataTypeName)
1031    {
1032      $this->dataTypeName = $dataTypeName;
1033    }
1034    public function getDataTypeName()
1035    {
1036      return $this->dataTypeName;
1037    }
1038    public function setEndTimeNanos($endTimeNanos)
1039    {
1040      $this->endTimeNanos = $endTimeNanos;
1041    }
1042    public function getEndTimeNanos()
1043    {
1044      return $this->endTimeNanos;
1045    }
1046    public function setModifiedTimeMillis($modifiedTimeMillis)
1047    {
1048      $this->modifiedTimeMillis = $modifiedTimeMillis;
1049    }
1050    public function getModifiedTimeMillis()
1051    {
1052      return $this->modifiedTimeMillis;
1053    }
1054    public function setOriginDataSourceId($originDataSourceId)
1055    {
1056      $this->originDataSourceId = $originDataSourceId;
1057    }
1058    public function getOriginDataSourceId()
1059    {
1060      return $this->originDataSourceId;
1061    }
1062    public function setRawTimestampNanos($rawTimestampNanos)
1063    {
1064      $this->rawTimestampNanos = $rawTimestampNanos;
1065    }
1066    public function getRawTimestampNanos()
1067    {
1068      return $this->rawTimestampNanos;
1069    }
1070    public function setStartTimeNanos($startTimeNanos)
1071    {
1072      $this->startTimeNanos = $startTimeNanos;
1073    }
1074    public function getStartTimeNanos()
1075    {
1076      return $this->startTimeNanos;
1077    }
1078    public function setValue($value)
1079    {
1080      $this->value = $value;
1081    }
1082    public function getValue()
1083    {
1084      return $this->value;
1085    }
1086  }
1087  
1088  class Google_Service_Fitness_DataSource extends Google_Model
1089  {
1090    protected $internal_gapi_mappings = array(
1091    );
1092    protected $applicationType = 'Google_Service_Fitness_Application';
1093    protected $applicationDataType = '';
1094    public $dataStreamId;
1095    public $dataStreamName;
1096    protected $dataTypeType = 'Google_Service_Fitness_DataType';
1097    protected $dataTypeDataType = '';
1098    protected $deviceType = 'Google_Service_Fitness_Device';
1099    protected $deviceDataType = '';
1100    public $name;
1101    public $type;
1102  
1103  
1104    public function setApplication(Google_Service_Fitness_Application $application)
1105    {
1106      $this->application = $application;
1107    }
1108    public function getApplication()
1109    {
1110      return $this->application;
1111    }
1112    public function setDataStreamId($dataStreamId)
1113    {
1114      $this->dataStreamId = $dataStreamId;
1115    }
1116    public function getDataStreamId()
1117    {
1118      return $this->dataStreamId;
1119    }
1120    public function setDataStreamName($dataStreamName)
1121    {
1122      $this->dataStreamName = $dataStreamName;
1123    }
1124    public function getDataStreamName()
1125    {
1126      return $this->dataStreamName;
1127    }
1128    public function setDataType(Google_Service_Fitness_DataType $dataType)
1129    {
1130      $this->dataType = $dataType;
1131    }
1132    public function getDataType()
1133    {
1134      return $this->dataType;
1135    }
1136    public function setDevice(Google_Service_Fitness_Device $device)
1137    {
1138      $this->device = $device;
1139    }
1140    public function getDevice()
1141    {
1142      return $this->device;
1143    }
1144    public function setName($name)
1145    {
1146      $this->name = $name;
1147    }
1148    public function getName()
1149    {
1150      return $this->name;
1151    }
1152    public function setType($type)
1153    {
1154      $this->type = $type;
1155    }
1156    public function getType()
1157    {
1158      return $this->type;
1159    }
1160  }
1161  
1162  class Google_Service_Fitness_DataType extends Google_Collection
1163  {
1164    protected $collection_key = 'field';
1165    protected $internal_gapi_mappings = array(
1166    );
1167    protected $fieldType = 'Google_Service_Fitness_DataTypeField';
1168    protected $fieldDataType = 'array';
1169    public $name;
1170  
1171  
1172    public function setField($field)
1173    {
1174      $this->field = $field;
1175    }
1176    public function getField()
1177    {
1178      return $this->field;
1179    }
1180    public function setName($name)
1181    {
1182      $this->name = $name;
1183    }
1184    public function getName()
1185    {
1186      return $this->name;
1187    }
1188  }
1189  
1190  class Google_Service_Fitness_DataTypeField extends Google_Model
1191  {
1192    protected $internal_gapi_mappings = array(
1193    );
1194    public $format;
1195    public $name;
1196    public $optional;
1197  
1198  
1199    public function setFormat($format)
1200    {
1201      $this->format = $format;
1202    }
1203    public function getFormat()
1204    {
1205      return $this->format;
1206    }
1207    public function setName($name)
1208    {
1209      $this->name = $name;
1210    }
1211    public function getName()
1212    {
1213      return $this->name;
1214    }
1215    public function setOptional($optional)
1216    {
1217      $this->optional = $optional;
1218    }
1219    public function getOptional()
1220    {
1221      return $this->optional;
1222    }
1223  }
1224  
1225  class Google_Service_Fitness_Dataset extends Google_Collection
1226  {
1227    protected $collection_key = 'point';
1228    protected $internal_gapi_mappings = array(
1229    );
1230    public $dataSourceId;
1231    public $maxEndTimeNs;
1232    public $minStartTimeNs;
1233    public $nextPageToken;
1234    protected $pointType = 'Google_Service_Fitness_DataPoint';
1235    protected $pointDataType = 'array';
1236  
1237  
1238    public function setDataSourceId($dataSourceId)
1239    {
1240      $this->dataSourceId = $dataSourceId;
1241    }
1242    public function getDataSourceId()
1243    {
1244      return $this->dataSourceId;
1245    }
1246    public function setMaxEndTimeNs($maxEndTimeNs)
1247    {
1248      $this->maxEndTimeNs = $maxEndTimeNs;
1249    }
1250    public function getMaxEndTimeNs()
1251    {
1252      return $this->maxEndTimeNs;
1253    }
1254    public function setMinStartTimeNs($minStartTimeNs)
1255    {
1256      $this->minStartTimeNs = $minStartTimeNs;
1257    }
1258    public function getMinStartTimeNs()
1259    {
1260      return $this->minStartTimeNs;
1261    }
1262    public function setNextPageToken($nextPageToken)
1263    {
1264      $this->nextPageToken = $nextPageToken;
1265    }
1266    public function getNextPageToken()
1267    {
1268      return $this->nextPageToken;
1269    }
1270    public function setPoint($point)
1271    {
1272      $this->point = $point;
1273    }
1274    public function getPoint()
1275    {
1276      return $this->point;
1277    }
1278  }
1279  
1280  class Google_Service_Fitness_Device extends Google_Model
1281  {
1282    protected $internal_gapi_mappings = array(
1283    );
1284    public $manufacturer;
1285    public $model;
1286    public $type;
1287    public $uid;
1288    public $version;
1289  
1290  
1291    public function setManufacturer($manufacturer)
1292    {
1293      $this->manufacturer = $manufacturer;
1294    }
1295    public function getManufacturer()
1296    {
1297      return $this->manufacturer;
1298    }
1299    public function setModel($model)
1300    {
1301      $this->model = $model;
1302    }
1303    public function getModel()
1304    {
1305      return $this->model;
1306    }
1307    public function setType($type)
1308    {
1309      $this->type = $type;
1310    }
1311    public function getType()
1312    {
1313      return $this->type;
1314    }
1315    public function setUid($uid)
1316    {
1317      $this->uid = $uid;
1318    }
1319    public function getUid()
1320    {
1321      return $this->uid;
1322    }
1323    public function setVersion($version)
1324    {
1325      $this->version = $version;
1326    }
1327    public function getVersion()
1328    {
1329      return $this->version;
1330    }
1331  }
1332  
1333  class Google_Service_Fitness_ListDataSourcesResponse extends Google_Collection
1334  {
1335    protected $collection_key = 'dataSource';
1336    protected $internal_gapi_mappings = array(
1337    );
1338    protected $dataSourceType = 'Google_Service_Fitness_DataSource';
1339    protected $dataSourceDataType = 'array';
1340  
1341  
1342    public function setDataSource($dataSource)
1343    {
1344      $this->dataSource = $dataSource;
1345    }
1346    public function getDataSource()
1347    {
1348      return $this->dataSource;
1349    }
1350  }
1351  
1352  class Google_Service_Fitness_ListSessionsResponse extends Google_Collection
1353  {
1354    protected $collection_key = 'session';
1355    protected $internal_gapi_mappings = array(
1356    );
1357    protected $deletedSessionType = 'Google_Service_Fitness_Session';
1358    protected $deletedSessionDataType = 'array';
1359    public $nextPageToken;
1360    protected $sessionType = 'Google_Service_Fitness_Session';
1361    protected $sessionDataType = 'array';
1362  
1363  
1364    public function setDeletedSession($deletedSession)
1365    {
1366      $this->deletedSession = $deletedSession;
1367    }
1368    public function getDeletedSession()
1369    {
1370      return $this->deletedSession;
1371    }
1372    public function setNextPageToken($nextPageToken)
1373    {
1374      $this->nextPageToken = $nextPageToken;
1375    }
1376    public function getNextPageToken()
1377    {
1378      return $this->nextPageToken;
1379    }
1380    public function setSession($session)
1381    {
1382      $this->session = $session;
1383    }
1384    public function getSession()
1385    {
1386      return $this->session;
1387    }
1388  }
1389  
1390  class Google_Service_Fitness_MapValue extends Google_Model
1391  {
1392    protected $internal_gapi_mappings = array(
1393    );
1394    public $fpVal;
1395  
1396  
1397    public function setFpVal($fpVal)
1398    {
1399      $this->fpVal = $fpVal;
1400    }
1401    public function getFpVal()
1402    {
1403      return $this->fpVal;
1404    }
1405  }
1406  
1407  class Google_Service_Fitness_Session extends Google_Model
1408  {
1409    protected $internal_gapi_mappings = array(
1410    );
1411    public $activeTimeMillis;
1412    public $activityType;
1413    protected $applicationType = 'Google_Service_Fitness_Application';
1414    protected $applicationDataType = '';
1415    public $description;
1416    public $endTimeMillis;
1417    public $id;
1418    public $modifiedTimeMillis;
1419    public $name;
1420    public $startTimeMillis;
1421  
1422  
1423    public function setActiveTimeMillis($activeTimeMillis)
1424    {
1425      $this->activeTimeMillis = $activeTimeMillis;
1426    }
1427    public function getActiveTimeMillis()
1428    {
1429      return $this->activeTimeMillis;
1430    }
1431    public function setActivityType($activityType)
1432    {
1433      $this->activityType = $activityType;
1434    }
1435    public function getActivityType()
1436    {
1437      return $this->activityType;
1438    }
1439    public function setApplication(Google_Service_Fitness_Application $application)
1440    {
1441      $this->application = $application;
1442    }
1443    public function getApplication()
1444    {
1445      return $this->application;
1446    }
1447    public function setDescription($description)
1448    {
1449      $this->description = $description;
1450    }
1451    public function getDescription()
1452    {
1453      return $this->description;
1454    }
1455    public function setEndTimeMillis($endTimeMillis)
1456    {
1457      $this->endTimeMillis = $endTimeMillis;
1458    }
1459    public function getEndTimeMillis()
1460    {
1461      return $this->endTimeMillis;
1462    }
1463    public function setId($id)
1464    {
1465      $this->id = $id;
1466    }
1467    public function getId()
1468    {
1469      return $this->id;
1470    }
1471    public function setModifiedTimeMillis($modifiedTimeMillis)
1472    {
1473      $this->modifiedTimeMillis = $modifiedTimeMillis;
1474    }
1475    public function getModifiedTimeMillis()
1476    {
1477      return $this->modifiedTimeMillis;
1478    }
1479    public function setName($name)
1480    {
1481      $this->name = $name;
1482    }
1483    public function getName()
1484    {
1485      return $this->name;
1486    }
1487    public function setStartTimeMillis($startTimeMillis)
1488    {
1489      $this->startTimeMillis = $startTimeMillis;
1490    }
1491    public function getStartTimeMillis()
1492    {
1493      return $this->startTimeMillis;
1494    }
1495  }
1496  
1497  class Google_Service_Fitness_Value extends Google_Collection
1498  {
1499    protected $collection_key = 'mapVal';
1500    protected $internal_gapi_mappings = array(
1501    );
1502    public $fpVal;
1503    public $intVal;
1504    protected $mapValType = 'Google_Service_Fitness_ValueMapValEntry';
1505    protected $mapValDataType = 'array';
1506    public $stringVal;
1507  
1508  
1509    public function setFpVal($fpVal)
1510    {
1511      $this->fpVal = $fpVal;
1512    }
1513    public function getFpVal()
1514    {
1515      return $this->fpVal;
1516    }
1517    public function setIntVal($intVal)
1518    {
1519      $this->intVal = $intVal;
1520    }
1521    public function getIntVal()
1522    {
1523      return $this->intVal;
1524    }
1525    public function setMapVal($mapVal)
1526    {
1527      $this->mapVal = $mapVal;
1528    }
1529    public function getMapVal()
1530    {
1531      return $this->mapVal;
1532    }
1533    public function setStringVal($stringVal)
1534    {
1535      $this->stringVal = $stringVal;
1536    }
1537    public function getStringVal()
1538    {
1539      return $this->stringVal;
1540    }
1541  }
1542  
1543  class Google_Service_Fitness_ValueMapValEntry extends Google_Model
1544  {
1545    protected $internal_gapi_mappings = array(
1546    );
1547    public $key;
1548    protected $valueType = 'Google_Service_Fitness_MapValue';
1549    protected $valueDataType = '';
1550  
1551  
1552    public function setKey($key)
1553    {
1554      $this->key = $key;
1555    }
1556    public function getKey()
1557    {
1558      return $this->key;
1559    }
1560    public function setValue(Google_Service_Fitness_MapValue $value)
1561    {
1562      $this->value = $value;
1563    }
1564    public function getValue()
1565    {
1566      return $this->value;
1567    }
1568  }