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 YouTubeAnalytics (v1).
  20   *
  21   * <p>
  22   * Retrieve your YouTube Analytics reports.</p>
  23   *
  24   * <p>
  25   * For more information about this service, see the API
  26   * <a href="http://developers.google.com/youtube/analytics/" target="_blank">Documentation</a>
  27   * </p>
  28   *
  29   * @author Google, Inc.
  30   */
  31  class Google_Service_YouTubeAnalytics extends Google_Service
  32  {
  33    /** Manage your YouTube account. */
  34    const YOUTUBE =
  35        "https://www.googleapis.com/auth/youtube";
  36    /** View your YouTube account. */
  37    const YOUTUBE_READONLY =
  38        "https://www.googleapis.com/auth/youtube.readonly";
  39    /** View and manage your assets and associated content on YouTube. */
  40    const YOUTUBEPARTNER =
  41        "https://www.googleapis.com/auth/youtubepartner";
  42    /** View monetary and non-monetary YouTube Analytics reports for your YouTube content. */
  43    const YT_ANALYTICS_MONETARY_READONLY =
  44        "https://www.googleapis.com/auth/yt-analytics-monetary.readonly";
  45    /** View YouTube Analytics reports for your YouTube content. */
  46    const YT_ANALYTICS_READONLY =
  47        "https://www.googleapis.com/auth/yt-analytics.readonly";
  48  
  49    public $batchReportDefinitions;
  50    public $batchReports;
  51    public $groupItems;
  52    public $groups;
  53    public $reports;
  54    
  55  
  56    /**
  57     * Constructs the internal representation of the YouTubeAnalytics service.
  58     *
  59     * @param Google_Client $client
  60     */
  61    public function __construct(Google_Client $client)
  62    {
  63      parent::__construct($client);
  64      $this->rootUrl = 'https://www.googleapis.com/';
  65      $this->servicePath = 'youtube/analytics/v1/';
  66      $this->version = 'v1';
  67      $this->serviceName = 'youtubeAnalytics';
  68  
  69      $this->batchReportDefinitions = new Google_Service_YouTubeAnalytics_BatchReportDefinitions_Resource(
  70          $this,
  71          $this->serviceName,
  72          'batchReportDefinitions',
  73          array(
  74            'methods' => array(
  75              'list' => array(
  76                'path' => 'batchReportDefinitions',
  77                'httpMethod' => 'GET',
  78                'parameters' => array(
  79                  'onBehalfOfContentOwner' => array(
  80                    'location' => 'query',
  81                    'type' => 'string',
  82                    'required' => true,
  83                  ),
  84                ),
  85              ),
  86            )
  87          )
  88      );
  89      $this->batchReports = new Google_Service_YouTubeAnalytics_BatchReports_Resource(
  90          $this,
  91          $this->serviceName,
  92          'batchReports',
  93          array(
  94            'methods' => array(
  95              'list' => array(
  96                'path' => 'batchReports',
  97                'httpMethod' => 'GET',
  98                'parameters' => array(
  99                  'batchReportDefinitionId' => array(
 100                    'location' => 'query',
 101                    'type' => 'string',
 102                    'required' => true,
 103                  ),
 104                  'onBehalfOfContentOwner' => array(
 105                    'location' => 'query',
 106                    'type' => 'string',
 107                    'required' => true,
 108                  ),
 109                ),
 110              ),
 111            )
 112          )
 113      );
 114      $this->groupItems = new Google_Service_YouTubeAnalytics_GroupItems_Resource(
 115          $this,
 116          $this->serviceName,
 117          'groupItems',
 118          array(
 119            'methods' => array(
 120              'delete' => array(
 121                'path' => 'groupItems',
 122                'httpMethod' => 'DELETE',
 123                'parameters' => array(
 124                  'id' => array(
 125                    'location' => 'query',
 126                    'type' => 'string',
 127                    'required' => true,
 128                  ),
 129                  'onBehalfOfContentOwner' => array(
 130                    'location' => 'query',
 131                    'type' => 'string',
 132                  ),
 133                ),
 134              ),'insert' => array(
 135                'path' => 'groupItems',
 136                'httpMethod' => 'POST',
 137                'parameters' => array(
 138                  'onBehalfOfContentOwner' => array(
 139                    'location' => 'query',
 140                    'type' => 'string',
 141                  ),
 142                ),
 143              ),'list' => array(
 144                'path' => 'groupItems',
 145                'httpMethod' => 'GET',
 146                'parameters' => array(
 147                  'groupId' => array(
 148                    'location' => 'query',
 149                    'type' => 'string',
 150                    'required' => true,
 151                  ),
 152                  'onBehalfOfContentOwner' => array(
 153                    'location' => 'query',
 154                    'type' => 'string',
 155                  ),
 156                ),
 157              ),
 158            )
 159          )
 160      );
 161      $this->groups = new Google_Service_YouTubeAnalytics_Groups_Resource(
 162          $this,
 163          $this->serviceName,
 164          'groups',
 165          array(
 166            'methods' => array(
 167              'delete' => array(
 168                'path' => 'groups',
 169                'httpMethod' => 'DELETE',
 170                'parameters' => array(
 171                  'id' => array(
 172                    'location' => 'query',
 173                    'type' => 'string',
 174                    'required' => true,
 175                  ),
 176                  'onBehalfOfContentOwner' => array(
 177                    'location' => 'query',
 178                    'type' => 'string',
 179                  ),
 180                ),
 181              ),'insert' => array(
 182                'path' => 'groups',
 183                'httpMethod' => 'POST',
 184                'parameters' => array(
 185                  'onBehalfOfContentOwner' => array(
 186                    'location' => 'query',
 187                    'type' => 'string',
 188                  ),
 189                ),
 190              ),'list' => array(
 191                'path' => 'groups',
 192                'httpMethod' => 'GET',
 193                'parameters' => array(
 194                  'onBehalfOfContentOwner' => array(
 195                    'location' => 'query',
 196                    'type' => 'string',
 197                  ),
 198                  'id' => array(
 199                    'location' => 'query',
 200                    'type' => 'string',
 201                  ),
 202                  'mine' => array(
 203                    'location' => 'query',
 204                    'type' => 'boolean',
 205                  ),
 206                ),
 207              ),'update' => array(
 208                'path' => 'groups',
 209                'httpMethod' => 'PUT',
 210                'parameters' => array(
 211                  'onBehalfOfContentOwner' => array(
 212                    'location' => 'query',
 213                    'type' => 'string',
 214                  ),
 215                ),
 216              ),
 217            )
 218          )
 219      );
 220      $this->reports = new Google_Service_YouTubeAnalytics_Reports_Resource(
 221          $this,
 222          $this->serviceName,
 223          'reports',
 224          array(
 225            'methods' => array(
 226              'query' => array(
 227                'path' => 'reports',
 228                'httpMethod' => 'GET',
 229                'parameters' => array(
 230                  'ids' => array(
 231                    'location' => 'query',
 232                    'type' => 'string',
 233                    'required' => true,
 234                  ),
 235                  'start-date' => array(
 236                    'location' => 'query',
 237                    'type' => 'string',
 238                    'required' => true,
 239                  ),
 240                  'end-date' => array(
 241                    'location' => 'query',
 242                    'type' => 'string',
 243                    'required' => true,
 244                  ),
 245                  'metrics' => array(
 246                    'location' => 'query',
 247                    'type' => 'string',
 248                    'required' => true,
 249                  ),
 250                  'max-results' => array(
 251                    'location' => 'query',
 252                    'type' => 'integer',
 253                  ),
 254                  'sort' => array(
 255                    'location' => 'query',
 256                    'type' => 'string',
 257                  ),
 258                  'dimensions' => array(
 259                    'location' => 'query',
 260                    'type' => 'string',
 261                  ),
 262                  'start-index' => array(
 263                    'location' => 'query',
 264                    'type' => 'integer',
 265                  ),
 266                  'currency' => array(
 267                    'location' => 'query',
 268                    'type' => 'string',
 269                  ),
 270                  'filters' => array(
 271                    'location' => 'query',
 272                    'type' => 'string',
 273                  ),
 274                ),
 275              ),
 276            )
 277          )
 278      );
 279    }
 280  }
 281  
 282  
 283  /**
 284   * The "batchReportDefinitions" collection of methods.
 285   * Typical usage is:
 286   *  <code>
 287   *   $youtubeAnalyticsService = new Google_Service_YouTubeAnalytics(...);
 288   *   $batchReportDefinitions = $youtubeAnalyticsService->batchReportDefinitions;
 289   *  </code>
 290   */
 291  class Google_Service_YouTubeAnalytics_BatchReportDefinitions_Resource extends Google_Service_Resource
 292  {
 293  
 294    /**
 295     * Retrieves a list of available batch report definitions.
 296     * (batchReportDefinitions.listBatchReportDefinitions)
 297     *
 298     * @param string $onBehalfOfContentOwner The onBehalfOfContentOwner parameter
 299     * identifies the content owner that the user is acting on behalf of.
 300     * @param array $optParams Optional parameters.
 301     * @return Google_Service_YouTubeAnalytics_BatchReportDefinitionList
 302     */
 303    public function listBatchReportDefinitions($onBehalfOfContentOwner, $optParams = array())
 304    {
 305      $params = array('onBehalfOfContentOwner' => $onBehalfOfContentOwner);
 306      $params = array_merge($params, $optParams);
 307      return $this->call('list', array($params), "Google_Service_YouTubeAnalytics_BatchReportDefinitionList");
 308    }
 309  }
 310  
 311  /**
 312   * The "batchReports" collection of methods.
 313   * Typical usage is:
 314   *  <code>
 315   *   $youtubeAnalyticsService = new Google_Service_YouTubeAnalytics(...);
 316   *   $batchReports = $youtubeAnalyticsService->batchReports;
 317   *  </code>
 318   */
 319  class Google_Service_YouTubeAnalytics_BatchReports_Resource extends Google_Service_Resource
 320  {
 321  
 322    /**
 323     * Retrieves a list of processed batch reports. (batchReports.listBatchReports)
 324     *
 325     * @param string $batchReportDefinitionId The batchReportDefinitionId parameter
 326     * specifies the ID of the batch reportort definition for which you are
 327     * retrieving reports.
 328     * @param string $onBehalfOfContentOwner The onBehalfOfContentOwner parameter
 329     * identifies the content owner that the user is acting on behalf of.
 330     * @param array $optParams Optional parameters.
 331     * @return Google_Service_YouTubeAnalytics_BatchReportList
 332     */
 333    public function listBatchReports($batchReportDefinitionId, $onBehalfOfContentOwner, $optParams = array())
 334    {
 335      $params = array('batchReportDefinitionId' => $batchReportDefinitionId, 'onBehalfOfContentOwner' => $onBehalfOfContentOwner);
 336      $params = array_merge($params, $optParams);
 337      return $this->call('list', array($params), "Google_Service_YouTubeAnalytics_BatchReportList");
 338    }
 339  }
 340  
 341  /**
 342   * The "groupItems" collection of methods.
 343   * Typical usage is:
 344   *  <code>
 345   *   $youtubeAnalyticsService = new Google_Service_YouTubeAnalytics(...);
 346   *   $groupItems = $youtubeAnalyticsService->groupItems;
 347   *  </code>
 348   */
 349  class Google_Service_YouTubeAnalytics_GroupItems_Resource extends Google_Service_Resource
 350  {
 351  
 352    /**
 353     * Removes an item from a group. (groupItems.delete)
 354     *
 355     * @param string $id The id parameter specifies the YouTube group item ID for
 356     * the group that is being deleted.
 357     * @param array $optParams Optional parameters.
 358     *
 359     * @opt_param string onBehalfOfContentOwner Note: This parameter is intended
 360     * exclusively for YouTube content partners.
 361     *
 362     * The onBehalfOfContentOwner parameter indicates that the request's
 363     * authorization credentials identify a YouTube CMS user who is acting on behalf
 364     * of the content owner specified in the parameter value. This parameter is
 365     * intended for YouTube content partners that own and manage many different
 366     * YouTube channels. It allows content owners to authenticate once and get
 367     * access to all their video and channel data, without having to provide
 368     * authentication credentials for each individual channel. The CMS account that
 369     * the user authenticates with must be linked to the specified YouTube content
 370     * owner.
 371     */
 372    public function delete($id, $optParams = array())
 373    {
 374      $params = array('id' => $id);
 375      $params = array_merge($params, $optParams);
 376      return $this->call('delete', array($params));
 377    }
 378  
 379    /**
 380     * Creates a group item. (groupItems.insert)
 381     *
 382     * @param Google_GroupItem $postBody
 383     * @param array $optParams Optional parameters.
 384     *
 385     * @opt_param string onBehalfOfContentOwner Note: This parameter is intended
 386     * exclusively for YouTube content partners.
 387     *
 388     * The onBehalfOfContentOwner parameter indicates that the request's
 389     * authorization credentials identify a YouTube CMS user who is acting on behalf
 390     * of the content owner specified in the parameter value. This parameter is
 391     * intended for YouTube content partners that own and manage many different
 392     * YouTube channels. It allows content owners to authenticate once and get
 393     * access to all their video and channel data, without having to provide
 394     * authentication credentials for each individual channel. The CMS account that
 395     * the user authenticates with must be linked to the specified YouTube content
 396     * owner.
 397     * @return Google_Service_YouTubeAnalytics_GroupItem
 398     */
 399    public function insert(Google_Service_YouTubeAnalytics_GroupItem $postBody, $optParams = array())
 400    {
 401      $params = array('postBody' => $postBody);
 402      $params = array_merge($params, $optParams);
 403      return $this->call('insert', array($params), "Google_Service_YouTubeAnalytics_GroupItem");
 404    }
 405  
 406    /**
 407     * Returns a collection of group items that match the API request parameters.
 408     * (groupItems.listGroupItems)
 409     *
 410     * @param string $groupId The id parameter specifies the unique ID of the group
 411     * for which you want to retrieve group items.
 412     * @param array $optParams Optional parameters.
 413     *
 414     * @opt_param string onBehalfOfContentOwner Note: This parameter is intended
 415     * exclusively for YouTube content partners.
 416     *
 417     * The onBehalfOfContentOwner parameter indicates that the request's
 418     * authorization credentials identify a YouTube CMS user who is acting on behalf
 419     * of the content owner specified in the parameter value. This parameter is
 420     * intended for YouTube content partners that own and manage many different
 421     * YouTube channels. It allows content owners to authenticate once and get
 422     * access to all their video and channel data, without having to provide
 423     * authentication credentials for each individual channel. The CMS account that
 424     * the user authenticates with must be linked to the specified YouTube content
 425     * owner.
 426     * @return Google_Service_YouTubeAnalytics_GroupItemListResponse
 427     */
 428    public function listGroupItems($groupId, $optParams = array())
 429    {
 430      $params = array('groupId' => $groupId);
 431      $params = array_merge($params, $optParams);
 432      return $this->call('list', array($params), "Google_Service_YouTubeAnalytics_GroupItemListResponse");
 433    }
 434  }
 435  
 436  /**
 437   * The "groups" collection of methods.
 438   * Typical usage is:
 439   *  <code>
 440   *   $youtubeAnalyticsService = new Google_Service_YouTubeAnalytics(...);
 441   *   $groups = $youtubeAnalyticsService->groups;
 442   *  </code>
 443   */
 444  class Google_Service_YouTubeAnalytics_Groups_Resource extends Google_Service_Resource
 445  {
 446  
 447    /**
 448     * Deletes a group. (groups.delete)
 449     *
 450     * @param string $id The id parameter specifies the YouTube group ID for the
 451     * group that is being deleted.
 452     * @param array $optParams Optional parameters.
 453     *
 454     * @opt_param string onBehalfOfContentOwner Note: This parameter is intended
 455     * exclusively for YouTube content partners.
 456     *
 457     * The onBehalfOfContentOwner parameter indicates that the request's
 458     * authorization credentials identify a YouTube CMS user who is acting on behalf
 459     * of the content owner specified in the parameter value. This parameter is
 460     * intended for YouTube content partners that own and manage many different
 461     * YouTube channels. It allows content owners to authenticate once and get
 462     * access to all their video and channel data, without having to provide
 463     * authentication credentials for each individual channel. The CMS account that
 464     * the user authenticates with must be linked to the specified YouTube content
 465     * owner.
 466     */
 467    public function delete($id, $optParams = array())
 468    {
 469      $params = array('id' => $id);
 470      $params = array_merge($params, $optParams);
 471      return $this->call('delete', array($params));
 472    }
 473  
 474    /**
 475     * Creates a group. (groups.insert)
 476     *
 477     * @param Google_Group $postBody
 478     * @param array $optParams Optional parameters.
 479     *
 480     * @opt_param string onBehalfOfContentOwner Note: This parameter is intended
 481     * exclusively for YouTube content partners.
 482     *
 483     * The onBehalfOfContentOwner parameter indicates that the request's
 484     * authorization credentials identify a YouTube CMS user who is acting on behalf
 485     * of the content owner specified in the parameter value. This parameter is
 486     * intended for YouTube content partners that own and manage many different
 487     * YouTube channels. It allows content owners to authenticate once and get
 488     * access to all their video and channel data, without having to provide
 489     * authentication credentials for each individual channel. The CMS account that
 490     * the user authenticates with must be linked to the specified YouTube content
 491     * owner.
 492     * @return Google_Service_YouTubeAnalytics_Group
 493     */
 494    public function insert(Google_Service_YouTubeAnalytics_Group $postBody, $optParams = array())
 495    {
 496      $params = array('postBody' => $postBody);
 497      $params = array_merge($params, $optParams);
 498      return $this->call('insert', array($params), "Google_Service_YouTubeAnalytics_Group");
 499    }
 500  
 501    /**
 502     * Returns a collection of groups that match the API request parameters. For
 503     * example, you can retrieve all groups that the authenticated user owns, or you
 504     * can retrieve one or more groups by their unique IDs. (groups.listGroups)
 505     *
 506     * @param array $optParams Optional parameters.
 507     *
 508     * @opt_param string onBehalfOfContentOwner Note: This parameter is intended
 509     * exclusively for YouTube content partners.
 510     *
 511     * The onBehalfOfContentOwner parameter indicates that the request's
 512     * authorization credentials identify a YouTube CMS user who is acting on behalf
 513     * of the content owner specified in the parameter value. This parameter is
 514     * intended for YouTube content partners that own and manage many different
 515     * YouTube channels. It allows content owners to authenticate once and get
 516     * access to all their video and channel data, without having to provide
 517     * authentication credentials for each individual channel. The CMS account that
 518     * the user authenticates with must be linked to the specified YouTube content
 519     * owner.
 520     * @opt_param string id The id parameter specifies a comma-separated list of the
 521     * YouTube group ID(s) for the resource(s) that are being retrieved. In a group
 522     * resource, the id property specifies the group's YouTube group ID.
 523     * @opt_param bool mine Set this parameter's value to true to instruct the API
 524     * to only return groups owned by the authenticated user.
 525     * @return Google_Service_YouTubeAnalytics_GroupListResponse
 526     */
 527    public function listGroups($optParams = array())
 528    {
 529      $params = array();
 530      $params = array_merge($params, $optParams);
 531      return $this->call('list', array($params), "Google_Service_YouTubeAnalytics_GroupListResponse");
 532    }
 533  
 534    /**
 535     * Modifies a group. For example, you could change a group's title.
 536     * (groups.update)
 537     *
 538     * @param Google_Group $postBody
 539     * @param array $optParams Optional parameters.
 540     *
 541     * @opt_param string onBehalfOfContentOwner Note: This parameter is intended
 542     * exclusively for YouTube content partners.
 543     *
 544     * The onBehalfOfContentOwner parameter indicates that the request's
 545     * authorization credentials identify a YouTube CMS user who is acting on behalf
 546     * of the content owner specified in the parameter value. This parameter is
 547     * intended for YouTube content partners that own and manage many different
 548     * YouTube channels. It allows content owners to authenticate once and get
 549     * access to all their video and channel data, without having to provide
 550     * authentication credentials for each individual channel. The CMS account that
 551     * the user authenticates with must be linked to the specified YouTube content
 552     * owner.
 553     * @return Google_Service_YouTubeAnalytics_Group
 554     */
 555    public function update(Google_Service_YouTubeAnalytics_Group $postBody, $optParams = array())
 556    {
 557      $params = array('postBody' => $postBody);
 558      $params = array_merge($params, $optParams);
 559      return $this->call('update', array($params), "Google_Service_YouTubeAnalytics_Group");
 560    }
 561  }
 562  
 563  /**
 564   * The "reports" collection of methods.
 565   * Typical usage is:
 566   *  <code>
 567   *   $youtubeAnalyticsService = new Google_Service_YouTubeAnalytics(...);
 568   *   $reports = $youtubeAnalyticsService->reports;
 569   *  </code>
 570   */
 571  class Google_Service_YouTubeAnalytics_Reports_Resource extends Google_Service_Resource
 572  {
 573  
 574    /**
 575     * Retrieve your YouTube Analytics reports. (reports.query)
 576     *
 577     * @param string $ids Identifies the YouTube channel or content owner for which
 578     * you are retrieving YouTube Analytics data. - To request data for a YouTube
 579     * user, set the ids parameter value to channel==CHANNEL_ID, where CHANNEL_ID
 580     * specifies the unique YouTube channel ID. - To request data for a YouTube CMS
 581     * content owner, set the ids parameter value to contentOwner==OWNER_NAME, where
 582     * OWNER_NAME is the CMS name of the content owner.
 583     * @param string $startDate The start date for fetching YouTube Analytics data.
 584     * The value should be in YYYY-MM-DD format.
 585     * @param string $endDate The end date for fetching YouTube Analytics data. The
 586     * value should be in YYYY-MM-DD format.
 587     * @param string $metrics A comma-separated list of YouTube Analytics metrics,
 588     * such as views or likes,dislikes. See the Available Reports document for a
 589     * list of the reports that you can retrieve and the metrics available in each
 590     * report, and see the Metrics document for definitions of those metrics.
 591     * @param array $optParams Optional parameters.
 592     *
 593     * @opt_param int max-results The maximum number of rows to include in the
 594     * response.
 595     * @opt_param string sort A comma-separated list of dimensions or metrics that
 596     * determine the sort order for YouTube Analytics data. By default the sort
 597     * order is ascending. The '-' prefix causes descending sort order.
 598     * @opt_param string dimensions A comma-separated list of YouTube Analytics
 599     * dimensions, such as views or ageGroup,gender. See the Available Reports
 600     * document for a list of the reports that you can retrieve and the dimensions
 601     * used for those reports. Also see the Dimensions document for definitions of
 602     * those dimensions.
 603     * @opt_param int start-index An index of the first entity to retrieve. Use this
 604     * parameter as a pagination mechanism along with the max-results parameter
 605     * (one-based, inclusive).
 606     * @opt_param string currency The currency to which financial metrics should be
 607     * converted. The default is US Dollar (USD). If the result contains no
 608     * financial metrics, this flag will be ignored. Responds with an error if the
 609     * specified currency is not recognized.
 610     * @opt_param string filters A list of filters that should be applied when
 611     * retrieving YouTube Analytics data. The Available Reports document identifies
 612     * the dimensions that can be used to filter each report, and the Dimensions
 613     * document defines those dimensions. If a request uses multiple filters, join
 614     * them together with a semicolon (;), and the returned result table will
 615     * satisfy both filters. For example, a filters parameter value of
 616     * video==dMH0bHeiRNg;country==IT restricts the result set to include data for
 617     * the given video in Italy.
 618     * @return Google_Service_YouTubeAnalytics_ResultTable
 619     */
 620    public function query($ids, $startDate, $endDate, $metrics, $optParams = array())
 621    {
 622      $params = array('ids' => $ids, 'start-date' => $startDate, 'end-date' => $endDate, 'metrics' => $metrics);
 623      $params = array_merge($params, $optParams);
 624      return $this->call('query', array($params), "Google_Service_YouTubeAnalytics_ResultTable");
 625    }
 626  }
 627  
 628  
 629  
 630  
 631  class Google_Service_YouTubeAnalytics_BatchReport extends Google_Collection
 632  {
 633    protected $collection_key = 'outputs';
 634    protected $internal_gapi_mappings = array(
 635    );
 636    public $id;
 637    public $kind;
 638    protected $outputsType = 'Google_Service_YouTubeAnalytics_BatchReportOutputs';
 639    protected $outputsDataType = 'array';
 640    public $reportId;
 641    protected $timeSpanType = 'Google_Service_YouTubeAnalytics_BatchReportTimeSpan';
 642    protected $timeSpanDataType = '';
 643    public $timeUpdated;
 644  
 645  
 646    public function setId($id)
 647    {
 648      $this->id = $id;
 649    }
 650    public function getId()
 651    {
 652      return $this->id;
 653    }
 654    public function setKind($kind)
 655    {
 656      $this->kind = $kind;
 657    }
 658    public function getKind()
 659    {
 660      return $this->kind;
 661    }
 662    public function setOutputs($outputs)
 663    {
 664      $this->outputs = $outputs;
 665    }
 666    public function getOutputs()
 667    {
 668      return $this->outputs;
 669    }
 670    public function setReportId($reportId)
 671    {
 672      $this->reportId = $reportId;
 673    }
 674    public function getReportId()
 675    {
 676      return $this->reportId;
 677    }
 678    public function setTimeSpan(Google_Service_YouTubeAnalytics_BatchReportTimeSpan $timeSpan)
 679    {
 680      $this->timeSpan = $timeSpan;
 681    }
 682    public function getTimeSpan()
 683    {
 684      return $this->timeSpan;
 685    }
 686    public function setTimeUpdated($timeUpdated)
 687    {
 688      $this->timeUpdated = $timeUpdated;
 689    }
 690    public function getTimeUpdated()
 691    {
 692      return $this->timeUpdated;
 693    }
 694  }
 695  
 696  class Google_Service_YouTubeAnalytics_BatchReportDefinition extends Google_Model
 697  {
 698    protected $internal_gapi_mappings = array(
 699    );
 700    public $id;
 701    public $kind;
 702    public $name;
 703    public $status;
 704    public $type;
 705  
 706  
 707    public function setId($id)
 708    {
 709      $this->id = $id;
 710    }
 711    public function getId()
 712    {
 713      return $this->id;
 714    }
 715    public function setKind($kind)
 716    {
 717      $this->kind = $kind;
 718    }
 719    public function getKind()
 720    {
 721      return $this->kind;
 722    }
 723    public function setName($name)
 724    {
 725      $this->name = $name;
 726    }
 727    public function getName()
 728    {
 729      return $this->name;
 730    }
 731    public function setStatus($status)
 732    {
 733      $this->status = $status;
 734    }
 735    public function getStatus()
 736    {
 737      return $this->status;
 738    }
 739    public function setType($type)
 740    {
 741      $this->type = $type;
 742    }
 743    public function getType()
 744    {
 745      return $this->type;
 746    }
 747  }
 748  
 749  class Google_Service_YouTubeAnalytics_BatchReportDefinitionList extends Google_Collection
 750  {
 751    protected $collection_key = 'items';
 752    protected $internal_gapi_mappings = array(
 753    );
 754    protected $itemsType = 'Google_Service_YouTubeAnalytics_BatchReportDefinition';
 755    protected $itemsDataType = 'array';
 756    public $kind;
 757  
 758  
 759    public function setItems($items)
 760    {
 761      $this->items = $items;
 762    }
 763    public function getItems()
 764    {
 765      return $this->items;
 766    }
 767    public function setKind($kind)
 768    {
 769      $this->kind = $kind;
 770    }
 771    public function getKind()
 772    {
 773      return $this->kind;
 774    }
 775  }
 776  
 777  class Google_Service_YouTubeAnalytics_BatchReportList extends Google_Collection
 778  {
 779    protected $collection_key = 'items';
 780    protected $internal_gapi_mappings = array(
 781    );
 782    protected $itemsType = 'Google_Service_YouTubeAnalytics_BatchReport';
 783    protected $itemsDataType = 'array';
 784    public $kind;
 785  
 786  
 787    public function setItems($items)
 788    {
 789      $this->items = $items;
 790    }
 791    public function getItems()
 792    {
 793      return $this->items;
 794    }
 795    public function setKind($kind)
 796    {
 797      $this->kind = $kind;
 798    }
 799    public function getKind()
 800    {
 801      return $this->kind;
 802    }
 803  }
 804  
 805  class Google_Service_YouTubeAnalytics_BatchReportOutputs extends Google_Model
 806  {
 807    protected $internal_gapi_mappings = array(
 808    );
 809    public $downloadUrl;
 810    public $format;
 811    public $type;
 812  
 813  
 814    public function setDownloadUrl($downloadUrl)
 815    {
 816      $this->downloadUrl = $downloadUrl;
 817    }
 818    public function getDownloadUrl()
 819    {
 820      return $this->downloadUrl;
 821    }
 822    public function setFormat($format)
 823    {
 824      $this->format = $format;
 825    }
 826    public function getFormat()
 827    {
 828      return $this->format;
 829    }
 830    public function setType($type)
 831    {
 832      $this->type = $type;
 833    }
 834    public function getType()
 835    {
 836      return $this->type;
 837    }
 838  }
 839  
 840  class Google_Service_YouTubeAnalytics_BatchReportTimeSpan extends Google_Model
 841  {
 842    protected $internal_gapi_mappings = array(
 843    );
 844    public $endTime;
 845    public $startTime;
 846  
 847  
 848    public function setEndTime($endTime)
 849    {
 850      $this->endTime = $endTime;
 851    }
 852    public function getEndTime()
 853    {
 854      return $this->endTime;
 855    }
 856    public function setStartTime($startTime)
 857    {
 858      $this->startTime = $startTime;
 859    }
 860    public function getStartTime()
 861    {
 862      return $this->startTime;
 863    }
 864  }
 865  
 866  class Google_Service_YouTubeAnalytics_Group extends Google_Model
 867  {
 868    protected $internal_gapi_mappings = array(
 869    );
 870    protected $contentDetailsType = 'Google_Service_YouTubeAnalytics_GroupContentDetails';
 871    protected $contentDetailsDataType = '';
 872    public $etag;
 873    public $id;
 874    public $kind;
 875    protected $snippetType = 'Google_Service_YouTubeAnalytics_GroupSnippet';
 876    protected $snippetDataType = '';
 877  
 878  
 879    public function setContentDetails(Google_Service_YouTubeAnalytics_GroupContentDetails $contentDetails)
 880    {
 881      $this->contentDetails = $contentDetails;
 882    }
 883    public function getContentDetails()
 884    {
 885      return $this->contentDetails;
 886    }
 887    public function setEtag($etag)
 888    {
 889      $this->etag = $etag;
 890    }
 891    public function getEtag()
 892    {
 893      return $this->etag;
 894    }
 895    public function setId($id)
 896    {
 897      $this->id = $id;
 898    }
 899    public function getId()
 900    {
 901      return $this->id;
 902    }
 903    public function setKind($kind)
 904    {
 905      $this->kind = $kind;
 906    }
 907    public function getKind()
 908    {
 909      return $this->kind;
 910    }
 911    public function setSnippet(Google_Service_YouTubeAnalytics_GroupSnippet $snippet)
 912    {
 913      $this->snippet = $snippet;
 914    }
 915    public function getSnippet()
 916    {
 917      return $this->snippet;
 918    }
 919  }
 920  
 921  class Google_Service_YouTubeAnalytics_GroupContentDetails extends Google_Model
 922  {
 923    protected $internal_gapi_mappings = array(
 924    );
 925    public $itemCount;
 926    public $itemType;
 927  
 928  
 929    public function setItemCount($itemCount)
 930    {
 931      $this->itemCount = $itemCount;
 932    }
 933    public function getItemCount()
 934    {
 935      return $this->itemCount;
 936    }
 937    public function setItemType($itemType)
 938    {
 939      $this->itemType = $itemType;
 940    }
 941    public function getItemType()
 942    {
 943      return $this->itemType;
 944    }
 945  }
 946  
 947  class Google_Service_YouTubeAnalytics_GroupItem extends Google_Model
 948  {
 949    protected $internal_gapi_mappings = array(
 950    );
 951    public $etag;
 952    public $groupId;
 953    public $id;
 954    public $kind;
 955    protected $resourceType = 'Google_Service_YouTubeAnalytics_GroupItemResource';
 956    protected $resourceDataType = '';
 957  
 958  
 959    public function setEtag($etag)
 960    {
 961      $this->etag = $etag;
 962    }
 963    public function getEtag()
 964    {
 965      return $this->etag;
 966    }
 967    public function setGroupId($groupId)
 968    {
 969      $this->groupId = $groupId;
 970    }
 971    public function getGroupId()
 972    {
 973      return $this->groupId;
 974    }
 975    public function setId($id)
 976    {
 977      $this->id = $id;
 978    }
 979    public function getId()
 980    {
 981      return $this->id;
 982    }
 983    public function setKind($kind)
 984    {
 985      $this->kind = $kind;
 986    }
 987    public function getKind()
 988    {
 989      return $this->kind;
 990    }
 991    public function setResource(Google_Service_YouTubeAnalytics_GroupItemResource $resource)
 992    {
 993      $this->resource = $resource;
 994    }
 995    public function getResource()
 996    {
 997      return $this->resource;
 998    }
 999  }
