[Summary view]

Differences Between: [Versions 311 and 402] [Versions 311 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 Classroom (v1).
  20   *
  21   * <p>
  22   * Google Classroom API</p>
  23   *
  24   * <p>
  25   * For more information about this service, see the API
  26   * <a href="https://developers.google.com/classroom/" target="_blank">Documentation</a>
  27   * </p>
  28   *
  29   * @author Google, Inc.
  30   */
  31  class Google_Service_Classroom extends Google_Service
  32  {
  33    /** Manage your Google Classroom classes. */
  34    const CLASSROOM_COURSES =
  35        "https://www.googleapis.com/auth/classroom.courses";
  36    /** View your Google Classroom classes. */
  37    const CLASSROOM_COURSES_READONLY =
  38        "https://www.googleapis.com/auth/classroom.courses.readonly";
  39    /** View the email addresses of people in your classes. */
  40    const CLASSROOM_PROFILE_EMAILS =
  41        "https://www.googleapis.com/auth/classroom.profile.emails";
  42    /** View the profile photos of people in your classes. */
  43    const CLASSROOM_PROFILE_PHOTOS =
  44        "https://www.googleapis.com/auth/classroom.profile.photos";
  45    /** Manage your Google Classroom class rosters. */
  46    const CLASSROOM_ROSTERS =
  47        "https://www.googleapis.com/auth/classroom.rosters";
  48    /** View your Google Classroom class rosters. */
  49    const CLASSROOM_ROSTERS_READONLY =
  50        "https://www.googleapis.com/auth/classroom.rosters.readonly";
  51  
  52    public $courses;
  53    public $courses_aliases;
  54    public $courses_students;
  55    public $courses_teachers;
  56    public $invitations;
  57    public $userProfiles;
  58    
  59  
  60    /**
  61     * Constructs the internal representation of the Classroom service.
  62     *
  63     * @param Google_Client $client
  64     */
  65    public function __construct(Google_Client $client)
  66    {
  67      parent::__construct($client);
  68      $this->rootUrl = 'https://classroom.googleapis.com/';
  69      $this->servicePath = '';
  70      $this->version = 'v1';
  71      $this->serviceName = 'classroom';
  72  
  73      $this->courses = new Google_Service_Classroom_Courses_Resource(
  74          $this,
  75          $this->serviceName,
  76          'courses',
  77          array(
  78            'methods' => array(
  79              'create' => array(
  80                'path' => 'v1/courses',
  81                'httpMethod' => 'POST',
  82                'parameters' => array(),
  83              ),'delete' => array(
  84                'path' => 'v1/courses/{id}',
  85                'httpMethod' => 'DELETE',
  86                'parameters' => array(
  87                  'id' => array(
  88                    'location' => 'path',
  89                    'type' => 'string',
  90                    'required' => true,
  91                  ),
  92                ),
  93              ),'get' => array(
  94                'path' => 'v1/courses/{id}',
  95                'httpMethod' => 'GET',
  96                'parameters' => array(
  97                  'id' => array(
  98                    'location' => 'path',
  99                    'type' => 'string',
 100                    'required' => true,
 101                  ),
 102                ),
 103              ),'list' => array(
 104                'path' => 'v1/courses',
 105                'httpMethod' => 'GET',
 106                'parameters' => array(
 107                  'teacherId' => array(
 108                    'location' => 'query',
 109                    'type' => 'string',
 110                  ),
 111                  'pageToken' => array(
 112                    'location' => 'query',
 113                    'type' => 'string',
 114                  ),
 115                  'studentId' => array(
 116                    'location' => 'query',
 117                    'type' => 'string',
 118                  ),
 119                  'pageSize' => array(
 120                    'location' => 'query',
 121                    'type' => 'integer',
 122                  ),
 123                ),
 124              ),'patch' => array(
 125                'path' => 'v1/courses/{id}',
 126                'httpMethod' => 'PATCH',
 127                'parameters' => array(
 128                  'id' => array(
 129                    'location' => 'path',
 130                    'type' => 'string',
 131                    'required' => true,
 132                  ),
 133                  'updateMask' => array(
 134                    'location' => 'query',
 135                    'type' => 'string',
 136                  ),
 137                ),
 138              ),'update' => array(
 139                'path' => 'v1/courses/{id}',
 140                'httpMethod' => 'PUT',
 141                'parameters' => array(
 142                  'id' => array(
 143                    'location' => 'path',
 144                    'type' => 'string',
 145                    'required' => true,
 146                  ),
 147                ),
 148              ),
 149            )
 150          )
 151      );
 152      $this->courses_aliases = new Google_Service_Classroom_CoursesAliases_Resource(
 153          $this,
 154          $this->serviceName,
 155          'aliases',
 156          array(
 157            'methods' => array(
 158              'create' => array(
 159                'path' => 'v1/courses/{courseId}/aliases',
 160                'httpMethod' => 'POST',
 161                'parameters' => array(
 162                  'courseId' => array(
 163                    'location' => 'path',
 164                    'type' => 'string',
 165                    'required' => true,
 166                  ),
 167                ),
 168              ),'delete' => array(
 169                'path' => 'v1/courses/{courseId}/aliases/{alias}',
 170                'httpMethod' => 'DELETE',
 171                'parameters' => array(
 172                  'courseId' => array(
 173                    'location' => 'path',
 174                    'type' => 'string',
 175                    'required' => true,
 176                  ),
 177                  'alias' => array(
 178                    'location' => 'path',
 179                    'type' => 'string',
 180                    'required' => true,
 181                  ),
 182                ),
 183              ),'list' => array(
 184                'path' => 'v1/courses/{courseId}/aliases',
 185                'httpMethod' => 'GET',
 186                'parameters' => array(
 187                  'courseId' => array(
 188                    'location' => 'path',
 189                    'type' => 'string',
 190                    'required' => true,
 191                  ),
 192                  'pageToken' => array(
 193                    'location' => 'query',
 194                    'type' => 'string',
 195                  ),
 196                  'pageSize' => array(
 197                    'location' => 'query',
 198                    'type' => 'integer',
 199                  ),
 200                ),
 201              ),
 202            )
 203          )
 204      );
 205      $this->courses_students = new Google_Service_Classroom_CoursesStudents_Resource(
 206          $this,
 207          $this->serviceName,
 208          'students',
 209          array(
 210            'methods' => array(
 211              'create' => array(
 212                'path' => 'v1/courses/{courseId}/students',
 213                'httpMethod' => 'POST',
 214                'parameters' => array(
 215                  'courseId' => array(
 216                    'location' => 'path',
 217                    'type' => 'string',
 218                    'required' => true,
 219                  ),
 220                  'enrollmentCode' => array(
 221                    'location' => 'query',
 222                    'type' => 'string',
 223                  ),
 224                ),
 225              ),'delete' => array(
 226                'path' => 'v1/courses/{courseId}/students/{userId}',
 227                'httpMethod' => 'DELETE',
 228                'parameters' => array(
 229                  'courseId' => array(
 230                    'location' => 'path',
 231                    'type' => 'string',
 232                    'required' => true,
 233                  ),
 234                  'userId' => array(
 235                    'location' => 'path',
 236                    'type' => 'string',
 237                    'required' => true,
 238                  ),
 239                ),
 240              ),'get' => array(
 241                'path' => 'v1/courses/{courseId}/students/{userId}',
 242                'httpMethod' => 'GET',
 243                'parameters' => array(
 244                  'courseId' => array(
 245                    'location' => 'path',
 246                    'type' => 'string',
 247                    'required' => true,
 248                  ),
 249                  'userId' => array(
 250                    'location' => 'path',
 251                    'type' => 'string',
 252                    'required' => true,
 253                  ),
 254                ),
 255              ),'list' => array(
 256                'path' => 'v1/courses/{courseId}/students',
 257                'httpMethod' => 'GET',
 258                'parameters' => array(
 259                  'courseId' => array(
 260                    'location' => 'path',
 261                    'type' => 'string',
 262                    'required' => true,
 263                  ),
 264                  'pageToken' => array(
 265                    'location' => 'query',
 266                    'type' => 'string',
 267                  ),
 268                  'pageSize' => array(
 269                    'location' => 'query',
 270                    'type' => 'integer',
 271                  ),
 272                ),
 273              ),
 274            )
 275          )
 276      );
 277      $this->courses_teachers = new Google_Service_Classroom_CoursesTeachers_Resource(
 278          $this,
 279          $this->serviceName,
 280          'teachers',
 281          array(
 282            'methods' => array(
 283              'create' => array(
 284                'path' => 'v1/courses/{courseId}/teachers',
 285                'httpMethod' => 'POST',
 286                'parameters' => array(
 287                  'courseId' => array(
 288                    'location' => 'path',
 289                    'type' => 'string',
 290                    'required' => true,
 291                  ),
 292                ),
 293              ),'delete' => array(
 294                'path' => 'v1/courses/{courseId}/teachers/{userId}',
 295                'httpMethod' => 'DELETE',
 296                'parameters' => array(
 297                  'courseId' => array(
 298                    'location' => 'path',
 299                    'type' => 'string',
 300                    'required' => true,
 301                  ),
 302                  'userId' => array(
 303                    'location' => 'path',
 304                    'type' => 'string',
 305                    'required' => true,
 306                  ),
 307                ),
 308              ),'get' => array(
 309                'path' => 'v1/courses/{courseId}/teachers/{userId}',
 310                'httpMethod' => 'GET',
 311                'parameters' => array(
 312                  'courseId' => array(
 313                    'location' => 'path',
 314                    'type' => 'string',
 315                    'required' => true,
 316                  ),
 317                  'userId' => array(
 318                    'location' => 'path',
 319                    'type' => 'string',
 320                    'required' => true,
 321                  ),
 322                ),
 323              ),'list' => array(
 324                'path' => 'v1/courses/{courseId}/teachers',
 325                'httpMethod' => 'GET',
 326                'parameters' => array(
 327                  'courseId' => array(
 328                    'location' => 'path',
 329                    'type' => 'string',
 330                    'required' => true,
 331                  ),
 332                  'pageToken' => array(
 333                    'location' => 'query',
 334                    'type' => 'string',
 335                  ),
 336                  'pageSize' => array(
 337                    'location' => 'query',
 338                    'type' => 'integer',
 339                  ),
 340                ),
 341              ),
 342            )
 343          )
 344      );
 345      $this->invitations = new Google_Service_Classroom_Invitations_Resource(
 346          $this,
 347          $this->serviceName,
 348          'invitations',
 349          array(
 350            'methods' => array(
 351              'accept' => array(
 352                'path' => 'v1/invitations/{id}:accept',
 353                'httpMethod' => 'POST',
 354                'parameters' => array(
 355                  'id' => array(
 356                    'location' => 'path',
 357                    'type' => 'string',
 358                    'required' => true,
 359                  ),
 360                ),
 361              ),'create' => array(
 362                'path' => 'v1/invitations',
 363                'httpMethod' => 'POST',
 364                'parameters' => array(),
 365              ),'delete' => array(
 366                'path' => 'v1/invitations/{id}',
 367                'httpMethod' => 'DELETE',
 368                'parameters' => array(
 369                  'id' => array(
 370                    'location' => 'path',
 371                    'type' => 'string',
 372                    'required' => true,
 373                  ),
 374                ),
 375              ),'get' => array(
 376                'path' => 'v1/invitations/{id}',
 377                'httpMethod' => 'GET',
 378                'parameters' => array(
 379                  'id' => array(
 380                    'location' => 'path',
 381                    'type' => 'string',
 382                    'required' => true,
 383                  ),
 384                ),
 385              ),'list' => array(
 386                'path' => 'v1/invitations',
 387                'httpMethod' => 'GET',
 388                'parameters' => array(
 389                  'courseId' => array(
 390                    'location' => 'query',
 391                    'type' => 'string',
 392                  ),
 393                  'pageToken' => array(
 394                    'location' => 'query',
 395                    'type' => 'string',
 396                  ),
 397                  'userId' => array(
 398                    'location' => 'query',
 399                    'type' => 'string',
 400                  ),
 401                  'pageSize' => array(
 402                    'location' => 'query',
 403                    'type' => 'integer',
 404                  ),
 405                ),
 406              ),
 407            )
 408          )
 409      );
 410      $this->userProfiles = new Google_Service_Classroom_UserProfiles_Resource(
 411          $this,
 412          $this->serviceName,
 413          'userProfiles',
 414          array(
 415            'methods' => array(
 416              'get' => array(
 417                'path' => 'v1/userProfiles/{userId}',
 418                'httpMethod' => 'GET',
 419                'parameters' => array(
 420                  'userId' => array(
 421                    'location' => 'path',
 422                    'type' => 'string',
 423                    'required' => true,
 424                  ),
 425                ),
 426              ),
 427            )
 428          )
 429      );
 430    }
 431  }
 432  
 433  
 434  /**
 435   * The "courses" collection of methods.
 436   * Typical usage is:
 437   *  <code>
 438   *   $classroomService = new Google_Service_Classroom(...);
 439   *   $courses = $classroomService->courses;
 440   *  </code>
 441   */
 442  class Google_Service_Classroom_Courses_Resource extends Google_Service_Resource
 443  {
 444  
 445    /**
 446     * Creates a course. The user specified in `ownerId` is the owner of the created
 447     * course and added as a teacher. This method returns the following error codes:
 448     * * `PERMISSION_DENIED` if the requesting user is not permitted to create
 449     * courses or for access errors. * `NOT_FOUND` if the primary teacher is not a
 450     * valid user. * `FAILED_PRECONDITION` if the course owner's account is disabled
 451     * or for the following request errors: * UserGroupsMembershipLimitReached *
 452     * `ALREADY_EXISTS` if an alias was specified in the `id` and already exists.
 453     * (courses.create)
 454     *
 455     * @param Google_Course $postBody
 456     * @param array $optParams Optional parameters.
 457     * @return Google_Service_Classroom_Course
 458     */
 459    public function create(Google_Service_Classroom_Course $postBody, $optParams = array())
 460    {
 461      $params = array('postBody' => $postBody);
 462      $params = array_merge($params, $optParams);
 463      return $this->call('create', array($params), "Google_Service_Classroom_Course");
 464    }
 465  
 466    /**
 467     * Deletes a course. This method returns the following error codes: *
 468     * `PERMISSION_DENIED` if the requesting user is not permitted to delete the
 469     * requested course or for access errors. * `NOT_FOUND` if no course exists with
 470     * the requested ID. (courses.delete)
 471     *
 472     * @param string $id Identifier of the course to delete. This identifier can be
 473     * either the Classroom-assigned identifier or an alias.
 474     * @param array $optParams Optional parameters.
 475     * @return Google_Service_Classroom_Empty
 476     */
 477    public function delete($id, $optParams = array())
 478    {
 479      $params = array('id' => $id);
 480      $params = array_merge($params, $optParams);
 481      return $this->call('delete', array($params), "Google_Service_Classroom_Empty");
 482    }
 483  
 484    /**
 485     * Returns a course. This method returns the following error codes: *
 486     * `PERMISSION_DENIED` if the requesting user is not permitted to access the
 487     * requested course or for access errors. * `NOT_FOUND` if no course exists with
 488     * the requested ID. (courses.get)
 489     *
 490     * @param string $id Identifier of the course to return. This identifier can be
 491     * either the Classroom-assigned identifier or an alias.
 492     * @param array $optParams Optional parameters.
 493     * @return Google_Service_Classroom_Course
 494     */
 495    public function get($id, $optParams = array())
 496    {
 497      $params = array('id' => $id);
 498      $params = array_merge($params, $optParams);
 499      return $this->call('get', array($params), "Google_Service_Classroom_Course");
 500    }
 501  
 502    /**
 503     * Returns a list of courses that the requesting user is permitted to view,
 504     * restricted to those that match the request. This method returns the following
 505     * error codes: * `PERMISSION_DENIED` for access errors. * `INVALID_ARGUMENT` if
 506     * the query argument is malformed. * `NOT_FOUND` if any users specified in the
 507     * query arguments do not exist. (courses.listCourses)
 508     *
 509     * @param array $optParams Optional parameters.
 510     *
 511     * @opt_param string teacherId Restricts returned courses to those having a
 512     * teacher with the specified identifier. The identifier can be one of the
 513     * following: * the numeric identifier for the user * the email address of the
 514     * user * the string literal `"me"`, indicating the requesting user
 515     * @opt_param string pageToken nextPageToken value returned from a previous list
 516     * call, indicating that the subsequent page of results should be returned. The
 517     * list request must be otherwise identical to the one that resulted in this
 518     * token.
 519     * @opt_param string studentId Restricts returned courses to those having a
 520     * student with the specified identifier. The identifier can be one of the
 521     * following: * the numeric identifier for the user * the email address of the
 522     * user * the string literal `"me"`, indicating the requesting user
 523     * @opt_param int pageSize Maximum number of items to return. Zero or
 524     * unspecified indicates that the server may assign a maximum. The server may
 525     * return fewer than the specified number of results.
 526     * @return Google_Service_Classroom_ListCoursesResponse
 527     */
 528    public function listCourses($optParams = array())
 529    {
 530      $params = array();
 531      $params = array_merge($params, $optParams);
 532      return $this->call('list', array($params), "Google_Service_Classroom_ListCoursesResponse");
 533    }
 534  
 535    /**
 536     * Updates one or more fields in a course. This method returns the following
 537     * error codes: * `PERMISSION_DENIED` if the requesting user is not permitted to
 538     * modify the requested course or for access errors. * `NOT_FOUND` if no course
 539     * exists with the requested ID. * `INVALID_ARGUMENT` if invalid fields are
 540     * specified in the update mask or if no update mask is supplied. *
 541     * `FAILED_PRECONDITION` for the following request errors: * CourseNotModifiable
 542     * (courses.patch)
 543     *
 544     * @param string $id Identifier of the course to update. This identifier can be
 545     * either the Classroom-assigned identifier or an alias.
 546     * @param Google_Course $postBody
 547     * @param array $optParams Optional parameters.
 548     *
 549     * @opt_param string updateMask Mask that identifies which fields on the course
 550     * to update. This field is required to do an update. The update will fail if
 551     * invalid fields are specified. The following fields are valid: * `name` *
 552     * `section` * `descriptionHeading` * `description` * `room` * `courseState`
 553     * When set in a query parameter, this field should be specified as
 554     * `updateMask=,,...`
 555     * @return Google_Service_Classroom_Course
 556     */
 557    public function patch($id, Google_Service_Classroom_Course $postBody, $optParams = array())
 558    {
 559      $params = array('id' => $id, 'postBody' => $postBody);
 560      $params = array_merge($params, $optParams);
 561      return $this->call('patch', array($params), "Google_Service_Classroom_Course");
 562    }
 563  
 564    /**
 565     * Updates a course. This method returns the following error codes: *
 566     * `PERMISSION_DENIED` if the requesting user is not permitted to modify the
 567     * requested course or for access errors. * `NOT_FOUND` if no course exists with
 568     * the requested ID. * `FAILED_PRECONDITION` for the following request errors: *
 569     * CourseNotModifiable (courses.update)
 570     *
 571     * @param string $id Identifier of the course to update. This identifier can be
 572     * either the Classroom-assigned identifier or an alias.
 573     * @param Google_Course $postBody
 574     * @param array $optParams Optional parameters.
 575     * @return Google_Service_Classroom_Course
 576     */
 577    public function update($id, Google_Service_Classroom_Course $postBody, $optParams = array())
 578    {
 579      $params = array('id' => $id, 'postBody' => $postBody);
 580      $params = array_merge($params, $optParams);
 581      return $this->call('update', array($params), "Google_Service_Classroom_Course");
 582    }
 583  }
 584  
 585  /**
 586   * The "aliases" collection of methods.
 587   * Typical usage is:
 588   *  <code>
 589   *   $classroomService = new Google_Service_Classroom(...);
 590   *   $aliases = $classroomService->aliases;
 591   *  </code>
 592   */
 593  class Google_Service_Classroom_CoursesAliases_Resource extends Google_Service_Resource
 594  {
 595  
 596    /**
 597     * Creates an alias for a course. This method returns the following error codes:
 598     * * `PERMISSION_DENIED` if the requesting user is not permitted to create the
 599     * alias or for access errors. * `NOT_FOUND` if the course does not exist. *
 600     * `ALREADY_EXISTS` if the alias already exists. (aliases.create)
 601     *
 602     * @param string $courseId Identifier of the course to alias. This identifier
 603     * can be either the Classroom-assigned identifier or an alias.
 604     * @param Google_CourseAlias $postBody
 605     * @param array $optParams Optional parameters.
 606     * @return Google_Service_Classroom_CourseAlias
 607     */
 608    public function create($courseId, Google_Service_Classroom_CourseAlias $postBody, $optParams = array())
 609    {
 610      $params = array('courseId' => $courseId, 'postBody' => $postBody);
 611      $params = array_merge($params, $optParams);
 612      return $this->call('create', array($params), "Google_Service_Classroom_CourseAlias");
 613    }
 614  
 615    /**
 616     * Deletes an alias of a course. This method returns the following error codes:
 617     * * `PERMISSION_DENIED` if the requesting user is not permitted to remove the
 618     * alias or for access errors. * `NOT_FOUND` if the alias does not exist.
 619     * (aliases.delete)
 620     *
 621     * @param string $courseId Identifier of the course whose alias should be
 622     * deleted. This identifier can be either the Classroom-assigned identifier or
 623     * an alias.
 624     * @param string $alias Alias to delete. This may not be the Classroom-assigned
 625     * identifier.
 626     * @param array $optParams Optional parameters.
 627     * @return Google_Service_Classroom_Empty
 628     */
 629    public function delete($courseId, $alias, $optParams = array())
 630    {
 631      $params = array('courseId' => $courseId, 'alias' => $alias);
 632      $params = array_merge($params, $optParams);
 633      return $this->call('delete', array($params), "Google_Service_Classroom_Empty");
 634    }
 635  
 636    /**
 637     * Returns a list of aliases for a course. This method returns the following
 638     * error codes: * `PERMISSION_DENIED` if the requesting user is not permitted to
 639     * access the course or for access errors. * `NOT_FOUND` if the course does not
 640     * exist. (aliases.listCoursesAliases)
 641     *
 642     * @param string $courseId The identifier of the course. This identifier can be
 643     * either the Classroom-assigned identifier or an alias.
 644     * @param array $optParams Optional parameters.
 645     *
 646     * @opt_param string pageToken nextPageToken value returned from a previous list
 647     * call, indicating that the subsequent page of results should be returned. The
 648     * list request must be otherwise identical to the one that resulted in this
 649     * token.
 650     * @opt_param int pageSize Maximum number of items to return. Zero or
 651     * unspecified indicates that the server may assign a maximum. The server may
 652     * return fewer than the specified number of results.
 653     * @return Google_Service_Classroom_ListCourseAliasesResponse
 654     */
 655    public function listCoursesAliases($courseId, $optParams = array())
 656    {
 657      $params = array('courseId' => $courseId);
 658      $params = array_merge($params, $optParams);
 659      return $this->call('list', array($params), "Google_Service_Classroom_ListCourseAliasesResponse");
 660    }
 661  }
 662  /**
 663   * The "students" collection of methods.
 664   * Typical usage is:
 665   *  <code>
 666   *   $classroomService = new Google_Service_Classroom(...);
 667   *   $students = $classroomService->students;
 668   *  </code>
 669   */
 670  class Google_Service_Classroom_CoursesStudents_Resource extends Google_Service_Resource
 671  {
 672  
 673    /**
 674     * Adds a user as a student of a course. This method returns the following error
 675     * codes: * `PERMISSION_DENIED` if the requesting user is not permitted to
 676     * create students in this course or for access errors. * `NOT_FOUND` if the
 677     * requested course ID does not exist. * `FAILED_PRECONDITION` if the requested
 678     * user's account is disabled, for the following request errors: *
 679     * CourseMemberLimitReached * CourseNotModifiable *
 680     * UserGroupsMembershipLimitReached * `ALREADY_EXISTS` if the user is already a
 681     * student or teacher in the course. (students.create)
 682     *
 683     * @param string $courseId Identifier of the course to create the student in.
 684     * This identifier can be either the Classroom-assigned identifier or an alias.
 685     * @param Google_Student $postBody
 686     * @param array $optParams Optional parameters.
 687     *
 688     * @opt_param string enrollmentCode Enrollment code of the course to create the
 689     * student in. This code is required if userId corresponds to the requesting
 690     * user; it may be omitted if the requesting user has administrative permissions
 691     * to create students for any user.
 692     * @return Google_Service_Classroom_Student
 693     */
 694    public function create($courseId, Google_Service_Classroom_Student $postBody, $optParams = array())
 695    {
 696      $params = array('courseId' => $courseId, 'postBody' => $postBody);
 697      $params = array_merge($params, $optParams);
 698      return $this->call('create', array($params), "Google_Service_Classroom_Student");
 699    }
 700  
 701    /**
 702     * Deletes a student of a course. This method returns the following error codes:
 703     * * `PERMISSION_DENIED` if the requesting user is not permitted to delete
 704     * students of this course or for access errors. * `NOT_FOUND` if no student of
 705     * this course has the requested ID or if the course does not exist.
 706     * (students.delete)
 707     *
 708     * @param string $courseId Identifier of the course. This identifier can be
 709     * either the Classroom-assigned identifier or an alias.
 710     * @param string $userId Identifier of the student to delete. The identifier can
 711     * be one of the following: * the numeric identifier for the user * the email
 712     * address of the user * the string literal `"me"`, indicating the requesting
 713     * user
 714     * @param array $optParams Optional parameters.
 715     * @return Google_Service_Classroom_Empty
 716     */
 717    public function delete($courseId, $userId, $optParams = array())
 718    {
 719      $params = array('courseId' => $courseId, 'userId' => $userId);
 720      $params = array_merge($params, $optParams);
 721      return $this->call('delete', array($params), "Google_Service_Classroom_Empty");
 722    }
 723  
 724    /**
 725     * Returns a student of a course. This method returns the following error codes:
 726     * * `PERMISSION_DENIED` if the requesting user is not permitted to view
 727     * students of this course or for access errors. * `NOT_FOUND` if no student of
 728     * this course has the requested ID or if the course does not exist.
 729     * (students.get)
 730     *
 731     * @param string $courseId Identifier of the course. This identifier can be
 732     * either the Classroom-assigned identifier or an alias.
 733     * @param string $userId Identifier of the student to return. The identifier can
 734     * be one of the following: * the numeric identifier for the user * the email
 735     * address of the user * the string literal `"me"`, indicating the requesting
 736     * user
 737     * @param array $optParams Optional parameters.
 738     * @return Google_Service_Classroom_Student
 739     */
 740    public function get($courseId, $userId, $optParams = array())
 741    {
 742      $params = array('courseId' => $courseId, 'userId' => $userId);
 743      $params = array_merge($params, $optParams);
 744      return $this->call('get', array($params), "Google_Service_Classroom_Student");
 745    }
 746  
 747    /**
 748     * Returns a list of students of this course that the requester is permitted to
 749     * view. This method returns the following error codes: * `NOT_FOUND` if the
 750     * course does not exist. * `PERMISSION_DENIED` for access errors.
 751     * (students.listCoursesStudents)
 752     *
 753     * @param string $courseId Identifier of the course. This identifier can be
 754     * either the Classroom-assigned identifier or an alias.
 755     * @param array $optParams Optional parameters.
 756     *
 757     * @opt_param string pageToken nextPageToken value returned from a previous list
 758     * call, indicating that the subsequent page of results should be returned. The
 759     * list request must be otherwise identical to the one that resulted in this
 760     * token.
 761     * @opt_param int pageSize Maximum number of items to return. Zero means no
 762     * maximum. The server may return fewer than the specified number of results.
 763     * @return Google_Service_Classroom_ListStudentsResponse
 764     */
 765    public function listCoursesStudents($courseId, $optParams = array())
 766    {
 767      $params = array('courseId' => $courseId);
 768      $params = array_merge($params, $optParams);
 769      return $this->call('list', array($params), "Google_Service_Classroom_ListStudentsResponse");
 770    }
 771  }
 772  /**
 773   * The "teachers" collection of methods.
 774   * Typical usage is:
 775   *  <code>
 776   *   $classroomService = new Google_Service_Classroom(...);
 777   *   $teachers = $classroomService->teachers;
 778   *  </code>
 779   */
 780  class Google_Service_Classroom_CoursesTeachers_Resource extends Google_Service_Resource
 781  {
 782  
 783    /**
 784     * Creates a teacher of a course. This method returns the following error codes:
 785     * * `PERMISSION_DENIED` if the requesting user is not permitted to create
 786     * teachers in this course or for access errors. * `NOT_FOUND` if the requested
 787     * course ID does not exist. * `FAILED_PRECONDITION` if the requested user's
 788     * account is disabled, for the following request errors: *
 789     * CourseMemberLimitReached * CourseNotModifiable * CourseTeacherLimitReached *
 790     * UserGroupsMembershipLimitReached * `ALREADY_EXISTS` if the user is already a
 791     * teacher or student in the course. (teachers.create)
 792     *
 793     * @param string $courseId Identifier of the course. This identifier can be
 794     * either the Classroom-assigned identifier or an alias.
 795     * @param Google_Teacher $postBody
 796     * @param array $optParams Optional parameters.
 797     * @return Google_Service_Classroom_Teacher
 798     */
 799    public function create($courseId, Google_Service_Classroom_Teacher $postBody, $optParams = array())
 800    {
 801      $params = array('courseId' => $courseId, 'postBody' => $postBody);
 802      $params = array_merge($params, $optParams);
 803      return $this->call('create', array($params), "Google_Service_Classroom_Teacher");
 804    }
 805  
 806    /**
 807     * Deletes a teacher of a course. This method returns the following error codes:
 808     * * `PERMISSION_DENIED` if the requesting user is not permitted to delete
 809     * teachers of this course or for access errors. * `NOT_FOUND` if no teacher of
 810     * this course has the requested ID or if the course does not exist. *
 811     * `FAILED_PRECONDITION` if the requested ID belongs to the primary teacher of
 812     * this course. (teachers.delete)
 813     *
 814     * @param string $courseId Identifier of the course. This identifier can be
 815     * either the Classroom-assigned identifier or an alias.
 816     * @param string $userId Identifier of the teacher to delete. The identifier can
 817     * be one of the following: * the numeric identifier for the user * the email
 818     * address of the user * the string literal `"me"`, indicating the requesting
 819     * user
 820     * @param array $optParams Optional parameters.
 821     * @return Google_Service_Classroom_Empty
 822     */
 823    public function delete($courseId, $userId, $optParams = array())
 824    {
 825      $params = array('courseId' => $courseId, 'userId' => $userId);
 826      $params = array_merge($params, $optParams);
 827      return $this->call('delete', array($params), "Google_Service_Classroom_Empty");
 828    }
 829  
 830    /**
 831     * Returns a teacher of a course. This method returns the following error codes:
 832     * * `PERMISSION_DENIED` if the requesting user is not permitted to view
 833     * teachers of this course or for access errors. * `NOT_FOUND` if no teacher of
 834     * this course has the requested ID or if the course does not exist.
 835     * (teachers.get)
 836     *
 837     * @param string $courseId Identifier of the course. This identifier can be
 838     * either the Classroom-assigned identifier or an alias.
 839     * @param string $userId Identifier of the teacher to return. The identifier can
 840     * be one of the following: * the numeric identifier for the user * the email
 841     * address of the user * the string literal `"me"`, indicating the requesting
 842     * user
 843     * @param array $optParams Optional parameters.
 844     * @return Google_Service_Classroom_Teacher
 845     */
 846    public function get($courseId, $userId, $optParams = array())
 847    {
 848      $params = array('courseId' => $courseId, 'userId' => $userId);
 849      $params = array_merge($params, $optParams);
 850      return $this->call('get', array($params), "Google_Service_Classroom_Teacher");
 851    }
 852  
 853    /**
 854     * Returns a list of teachers of this course that the requester is permitted to
 855     * view. This method returns the following error codes: * `NOT_FOUND` if the
 856     * course does not exist. * `PERMISSION_DENIED` for access errors.
 857     * (teachers.listCoursesTeachers)
 858     *
 859     * @param string $courseId Identifier of the course. This identifier can be
 860     * either the Classroom-assigned identifier or an alias.
 861     * @param array $optParams Optional parameters.
 862     *
 863     * @opt_param string pageToken nextPageToken value returned from a previous list
 864     * call, indicating that the subsequent page of results should be returned. The
 865     * list request must be otherwise identical to the one that resulted in this
 866     * token.
 867     * @opt_param int pageSize Maximum number of items to return. Zero means no
 868     * maximum. The server may return fewer than the specified number of results.
 869     * @return Google_Service_Classroom_ListTeachersResponse
 870     */
 871    public function listCoursesTeachers($courseId, $optParams = array())
 872    {
 873      $params = array('courseId' => $courseId);
 874      $params = array_merge($params, $optParams);
 875      return $this->call('list', array($params), "Google_Service_Classroom_ListTeachersResponse");
 876    }
 877  }
 878  
 879  /**
 880   * The "invitations" collection of methods.
 881   * Typical usage is:
 882   *  <code>
 883   *   $classroomService = new Google_Service_Classroom(...);
 884   *   $invitations = $classroomService->invitations;
 885   *  </code>
 886   */
 887  class Google_Service_Classroom_Invitations_Resource extends Google_Service_Resource
 888  {
 889  
 890    /**
 891     * Accepts an invitation, removing it and adding the invited user to the
 892     * teachers or students (as appropriate) of the specified course. Only the
 893     * invited user may accept an invitation. This method returns the following
 894     * error codes: * `PERMISSION_DENIED` if the requesting user is not permitted to
 895     * accept the requested invitation or for access errors. * `FAILED_PRECONDITION`
 896     * for the following request errors: * CourseMemberLimitReached *
 897     * CourseNotModifiable * CourseTeacherLimitReached *
 898     * UserGroupsMembershipLimitReached * `NOT_FOUND` if no invitation exists with
 899     * the requested ID. (invitations.accept)
 900     *
 901     * @param string $id Identifier of the invitation to accept.
 902     * @param array $optParams Optional parameters.
 903     * @return Google_Service_Classroom_Empty
 904     */
 905    public function accept($id, $optParams = array())
 906    {
 907      $params = array('id' => $id);
 908      $params = array_merge($params, $optParams);
 909      return $this->call('accept', array($params), "Google_Service_Classroom_Empty");
 910    }
 911  
 912    /**
 913     * Creates an invitation. Only one invitation for a user and course may exist at
 914     * a time. Delete and re-create an invitation to make changes. This method
 915     * returns the following error codes: * `PERMISSION_DENIED` if the requesting
 916     * user is not permitted to create invitations for this course or for access
 917     * errors. * `NOT_FOUND` if the course or the user does not exist. *
 918     * `FAILED_PRECONDITION` if the requested user's account is disabled or if the
 919     * user already has this role or a role with greater permissions. *
 920     * `ALREADY_EXISTS` if an invitation for the specified user and course already
 921     * exists. (invitations.create)
 922     *
 923     * @param Google_Invitation $postBody
 924     * @param array $optParams Optional parameters.
 925     * @return Google_Service_Classroom_Invitation
 926     */
 927    public function create(Google_Service_Classroom_Invitation $postBody, $optParams = array())
 928    {
 929      $params = array('postBody' => $postBody);
 930      $params = array_merge($params, $optParams);
 931      return $this->call('create', array($params), "Google_Service_Classroom_Invitation");
 932    }
 933  
 934    /**
 935     * Deletes an invitation. This method returns the following error codes: *
 936     * `PERMISSION_DENIED` if the requesting user is not permitted to delete the
 937     * requested invitation or for access errors. * `NOT_FOUND` if no invitation
 938     * exists with the requested ID. (invitations.delete)
 939     *
 940     * @param string $id Identifier of the invitation to delete.
 941     * @param array $optParams Optional parameters.
 942     * @return Google_Service_Classroom_Empty
 943     */
 944    public function delete($id, $optParams = array())
 945    {
 946      $params = array('id' => $id);
 947      $params = array_merge($params, $optParams);
 948      return $this->call('delete', array($params), "Google_Service_Classroom_Empty");
 949    }
 950  
 951    /**
 952     * Returns an invitation. This method returns the following error codes: *
 953     * `PERMISSION_DENIED` if the requesting user is not permitted to view the
 954     * requested invitation or for access errors. * `NOT_FOUND` if no invitation
 955     * exists with the requested ID. (invitations.get)
 956     *
 957     * @param string $id Identifier of the invitation to return.
 958     * @param array $optParams Optional parameters.
 959     * @return Google_Service_Classroom_Invitation
 960     */
 961    public function get($id, $optParams = array())
 962    {
 963      $params = array('id' => $id);
 964      $params = array_merge($params, $optParams);
 965      return $this->call('get', array($params), "Google_Service_Classroom_Invitation");
 966    }
 967  
 968    /**
 969     * Returns a list of invitations that the requesting user is permitted to view,
 970     * restricted to those that match the list request. *Note:* At least one of
 971     * `user_id` or `course_id` must be supplied. Both fields can be supplied. This
 972     * method returns the following error codes: * `PERMISSION_DENIED` for access
 973     * errors. (invitations.listInvitations)
 974     *
 975     * @param array $optParams Optional parameters.
 976     *
 977     * @opt_param string courseId Restricts returned invitations to those for a
 978     * course with the specified identifier.
 979     * @opt_param string pageToken nextPageToken value returned from a previous list
 980     * call, indicating that the subsequent page of results should be returned. The
 981     * list request must be otherwise identical to the one that resulted in this
 982     * token.
 983     * @opt_param string userId Restricts returned invitations to those for a
 984     * specific user. The identifier can be one of the following: * the numeric
 985     * identifier for the user * the email address of the user * the string literal
 986     * `"me"`, indicating the requesting user
 987     * @opt_param int pageSize Maximum number of items to return. Zero means no
 988     * maximum. The server may return fewer than the specified number of results.
 989     * @return Google_Service_Classroom_ListInvitationsResponse
 990     */
 991    public function listInvitations($optParams = array())
 992    {
 993      $params = array();
 994      $params = array_merge($params, $optParams);
 995      return $this->call('list', array($params), "Google_Service_Classroom_ListInvitationsResponse");
 996    }
 997  }
 998  
 999  /**
1000   * The "userProfiles" collection of methods.
1001   * Typical usage is:
1002   *  <code>
1003   *   $classroomService = new Google_Service_Classroom(...);
1004   *   $userProfiles = $classroomService->userProfiles;
1005   *  </code>
1006   */
1007  class Google_Service_Classroom_UserProfiles_Resource extends Google_Service_Resource
1008  {
1009  
1010    /**
1011     * Returns a user profile. This method returns the following error codes: *
1012     * `PERMISSION_DENIED` if the requesting user is not permitted to access this
1013     * user profile or if no profile exists with the requested ID or for access
1014     * errors. (userProfiles.get)
1015     *
1016     * @param string $userId Identifier of the profile to return. The identifier can
1017     * be one of the following: * the numeric identifier for the user * the email
1018     * address of the user * the string literal `"me"`, indicating the requesting
1019     * user
1020     * @param array $optParams Optional parameters.
1021     * @return Google_Service_Classroom_UserProfile
1022     */
1023    public function get($userId, $optParams = array())
1024    {
1025      $params = array('userId' => $userId);
1026      $params = array_merge($params, $optParams);
1027      return $this->call('get', array($params), "Google_Service_Classroom_UserProfile");
1028    }
1029  }
1030  
1031  
1032  
1033  
1034  class Google_Service_Classroom_Course extends Google_Model
1035  {
1036    protected $internal_gapi_mappings = array(
1037    );
1038    public $alternateLink;
1039    public $courseState;
1040    public $creationTime;
1041    public $description;
1042    public $descriptionHeading;
1043    public $enrollmentCode;
1044    public $id;
1045    public $name;
1046    public $ownerId;
1047    public $room;
1048    public $section;
1049    public $updateTime;
1050  
1051  
1052    public function setAlternateLink($alternateLink)
1053    {
1054      $this->alternateLink = $alternateLink;
1055    }
1056    public function getAlternateLink()
1057    {
1058      return $this->alternateLink;
1059    }
1060    public function setCourseState($courseState)
1061    {
1062      $this->courseState = $courseState;
1063    }
1064    public function getCourseState()
1065    {
1066      return $this->courseState;
1067    }
1068    public function setCreationTime($creationTime)
1069    {
1070      $this->creationTime = $creationTime;
1071    }
1072    public function getCreationTime()
1073    {
1074      return $this->creationTime;
1075    }
1076    public function setDescription($description)
1077    {
1078      $this->description = $description;
1079    }
1080    public function getDescription()
1081    {
1082      return $this->description;
1083    }
1084    public function setDescriptionHeading($descriptionHeading)
1085    {
1086      $this->descriptionHeading = $descriptionHeading;
1087    }
1088    public function getDescriptionHeading()
1089    {
1090      return $this->descriptionHeading;
1091    }
1092    public function setEnrollmentCode($enrollmentCode)
1093    {
1094      $this->enrollmentCode = $enrollmentCode;
1095    }
1096    public function getEnrollmentCode()
1097    {
1098      return $this->enrollmentCode;
1099    }
1100    public function setId($id)
1101    {
1102      $this->id = $id;
1103    }
1104    public function getId()
1105    {
1106      return $this->id;
1107    }
1108    public function setName($name)
1109    {
1110      $this->name = $name;
1111    }
1112    public function getName()
1113    {
1114      return $this->name;
1115    }
1116    public function setOwnerId($ownerId)
1117    {
1118      $this->ownerId = $ownerId;
1119    }
1120    public function getOwnerId()
1121    {
1122      return $this->ownerId;
1123    }
1124    public function setRoom($room)
1125    {
1126      $this->room = $room;
1127    }
1128    public function getRoom()
1129    {
1130      return $this->room;
1131    }
1132    public function setSection($section)
1133    {
1134      $this->section = $section;
1135    }
1136    public function getSection()
1137    {
1138      return $this->section;
1139    }
1140    public function setUpdateTime($updateTime)
1141    {
1142      $this->updateTime = $updateTime;
1143    }
1144    public function getUpdateTime()
1145    {
1146      return $this->updateTime;
1147    }
1148  }
1149  
1150  class Google_Service_Classroom_CourseAlias extends Google_Model
1151  {
1152    protected $internal_gapi_mappings = array(
1153    );
1154    public $alias;
1155  
1156  
1157    public function setAlias($alias)
1158    {
1159      $this->alias = $alias;
1160    }
1161    public function getAlias()
1162    {
1163      return $this->alias;
1164    }
1165  }
1166  
1167  class Google_Service_Classroom_Empty extends Google_Model
1168  {
1169  }
1170  
1171  class Google_Service_Classroom_GlobalPermission extends Google_Model
1172  {
1173    protected $internal_gapi_mappings = array(
1174    );
1175    public $permission;
1176  
1177  
1178    public function setPermission($permission)
1179    {
1180      $this->permission = $permission;
1181    }
1182    public function getPermission()
1183    {
1184      return $this->permission;
1185    }
1186  }
1187  
1188  class Google_Service_Classroom_Invitation extends Google_Model
1189  {
1190    protected $internal_gapi_mappings = array(
1191    );
1192    public $courseId;
1193    public $id;
1194    public $role;
1195    public $userId;
1196  
1197  
1198    public function setCourseId($courseId)
1199    {
1200      $this->courseId = $courseId;
1201    }
1202    public function getCourseId()
1203    {
1204      return $this->courseId;
1205    }
1206    public function setId($id)
1207    {
1208      $this->id = $id;
1209    }
1210    public function getId()
1211    {
1212      return $this->id;
1213    }
1214    public function setRole($role)
1215    {
1216      $this->role = $role;
1217    }
1218    public function getRole()
1219    {
1220      return $this->role;
1221    }
1222    public function setUserId($userId)
1223    {
1224      $this->userId = $userId;
1225    }
1226    public function getUserId()
1227    {
1228      return $this->userId;
1229    }
1230  }
1231  
1232  class Google_Service_Classroom_ListCourseAliasesResponse extends Google_Collection
1233  {
1234    protected $collection_key = 'aliases';
1235    protected $internal_gapi_mappings = array(
1236    );
1237    protected $aliasesType = 'Google_Service_Classroom_CourseAlias';
1238    protected $aliasesDataType = 'array';
1239    public $nextPageToken;
1240  
1241  
1242    public function setAliases($aliases)
1243    {
1244      $this->aliases = $aliases;
1245    }
1246    public function getAliases()
1247    {
1248      return $this->aliases;
1249    }
1250    public function setNextPageToken($nextPageToken)
1251    {
1252      $this->nextPageToken = $nextPageToken;
1253    }
1254    public function getNextPageToken()
1255    {
1256      return $this->nextPageToken;
1257    }
1258  }
1259  
1260  class Google_Service_Classroom_ListCoursesResponse extends Google_Collection
1261  {
1262    protected $collection_key = 'courses';
1263    protected $internal_gapi_mappings = array(
1264    );
1265    protected $coursesType = 'Google_Service_Classroom_Course';
1266    protected $coursesDataType = 'array';
1267    public $nextPageToken;
1268  
1269  
1270    public function setCourses($courses)
1271    {
1272      $this->courses = $courses;
1273    }
1274    public function getCourses()
1275    {
1276      return $this->courses;
1277    }
1278    public function setNextPageToken($nextPageToken)
1279    {
1280      $this->nextPageToken = $nextPageToken;
1281    }
1282    public function getNextPageToken()
1283    {
1284      return $this->nextPageToken;
1285    }
1286  }
1287  
1288  class Google_Service_Classroom_ListInvitationsResponse extends Google_Collection
1289  {
1290    protected $collection_key = 'invitations';
1291    protected $internal_gapi_mappings = array(
1292    );
1293    protected $invitationsType = 'Google_Service_Classroom_Invitation';
1294    protected $invitationsDataType = 'array';
1295    public $nextPageToken;
1296  
1297  
1298    public function setInvitations($invitations)
1299    {
1300      $this->invitations = $invitations;
1301    }
1302    public function getInvitations()
1303    {
1304      return $this->invitations;
1305    }
1306    public function setNextPageToken($nextPageToken)
1307    {
1308      $this->nextPageToken = $nextPageToken;
1309    }
1310    public function getNextPageToken()
1311    {
1312      return $this->nextPageToken;
1313    }
1314  }
1315  
1316  class Google_Service_Classroom_ListStudentsResponse extends Google_Collection
1317  {
1318    protected $collection_key = 'students';
1319    protected $internal_gapi_mappings = array(
1320    );
1321    public $nextPageToken;
1322    protected $studentsType = 'Google_Service_Classroom_Student';
1323    protected $studentsDataType = 'array';
1324  
1325  
1326    public function setNextPageToken($nextPageToken)
1327    {
1328      $this->nextPageToken = $nextPageToken;
1329    }
1330    public function getNextPageToken()
1331    {
1332      return $this->nextPageToken;
1333    }
1334    public function setStudents($students)
1335    {
1336      $this->students = $students;
1337    }
1338    public function getStudents()
1339    {
1340      return $this->students;
1341    }
1342  }
1343  
1344  class Google_Service_Classroom_ListTeachersResponse extends Google_Collection
1345  {
1346    protected $collection_key = 'teachers';
1347    protected $internal_gapi_mappings = array(
1348    );
1349    public $nextPageToken;
1350    protected $teachersType = 'Google_Service_Classroom_Teacher';
1351    protected $teachersDataType = 'array';
1352  
1353  
1354    public function setNextPageToken($nextPageToken)
1355    {
1356      $this->nextPageToken = $nextPageToken;
1357    }
1358    public function getNextPageToken()
1359    {
1360      return $this->nextPageToken;
1361    }
1362    public function setTeachers($teachers)
1363    {
1364      $this->teachers = $teachers;
1365    }
1366    public function getTeachers()
1367    {
1368      return $this->teachers;
1369    }
1370  }
1371  
1372  class Google_Service_Classroom_Name extends Google_Model
1373  {
1374    protected $internal_gapi_mappings = array(
1375    );
1376    public $familyName;
1377    public $fullName;
1378    public $givenName;
1379  
1380  
1381    public function setFamilyName($familyName)
1382    {
1383      $this->familyName = $familyName;
1384    }
1385    public function getFamilyName()
1386    {
1387      return $this->familyName;
1388    }
1389    public function setFullName($fullName)
1390    {
1391      $this->fullName = $fullName;
1392    }
1393    public function getFullName()
1394    {
1395      return $this->fullName;
1396    }
1397    public function setGivenName($givenName)
1398    {
1399      $this->givenName = $givenName;
1400    }
1401    public function getGivenName()
1402    {
1403      return $this->givenName;
1404    }
1405  }
1406  
1407  class Google_Service_Classroom_Student extends Google_Model
1408  {
1409    protected $internal_gapi_mappings = array(
1410    );
1411    public $courseId;
1412    protected $profileType = 'Google_Service_Classroom_UserProfile';
1413    protected $profileDataType = '';
1414    public $userId;
1415  
1416  
1417    public function setCourseId($courseId)
1418    {
1419      $this->courseId = $courseId;
1420    }
1421    public function getCourseId()
1422    {
1423      return $this->courseId;
1424    }
1425    public function setProfile(Google_Service_Classroom_UserProfile $profile)
1426    {
1427      $this->profile = $profile;
1428    }
1429    public function getProfile()
1430    {
1431      return $this->profile;
1432    }
1433    public function setUserId($userId)
1434    {
1435      $this->userId = $userId;
1436    }
1437    public function getUserId()
1438    {
1439      return $this->userId;
1440    }
1441  }
1442  
1443  class Google_Service_Classroom_Teacher extends Google_Model
1444  {
1445    protected $internal_gapi_mappings = array(
1446    );
1447    public $courseId;
1448    protected $profileType = 'Google_Service_Classroom_UserProfile';
1449    protected $profileDataType = '';
1450    public $userId;
1451  
1452  
1453    public function setCourseId($courseId)
1454    {
1455      $this->courseId = $courseId;
1456    }
1457    public function getCourseId()
1458    {
1459      return $this->courseId;
1460    }
1461    public function setProfile(Google_Service_Classroom_UserProfile $profile)
1462    {
1463      $this->profile = $profile;
1464    }
1465    public function getProfile()
1466    {
1467      return $this->profile;
1468    }
1469    public function setUserId($userId)
1470    {
1471      $this->userId = $userId;
1472    }
1473    public function getUserId()
1474    {
1475      return $this->userId;
1476    }
1477  }
1478  
1479  class Google_Service_Classroom_UserProfile extends Google_Collection
1480  {
1481    protected $collection_key = 'permissions';
1482    protected $internal_gapi_mappings = array(
1483    );
1484    public $emailAddress;
1485    public $id;
1486    protected $nameType = 'Google_Service_Classroom_Name';
1487    protected $nameDataType = '';
1488    protected $permissionsType = 'Google_Service_Classroom_GlobalPermission';
1489    protected $permissionsDataType = 'array';
1490    public $photoUrl;
1491  
1492  
1493    public function setEmailAddress($emailAddress)
1494    {
1495      $this->emailAddress = $emailAddress;
1496    }
1497    public function getEmailAddress()
1498    {
1499      return $this->emailAddress;
1500    }
1501    public function setId($id)
1502    {
1503      $this->id = $id;
1504    }
1505    public function getId()
1506    {
1507      return $this->id;
1508    }
1509    public function setName(Google_Service_Classroom_Name $name)
1510    {
1511      $this->name = $name;
1512    }
1513    public function getName()
1514    {
1515      return $this->name;
1516    }
1517    public function setPermissions($permissions)
1518    {
1519      $this->permissions = $permissions;
1520    }
1521    public function getPermissions()
1522    {
1523      return $this->permissions;
1524    }
1525    public function setPhotoUrl($photoUrl)
1526    {
1527      $this->photoUrl = $photoUrl;
1528    }
1529    public function getPhotoUrl()
1530    {
1531      return $this->photoUrl;
1532    }
1533  }