1000  
1001  class Google_Service_YouTubeAnalytics_GroupItemListResponse extends Google_Collection
1002  {
1003    protected $collection_key = 'items';
1004    protected $internal_gapi_mappings = array(
1005    );
1006    public $etag;
1007    protected $itemsType = 'Google_Service_YouTubeAnalytics_GroupItem';
1008    protected $itemsDataType = 'array';
1009    public $kind;
1010  
1011  
1012    public function setEtag($etag)
1013    {
1014      $this->etag = $etag;
1015    }
1016    public function getEtag()
1017    {
1018      return $this->etag;
1019    }
1020    public function setItems($items)
1021    {
1022      $this->items = $items;
1023    }
1024    public function getItems()
1025    {
1026      return $this->items;
1027    }
1028    public function setKind($kind)
1029    {
1030      $this->kind = $kind;
1031    }
1032    public function getKind()
1033    {
1034      return $this->kind;
1035    }
1036  }
1037  
1038  class Google_Service_YouTubeAnalytics_GroupItemResource extends Google_Model
1039  {
1040    protected $internal_gapi_mappings = array(
1041    );
1042    public $id;
1043    public $kind;
1044  
1045  
1046    public function setId($id)
1047    {
1048      $this->id = $id;
1049    }
1050    public function getId()
1051    {
1052      return $this->id;
1053    }
1054    public function setKind($kind)
1055    {
1056      $this->kind = $kind;
1057    }
1058    public function getKind()
1059    {
1060      return $this->kind;
1061    }
1062  }
1063  
1064  class Google_Service_YouTubeAnalytics_GroupListResponse extends Google_Collection
1065  {
1066    protected $collection_key = 'items';
1067    protected $internal_gapi_mappings = array(
1068    );
1069    public $etag;
1070    protected $itemsType = 'Google_Service_YouTubeAnalytics_Group';
1071    protected $itemsDataType = 'array';
1072    public $kind;
1073  
1074  
1075    public function setEtag($etag)
1076    {
1077      $this->etag = $etag;
1078    }
1079    public function getEtag()
1080    {
1081      return $this->etag;
1082    }
1083    public function setItems($items)
1084    {
1085      $this->items = $items;
1086    }
1087    public function getItems()
1088    {
1089      return $this->items;
1090    }
1091    public function setKind($kind)
1092    {
1093      $this->kind = $kind;
1094    }
1095    public function getKind()
1096    {
1097      return $this->kind;
1098    }
1099  }
1100  
1101  class Google_Service_YouTubeAnalytics_GroupSnippet extends Google_Model
1102  {
1103    protected $internal_gapi_mappings = array(
1104    );
1105    public $publishedAt;
1106    public $title;
1107  
1108  
1109    public function setPublishedAt($publishedAt)
1110    {
1111      $this->publishedAt = $publishedAt;
1112    }
1113    public function getPublishedAt()
1114    {
1115      return $this->publishedAt;
1116    }
1117    public function setTitle($title)
1118    {
1119      $this->title = $title;
1120    }
1121    public function getTitle()
1122    {
1123      return $this->title;
1124    }
1125  }
1126  
1127  class Google_Service_YouTubeAnalytics_ResultTable extends Google_Collection
1128  {
1129    protected $collection_key = 'rows';
1130    protected $internal_gapi_mappings = array(
1131    );
1132    protected $columnHeadersType = 'Google_Service_YouTubeAnalytics_ResultTableColumnHeaders';
1133    protected $columnHeadersDataType = 'array';
1134    public $kind;
1135    public $rows;
1136  
1137  
1138    public function setColumnHeaders($columnHeaders)
1139    {
1140      $this->columnHeaders = $columnHeaders;
1141    }
1142    public function getColumnHeaders()
1143    {
1144      return $this->columnHeaders;
1145    }
1146    public function setKind($kind)
1147    {
1148      $this->kind = $kind;
1149    }
1150    public function getKind()
1151    {
1152      return $this->kind;
1153    }
1154    public function setRows($rows)
1155    {
1156      $this->rows = $rows;
1157    }
1158    public function getRows()
1159    {
1160      return $this->rows;
1161    }
1162  }
1163  
1164  class Google_Service_YouTubeAnalytics_ResultTableColumnHeaders extends Google_Model
1165  {
1166    protected $internal_gapi_mappings = array(
1167    );
1168    public $columnType;
1169    public $dataType;
1170    public $name;
1171  
1172  
1173    public function setColumnType($columnType)
1174    {
1175      $this->columnType = $columnType;
1176    }
1177    public function getColumnType()
1178    {
1179      return $this->columnType;
1180    }
1181    public function setDataType($dataType)
1182    {
1183      $this->dataType = $dataType;
1184    }
1185    public function getDataType()
1186    {
1187      return $this->dataType;
1188    }
1189    public function setName($name)
1190    {
1191      $this->name = $name;
1192    }
1193    public function getName()
1194    {
1195      return $this->name;
1196    }
1197  }