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 Proximitybeacon (v1beta1).
  20   *
  21   * <p>
  22   * This API provides services to register, manage, index, and search beacons.</p>
  23   *
  24   * <p>
  25   * For more information about this service, see the API
  26   * <a href="https://developers.google.com/beacons/proximity/" target="_blank">Documentation</a>
  27   * </p>
  28   *
  29   * @author Google, Inc.
  30   */
  31  class Google_Service_Proximitybeacon extends Google_Service
  32  {
  33  
  34  
  35    public $beaconinfo;
  36    public $beacons;
  37    public $beacons_attachments;
  38    public $beacons_diagnostics;
  39    public $namespaces;
  40    
  41  
  42    /**
  43     * Constructs the internal representation of the Proximitybeacon service.
  44     *
  45     * @param Google_Client $client
  46     */
  47    public function __construct(Google_Client $client)
  48    {
  49      parent::__construct($client);
  50      $this->rootUrl = 'https://proximitybeacon.googleapis.com/';
  51      $this->servicePath = '';
  52      $this->version = 'v1beta1';
  53      $this->serviceName = 'proximitybeacon';
  54  
  55      $this->beaconinfo = new Google_Service_Proximitybeacon_Beaconinfo_Resource(
  56          $this,
  57          $this->serviceName,
  58          'beaconinfo',
  59          array(
  60            'methods' => array(
  61              'getforobserved' => array(
  62                'path' => 'v1beta1/beaconinfo:getforobserved',
  63                'httpMethod' => 'POST',
  64                'parameters' => array(),
  65              ),
  66            )
  67          )
  68      );
  69      $this->beacons = new Google_Service_Proximitybeacon_Beacons_Resource(
  70          $this,
  71          $this->serviceName,
  72          'beacons',
  73          array(
  74            'methods' => array(
  75              'activate' => array(
  76                'path' => 'v1beta1/{+beaconName}:activate',
  77                'httpMethod' => 'POST',
  78                'parameters' => array(
  79                  'beaconName' => array(
  80                    'location' => 'path',
  81                    'type' => 'string',
  82                    'required' => true,
  83                  ),
  84                ),
  85              ),'deactivate' => array(
  86                'path' => 'v1beta1/{+beaconName}:deactivate',
  87                'httpMethod' => 'POST',
  88                'parameters' => array(
  89                  'beaconName' => array(
  90                    'location' => 'path',
  91                    'type' => 'string',
  92                    'required' => true,
  93                  ),
  94                ),
  95              ),'decommission' => array(
  96                'path' => 'v1beta1/{+beaconName}:decommission',
  97                'httpMethod' => 'POST',
  98                'parameters' => array(
  99                  'beaconName' => array(
 100                    'location' => 'path',
 101                    'type' => 'string',
 102                    'required' => true,
 103                  ),
 104                ),
 105              ),'get' => array(
 106                'path' => 'v1beta1/{+beaconName}',
 107                'httpMethod' => 'GET',
 108                'parameters' => array(
 109                  'beaconName' => array(
 110                    'location' => 'path',
 111                    'type' => 'string',
 112                    'required' => true,
 113                  ),
 114                ),
 115              ),'list' => array(
 116                'path' => 'v1beta1/beacons',
 117                'httpMethod' => 'GET',
 118                'parameters' => array(
 119                  'q' => array(
 120                    'location' => 'query',
 121                    'type' => 'string',
 122                  ),
 123                  'pageToken' => array(
 124                    'location' => 'query',
 125                    'type' => 'string',
 126                  ),
 127                  'pageSize' => array(
 128                    'location' => 'query',
 129                    'type' => 'integer',
 130                  ),
 131                ),
 132              ),'register' => array(
 133                'path' => 'v1beta1/beacons:register',
 134                'httpMethod' => 'POST',
 135                'parameters' => array(),
 136              ),'update' => array(
 137                'path' => 'v1beta1/{+beaconName}',
 138                'httpMethod' => 'PUT',
 139                'parameters' => array(
 140                  'beaconName' => array(
 141                    'location' => 'path',
 142                    'type' => 'string',
 143                    'required' => true,
 144                  ),
 145                ),
 146              ),
 147            )
 148          )
 149      );
 150      $this->beacons_attachments = new Google_Service_Proximitybeacon_BeaconsAttachments_Resource(
 151          $this,
 152          $this->serviceName,
 153          'attachments',
 154          array(
 155            'methods' => array(
 156              'batchDelete' => array(
 157                'path' => 'v1beta1/{+beaconName}/attachments:batchDelete',
 158                'httpMethod' => 'POST',
 159                'parameters' => array(
 160                  'beaconName' => array(
 161                    'location' => 'path',
 162                    'type' => 'string',
 163                    'required' => true,
 164                  ),
 165                  'namespacedType' => array(
 166                    'location' => 'query',
 167                    'type' => 'string',
 168                  ),
 169                ),
 170              ),'create' => array(
 171                'path' => 'v1beta1/{+beaconName}/attachments',
 172                'httpMethod' => 'POST',
 173                'parameters' => array(
 174                  'beaconName' => array(
 175                    'location' => 'path',
 176                    'type' => 'string',
 177                    'required' => true,
 178                  ),
 179                ),
 180              ),'delete' => array(
 181                'path' => 'v1beta1/{+attachmentName}',
 182                'httpMethod' => 'DELETE',
 183                'parameters' => array(
 184                  'attachmentName' => array(
 185                    'location' => 'path',
 186                    'type' => 'string',
 187                    'required' => true,
 188                  ),
 189                ),
 190              ),'list' => array(
 191                'path' => 'v1beta1/{+beaconName}/attachments',
 192                'httpMethod' => 'GET',
 193                'parameters' => array(
 194                  'beaconName' => array(
 195                    'location' => 'path',
 196                    'type' => 'string',
 197                    'required' => true,
 198                  ),
 199                  'namespacedType' => array(
 200                    'location' => 'query',
 201                    'type' => 'string',
 202                  ),
 203                ),
 204              ),
 205            )
 206          )
 207      );
 208      $this->beacons_diagnostics = new Google_Service_Proximitybeacon_BeaconsDiagnostics_Resource(
 209          $this,
 210          $this->serviceName,
 211          'diagnostics',
 212          array(
 213            'methods' => array(
 214              'list' => array(
 215                'path' => 'v1beta1/{+beaconName}/diagnostics',
 216                'httpMethod' => 'GET',
 217                'parameters' => array(
 218                  'beaconName' => array(
 219                    'location' => 'path',
 220                    'type' => 'string',
 221                    'required' => true,
 222                  ),
 223                  'pageToken' => array(
 224                    'location' => 'query',
 225                    'type' => 'string',
 226                  ),
 227                  'alertFilter' => array(
 228                    'location' => 'query',
 229                    'type' => 'string',
 230                  ),
 231                  'pageSize' => array(
 232                    'location' => 'query',
 233                    'type' => 'integer',
 234                  ),
 235                ),
 236              ),
 237            )
 238          )
 239      );
 240      $this->namespaces = new Google_Service_Proximitybeacon_Namespaces_Resource(
 241          $this,
 242          $this->serviceName,
 243          'namespaces',
 244          array(
 245            'methods' => array(
 246              'list' => array(
 247                'path' => 'v1beta1/namespaces',
 248                'httpMethod' => 'GET',
 249                'parameters' => array(),
 250              ),
 251            )
 252          )
 253      );
 254    }
 255  }
 256  
 257  
 258  /**
 259   * The "beaconinfo" collection of methods.
 260   * Typical usage is:
 261   *  <code>
 262   *   $proximitybeaconService = new Google_Service_Proximitybeacon(...);
 263   *   $beaconinfo = $proximitybeaconService->beaconinfo;
 264   *  </code>
 265   */
 266  class Google_Service_Proximitybeacon_Beaconinfo_Resource extends Google_Service_Resource
 267  {
 268  
 269    /**
 270     * Given one or more beacon observations, returns any beacon information and
 271     * attachments accessible to your application. (beaconinfo.getforobserved)
 272     *
 273     * @param Google_GetInfoForObservedBeaconsRequest $postBody
 274     * @param array $optParams Optional parameters.
 275     * @return Google_Service_Proximitybeacon_GetInfoForObservedBeaconsResponse
 276     */
 277    public function getforobserved(Google_Service_Proximitybeacon_GetInfoForObservedBeaconsRequest $postBody, $optParams = array())
 278    {
 279      $params = array('postBody' => $postBody);
 280      $params = array_merge($params, $optParams);
 281      return $this->call('getforobserved', array($params), "Google_Service_Proximitybeacon_GetInfoForObservedBeaconsResponse");
 282    }
 283  }
 284  
 285  /**
 286   * The "beacons" collection of methods.
 287   * Typical usage is:
 288   *  <code>
 289   *   $proximitybeaconService = new Google_Service_Proximitybeacon(...);
 290   *   $beacons = $proximitybeaconService->beacons;
 291   *  </code>
 292   */
 293  class Google_Service_Proximitybeacon_Beacons_Resource extends Google_Service_Resource
 294  {
 295  
 296    /**
 297     * (Re)activates a beacon. A beacon that is active will return information and
 298     * attachment data when queried via `beaconinfo.getforobserved`. Calling this
 299     * method on an already active beacon will do nothing (but will return a
 300     * successful response code). (beacons.activate)
 301     *
 302     * @param string $beaconName The beacon to activate. Required.
 303     * @param array $optParams Optional parameters.
 304     * @return Google_Service_Proximitybeacon_Empty
 305     */
 306    public function activate($beaconName, $optParams = array())
 307    {
 308      $params = array('beaconName' => $beaconName);
 309      $params = array_merge($params, $optParams);
 310      return $this->call('activate', array($params), "Google_Service_Proximitybeacon_Empty");
 311    }
 312  
 313    /**
 314     * Deactivates a beacon. Once deactivated, the API will not return information
 315     * nor attachment data for the beacon when queried via
 316     * `beaconinfo.getforobserved`. Calling this method on an already inactive
 317     * beacon will do nothing (but will return a successful response code).
 318     * (beacons.deactivate)
 319     *
 320     * @param string $beaconName The beacon name of this beacon.
 321     * @param array $optParams Optional parameters.
 322     * @return Google_Service_Proximitybeacon_Empty
 323     */
 324    public function deactivate($beaconName, $optParams = array())
 325    {
 326      $params = array('beaconName' => $beaconName);
 327      $params = array_merge($params, $optParams);
 328      return $this->call('deactivate', array($params), "Google_Service_Proximitybeacon_Empty");
 329    }
 330  
 331    /**
 332     * Decommissions the specified beacon in the service. This beacon will no longer
 333     * be returned from `beaconinfo.getforobserved`. This operation is permanent --
 334     * you will not be able to re-register a beacon with this ID again.
 335     * (beacons.decommission)
 336     *
 337     * @param string $beaconName Beacon that should be decommissioned. Required.
 338     * @param array $optParams Optional parameters.
 339     * @return Google_Service_Proximitybeacon_Empty
 340     */
 341    public function decommission($beaconName, $optParams = array())
 342    {
 343      $params = array('beaconName' => $beaconName);
 344      $params = array_merge($params, $optParams);
 345      return $this->call('decommission', array($params), "Google_Service_Proximitybeacon_Empty");
 346    }
 347  
 348    /**
 349     * Returns detailed information about the specified beacon. (beacons.get)
 350     *
 351     * @param string $beaconName Beacon that is requested.
 352     * @param array $optParams Optional parameters.
 353     * @return Google_Service_Proximitybeacon_Beacon
 354     */
 355    public function get($beaconName, $optParams = array())
 356    {
 357      $params = array('beaconName' => $beaconName);
 358      $params = array_merge($params, $optParams);
 359      return $this->call('get', array($params), "Google_Service_Proximitybeacon_Beacon");
 360    }
 361  
 362    /**
 363     * Searches the beacon registry for beacons that match the given search
 364     * criteria. Only those beacons that the client has permission to list will be
 365     * returned. (beacons.listBeacons)
 366     *
 367     * @param array $optParams Optional parameters.
 368     *
 369     * @opt_param string q Filter query string that supports the following field
 370     * filters: * `description:""` For example: `description:"Room 3"` Returns
 371     * beacons whose description matches tokens in the string "Room 3" (not
 372     * necessarily that exact string). The string must be double-quoted. * `status:`
 373     * For example: `status:active` Returns beacons whose status matches the given
 374     * value. Values must be one of the Beacon.Status enum values (case
 375     * insensitive). Accepts multiple filters which will be combined with OR logic.
 376     * * `stability:` For example: `stability:mobile` Returns beacons whose expected
 377     * stability matches the given value. Values must be one of the Beacon.Stability
 378     * enum values (case insensitive). Accepts multiple filters which will be
 379     * combined with OR logic. * `place_id:""` For example:
 380     * `place_id:"ChIJVSZzVR8FdkgRXGmmm6SslKw="` Returns beacons explicitly
 381     * registered at the given place, expressed as a Place ID obtained from [Google
 382     * Places API](/places/place-id). Does not match places inside the given place.
 383     * Does not consider the beacon's actual location (which may be different from
 384     * its registered place). Accepts multiple filters that will be combined with OR
 385     * logic. The place ID must be double-quoted. * `registration_time[|=]` For
 386     * example: `registration_time>=1433116800` Returns beacons whose registration
 387     * time matches the given filter. Supports the operators: , =. Timestamp must be
 388     * expressed as an integer number of seconds since midnight January 1, 1970 UTC.
 389     * Accepts at most two filters that will be combined with AND logic, to support
 390     * "between" semantics. If more than two are supplied, the latter ones are
 391     * ignored. * `lat: lng: radius:` For example: `lat:51.1232343 lng:-1.093852
 392     * radius:1000` Returns beacons whose registered location is within the given
 393     * circle. When any of these fields are given, all are required. Latitude and
 394     * longitude must be decimal degrees between -90.0 and 90.0 and between -180.0
 395     * and 180.0 respectively. Radius must be an integer number of meters less than
 396     * 1,000,000 (1000 km). * `property:"="` For example: `property:"battery-
 397     * type=CR2032"` Returns beacons which have a property of the given name and
 398     * value. Supports multiple filters which will be combined with OR logic. The
 399     * entire name=value string must be double-quoted as one string. *
 400     * `attachment_type:""` For example: `attachment_type:"my-namespace/my-type"`
 401     * Returns beacons having at least one attachment of the given namespaced type.
 402     * Supports "any within this namespace" via the partial wildcard syntax: "my-
 403     * namespace". Supports multiple filters which will be combined with OR logic.
 404     * The string must be double-quoted. Multiple filters on the same field are
 405     * combined with OR logic (except registration_time which is combined with AND
 406     * logic). Multiple filters on different fields are combined with AND logic.
 407     * Filters should be separated by spaces. As with any HTTP query string
 408     * parameter, the whole filter expression must be URL-encoded. Example REST
 409     * request: `GET
 410     * /v1beta1/beacons?q=status:active%20lat:51.123%20lng:-1.095%20radius:1000`
 411     * @opt_param string pageToken A pagination token obtained from a previous
 412     * request to list beacons.
 413     * @opt_param int pageSize The maximum number of records to return for this
 414     * request, up to a server-defined upper limit.
 415     * @return Google_Service_Proximitybeacon_ListBeaconsResponse
 416     */
 417    public function listBeacons($optParams = array())
 418    {
 419      $params = array();
 420      $params = array_merge($params, $optParams);
 421      return $this->call('list', array($params), "Google_Service_Proximitybeacon_ListBeaconsResponse");
 422    }
 423  
 424    /**
 425     * Registers a previously unregistered beacon given its `advertisedId`. These
 426     * IDs are unique within the system. An ID can be registered only once.
 427     * (beacons.register)
 428     *
 429     * @param Google_Beacon $postBody
 430     * @param array $optParams Optional parameters.
 431     * @return Google_Service_Proximitybeacon_Beacon
 432     */
 433    public function register(Google_Service_Proximitybeacon_Beacon $postBody, $optParams = array())
 434    {
 435      $params = array('postBody' => $postBody);
 436      $params = array_merge($params, $optParams);
 437      return $this->call('register', array($params), "Google_Service_Proximitybeacon_Beacon");
 438    }
 439  
 440    /**
 441     * Updates the information about the specified beacon. **Any field that you do
 442     * not populate in the submitted beacon will be permanently erased**, so you
 443     * should follow the "read, modify, write" pattern to avoid inadvertently
 444     * destroying data. Changes to the beacon status via this method will be
 445     * silently ignored. To update beacon status, use the separate methods on this
 446     * API for (de)activation and decommissioning. (beacons.update)
 447     *
 448     * @param string $beaconName Resource name of this beacon. A beacon name has the
 449     * format "beacons/N!beaconId" where the beaconId is the base16 ID broadcast by
 450     * the beacon and N is a code for the beacon's type. Possible values are `3` for
 451     * Eddystone, `1` for iBeacon, or `5` for AltBeacon. This field must be left
 452     * empty when registering. After reading a beacon, clients can use the name for
 453     * future operations.
 454     * @param Google_Beacon $postBody
 455     * @param array $optParams Optional parameters.
 456     * @return Google_Service_Proximitybeacon_Beacon
 457     */
 458    public function update($beaconName, Google_Service_Proximitybeacon_Beacon $postBody, $optParams = array())
 459    {
 460      $params = array('beaconName' => $beaconName, 'postBody' => $postBody);
 461      $params = array_merge($params, $optParams);
 462      return $this->call('update', array($params), "Google_Service_Proximitybeacon_Beacon");
 463    }
 464  }
 465  
 466  /**
 467   * The "attachments" collection of methods.
 468   * Typical usage is:
 469   *  <code>
 470   *   $proximitybeaconService = new Google_Service_Proximitybeacon(...);
 471   *   $attachments = $proximitybeaconService->attachments;
 472   *  </code>
 473   */
 474  class Google_Service_Proximitybeacon_BeaconsAttachments_Resource extends Google_Service_Resource
 475  {
 476  
 477    /**
 478     * Deletes multiple attachments on a given beacon. This operation is permanent
 479     * and cannot be undone. You can optionally specify `namespacedType` to choose
 480     * which attachments should be deleted. If you do not specify `namespacedType`,
 481     * all your attachments on the given beacon will be deleted. You also may
 482     * explicitly specify `*` to delete all. (attachments.batchDelete)
 483     *
 484     * @param string $beaconName The beacon whose attachments are to be deleted.
 485     * Required.
 486     * @param array $optParams Optional parameters.
 487     *
 488     * @opt_param string namespacedType Specifies the namespace and type of
 489     * attachments to delete in `namespace/type` format. Accepts `*` to specify "all
 490     * types in all namespaces". Optional.
 491     * @return Google_Service_Proximitybeacon_DeleteAttachmentsResponse
 492     */
 493    public function batchDelete($beaconName, $optParams = array())
 494    {
 495      $params = array('beaconName' => $beaconName);
 496      $params = array_merge($params, $optParams);
 497      return $this->call('batchDelete', array($params), "Google_Service_Proximitybeacon_DeleteAttachmentsResponse");
 498    }
 499  
 500    /**
 501     * Associates the given data with the specified beacon. Attachment data must
 502     * contain two parts: - A namespaced type.  - The actual attachment data itself.
 503     * The namespaced type consists of two parts, the namespace and the type. The
 504     * namespace must be one of the values returned by the `namespaces` endpoint,
 505     * while the type can be a string of any characters except for the forward slash
 506     * (`/`) up to 100 characters in length. Attachment data can be up to 1024 bytes
 507     * long. (attachments.create)
 508     *
 509     * @param string $beaconName The beacon on which the attachment should be
 510     * created. Required.
 511     * @param Google_BeaconAttachment $postBody
 512     * @param array $optParams Optional parameters.
 513     * @return Google_Service_Proximitybeacon_BeaconAttachment
 514     */
 515    public function create($beaconName, Google_Service_Proximitybeacon_BeaconAttachment $postBody, $optParams = array())
 516    {
 517      $params = array('beaconName' => $beaconName, 'postBody' => $postBody);
 518      $params = array_merge($params, $optParams);
 519      return $this->call('create', array($params), "Google_Service_Proximitybeacon_BeaconAttachment");
 520    }
 521  
 522    /**
 523     * Deletes the specified attachment for the given beacon. Each attachment has a
 524     * unique attachment name (`attachmentName`) which is returned when you fetch
 525     * the attachment data via this API. You specify this with the delete request to
 526     * control which attachment is removed. This operation cannot be undone.
 527     * (attachments.delete)
 528     *
 529     * @param string $attachmentName The attachment name (`attachmentName`) of the
 530     * attachment to remove. For example:
 531     * `beacons/3!893737abc9/attachments/c5e937-af0-494-959-ec49d12738` Required.
 532     * @param array $optParams Optional parameters.
 533     * @return Google_Service_Proximitybeacon_Empty
 534     */
 535    public function delete($attachmentName, $optParams = array())
 536    {
 537      $params = array('attachmentName' => $attachmentName);
 538      $params = array_merge($params, $optParams);
 539      return $this->call('delete', array($params), "Google_Service_Proximitybeacon_Empty");
 540    }
 541  
 542    /**
 543     * Returns the attachments for the specified beacon that match the specified
 544     * namespaced-type pattern. To control which namespaced types are returned, you
 545     * add the `namespacedType` query parameter to the request. You must either use
 546     * `*`, to return all attachments, or the namespace must be one of the ones
 547     * returned from the `namespaces` endpoint. (attachments.listBeaconsAttachments)
 548     *
 549     * @param string $beaconName The beacon whose attachments are to be fetched.
 550     * Required.
 551     * @param array $optParams Optional parameters.
 552     *
 553     * @opt_param string namespacedType Specifies the namespace and type of
 554     * attachment to include in response in namespace/type format. Accepts `*` to
 555     * specify "all types in all namespaces".
 556     * @return Google_Service_Proximitybeacon_ListBeaconAttachmentsResponse
 557     */
 558    public function listBeaconsAttachments($beaconName, $optParams = array())
 559    {
 560      $params = array('beaconName' => $beaconName);
 561      $params = array_merge($params, $optParams);
 562      return $this->call('list', array($params), "Google_Service_Proximitybeacon_ListBeaconAttachmentsResponse");
 563    }
 564  }
 565  /**
 566   * The "diagnostics" collection of methods.
 567   * Typical usage is:
 568   *  <code>
 569   *   $proximitybeaconService = new Google_Service_Proximitybeacon(...);
 570   *   $diagnostics = $proximitybeaconService->diagnostics;
 571   *  </code>
 572   */
 573  class Google_Service_Proximitybeacon_BeaconsDiagnostics_Resource extends Google_Service_Resource
 574  {
 575  
 576    /**
 577     * List the diagnostics for a single beacon. You can also list diagnostics for
 578     * all the beacons owned by your Google Developers Console project by using the
 579     * beacon name `beacons/-`. (diagnostics.listBeaconsDiagnostics)
 580     *
 581     * @param string $beaconName Beacon that the diagnostics are for.
 582     * @param array $optParams Optional parameters.
 583     *
 584     * @opt_param string pageToken Requests results that occur after the
 585     * `page_token`, obtained from the response to a previous request. Optional.
 586     * @opt_param string alertFilter Requests only beacons that have the given
 587     * alert. For example, to find beacons that have low batteries use
 588     * `alert_filter=LOW_BATTERY`.
 589     * @opt_param int pageSize Specifies the maximum number of results to return.
 590     * Defaults to 10. Maximum 1000. Optional.
 591     * @return Google_Service_Proximitybeacon_ListDiagnosticsResponse
 592     */
 593    public function listBeaconsDiagnostics($beaconName, $optParams = array())
 594    {
 595      $params = array('beaconName' => $beaconName);
 596      $params = array_merge($params, $optParams);
 597      return $this->call('list', array($params), "Google_Service_Proximitybeacon_ListDiagnosticsResponse");
 598    }
 599  }
 600  
 601  /**
 602   * The "namespaces" collection of methods.
 603   * Typical usage is:
 604   *  <code>
 605   *   $proximitybeaconService = new Google_Service_Proximitybeacon(...);
 606   *   $namespaces = $proximitybeaconService->namespaces;
 607   *  </code>
 608   */
 609  class Google_Service_Proximitybeacon_Namespaces_Resource extends Google_Service_Resource
 610  {
 611  
 612    /**
 613     * Lists all attachment namespaces owned by your Google Developers Console
 614     * project. Attachment data associated with a beacon must include a namespaced
 615     * type, and the namespace must be owned by your project.
 616     * (namespaces.listNamespaces)
 617     *
 618     * @param array $optParams Optional parameters.
 619     * @return Google_Service_Proximitybeacon_ListNamespacesResponse
 620     */
 621    public function listNamespaces($optParams = array())
 622    {
 623      $params = array();
 624      $params = array_merge($params, $optParams);
 625      return $this->call('list', array($params), "Google_Service_Proximitybeacon_ListNamespacesResponse");
 626    }
 627  }
 628  
 629  
 630  
 631  
 632  class Google_Service_Proximitybeacon_AdvertisedId extends Google_Model
 633  {
 634    protected $internal_gapi_mappings = array(
 635    );
 636    public $id;
 637    public $type;
 638  
 639  
 640    public function setId($id)
 641    {
 642      $this->id = $id;
 643    }
 644    public function getId()
 645    {
 646      return $this->id;
 647    }
 648    public function setType($type)
 649    {
 650      $this->type = $type;
 651    }
 652    public function getType()
 653    {
 654      return $this->type;
 655    }
 656  }
 657  
 658  class Google_Service_Proximitybeacon_AttachmentInfo extends Google_Model
 659  {
 660    protected $internal_gapi_mappings = array(
 661    );
 662    public $data;
 663    public $namespacedType;
 664  
 665  
 666    public function setData($data)
 667    {
 668      $this->data = $data;
 669    }
 670    public function getData()
 671    {
 672      return $this->data;
 673    }
 674    public function setNamespacedType($namespacedType)
 675    {
 676      $this->namespacedType = $namespacedType;
 677    }
 678    public function getNamespacedType()
 679    {
 680      return $this->namespacedType;
 681    }
 682  }
 683  
 684  class Google_Service_Proximitybeacon_Beacon extends Google_Model
 685  {
 686    protected $internal_gapi_mappings = array(
 687    );
 688    protected $advertisedIdType = 'Google_Service_Proximitybeacon_AdvertisedId';
 689    protected $advertisedIdDataType = '';
 690    public $beaconName;
 691    public $description;
 692    public $expectedStability;
 693    protected $indoorLevelType = 'Google_Service_Proximitybeacon_IndoorLevel';
 694    protected $indoorLevelDataType = '';
 695    protected $latLngType = 'Google_Service_Proximitybeacon_LatLng';
 696    protected $latLngDataType = '';
 697    public $placeId;
 698    public $properties;
 699    public $status;
 700  
 701  
 702    public function setAdvertisedId(Google_Service_Proximitybeacon_AdvertisedId $advertisedId)
 703    {
 704      $this->advertisedId = $advertisedId;
 705    }
 706    public function getAdvertisedId()
 707    {
 708      return $this->advertisedId;
 709    }
 710    public function setBeaconName($beaconName)
 711    {
 712      $this->beaconName = $beaconName;
 713    }
 714    public function getBeaconName()
 715    {
 716      return $this->beaconName;
 717    }
 718    public function setDescription($description)
 719    {
 720      $this->description = $description;
 721    }
 722    public function getDescription()
 723    {
 724      return $this->description;
 725    }
 726    public function setExpectedStability($expectedStability)
 727    {
 728      $this->expectedStability = $expectedStability;
 729    }
 730    public function getExpectedStability()
 731    {
 732      return $this->expectedStability;
 733    }
 734    public function setIndoorLevel(Google_Service_Proximitybeacon_IndoorLevel $indoorLevel)
 735    {
 736      $this->indoorLevel = $indoorLevel;
 737    }
 738    public function getIndoorLevel()
 739    {
 740      return $this->indoorLevel;
 741    }
 742    public function setLatLng(Google_Service_Proximitybeacon_LatLng $latLng)
 743    {
 744      $this->latLng = $latLng;
 745    }
 746    public function getLatLng()
 747    {
 748      return $this->latLng;
 749    }
 750    public function setPlaceId($placeId)
 751    {
 752      $this->placeId = $placeId;
 753    }
 754    public function getPlaceId()
 755    {
 756      return $this->placeId;
 757    }
 758    public function setProperties($properties)
 759    {
 760      $this->properties = $properties;
 761    }
 762    public function getProperties()
 763    {
 764      return $this->properties;
 765    }
 766    public function setStatus($status)
 767    {
 768      $this->status = $status;
 769    }
 770    public function getStatus()
 771    {
 772      return $this->status;
 773    }
 774  }
 775  
 776  class Google_Service_Proximitybeacon_BeaconAttachment extends Google_Model
 777  {
 778    protected $internal_gapi_mappings = array(
 779    );
 780    public $attachmentName;
 781    public $data;
 782    public $namespacedType;
 783  
 784  
 785    public function setAttachmentName($attachmentName)
 786    {
 787      $this->attachmentName = $attachmentName;
 788    }
 789    public function getAttachmentName()
 790    {
 791      return $this->attachmentName;
 792    }
 793    public function setData($data)
 794    {
 795      $this->data = $data;
 796    }
 797    public function getData()
 798    {
 799      return $this->data;
 800    }
 801    public function setNamespacedType($namespacedType)
 802    {
 803      $this->namespacedType = $namespacedType;
 804    }
 805    public function getNamespacedType()
 806    {
 807      return $this->namespacedType;
 808    }
 809  }
 810  
 811  class Google_Service_Proximitybeacon_BeaconInfo extends Google_Collection
 812  {
 813    protected $collection_key = 'attachments';
 814    protected $internal_gapi_mappings = array(
 815    );
 816    protected $advertisedIdType = 'Google_Service_Proximitybeacon_AdvertisedId';
 817    protected $advertisedIdDataType = '';
 818    protected $attachmentsType = 'Google_Service_Proximitybeacon_AttachmentInfo';
 819    protected $attachmentsDataType = 'array';
 820    public $beaconName;
 821    public $description;
 822  
 823  
 824    public function setAdvertisedId(Google_Service_Proximitybeacon_AdvertisedId $advertisedId)
 825    {
 826      $this->advertisedId = $advertisedId;
 827    }
 828    public function getAdvertisedId()
 829    {
 830      return $this->advertisedId;
 831    }
 832    public function setAttachments($attachments)
 833    {
 834      $this->attachments = $attachments;
 835    }
 836    public function getAttachments()
 837    {
 838      return $this->attachments;
 839    }
 840    public function setBeaconName($beaconName)
 841    {
 842      $this->beaconName = $beaconName;
 843    }
 844    public function getBeaconName()
 845    {
 846      return $this->beaconName;
 847    }
 848    public function setDescription($description)
 849    {
 850      $this->description = $description;
 851    }
 852    public function getDescription()
 853    {
 854      return $this->description;
 855    }
 856  }
 857  
 858  class Google_Service_Proximitybeacon_BeaconProperties extends Google_Model
 859  {
 860  }
 861  
 862  class Google_Service_Proximitybeacon_Date extends Google_Model
 863  {
 864    protected $internal_gapi_mappings = array(
 865    );
 866    public $day;
 867    public $month;
 868    public $year;
 869  
 870  
 871    public function setDay($day)
 872    {
 873      $this->day = $day;
 874    }
 875    public function getDay()
 876    {
 877      return $this->day;
 878    }
 879    public function setMonth($month)
 880    {
 881      $this->month = $month;
 882    }
 883    public function getMonth()
 884    {
 885      return $this->month;
 886    }
 887    public function setYear($year)
 888    {
 889      $this->year = $year;
 890    }
 891    public function getYear()
 892    {
 893      return $this->year;
 894    }
 895  }
 896  
 897  class Google_Service_Proximitybeacon_DeleteAttachmentsResponse extends Google_Model
 898  {
 899    protected $internal_gapi_mappings = array(
 900    );
 901    public $numDeleted;
 902  
 903  
 904    public function setNumDeleted($numDeleted)
 905    {
 906      $this->numDeleted = $numDeleted;
 907    }
 908    public function getNumDeleted()
 909    {
 910      return $this->numDeleted;
 911    }
 912  }
 913  
 914  class Google_Service_Proximitybeacon_Diagnostics extends Google_Collection
 915  {
 916    protected $collection_key = 'alerts';
 917    protected $internal_gapi_mappings = array(
 918    );
 919    public $alerts;
 920    public $beaconName;
 921    protected $estimatedLowBatteryDateType = 'Google_Service_Proximitybeacon_Date';
 922    protected $estimatedLowBatteryDateDataType = '';
 923  
 924  
 925    public function setAlerts($alerts)
 926    {
 927      $this->alerts = $alerts;
 928    }
 929    public function getAlerts()
 930    {
 931      return $this->alerts;
 932    }
 933    public function setBeaconName($beaconName)
 934    {
 935      $this->beaconName = $beaconName;
 936    }
 937    public function getBeaconName()
 938    {
 939      return $this->beaconName;
 940    }
 941    public function setEstimatedLowBatteryDate(Google_Service_Proximitybeacon_Date $estimatedLowBatteryDate)
 942    {
 943      $this->estimatedLowBatteryDate = $estimatedLowBatteryDate;
 944    }
 945    public function getEstimatedLowBatteryDate()
 946    {
 947      return $this->estimatedLowBatteryDate;
 948    }
 949  }
 950  
 951  class Google_Service_Proximitybeacon_Empty extends Google_Model
 952  {
 953  }
 954  
 955  class Google_Service_Proximitybeacon_GetInfoForObservedBeaconsRequest extends Google_Collection
 956  {
 957    protected $collection_key = 'observations';
 958    protected $internal_gapi_mappings = array(
 959    );
 960    public $namespacedTypes;
 961    protected $observationsType = 'Google_Service_Proximitybeacon_Observation';
 962    protected $observationsDataType = 'array';
 963  
 964  
 965    public function setNamespacedTypes($namespacedTypes)
 966    {
 967      $this->namespacedTypes = $namespacedTypes;
 968    }
 969    public function getNamespacedTypes()
 970    {
 971      return $this->namespacedTypes;
 972    }
 973    public function setObservations($observations)
 974    {
 975      $this->observations = $observations;
 976    }
 977    public function getObservations()
 978    {
 979      return $this->observations;
 980    }
 981  }
 982  
 983  class Google_Service_Proximitybeacon_GetInfoForObservedBeaconsResponse extends Google_Collection
 984  {
 985    protected $collection_key = 'beacons';
 986    protected $internal_gapi_mappings = array(
 987    );
 988    protected $beaconsType = 'Google_Service_Proximitybeacon_BeaconInfo';
 989    protected $beaconsDataType = 'array';
 990  
 991  
 992    public function setBeacons($beacons)
 993    {
 994      $this->beacons = $beacons;
 995    }
 996    public function getBeacons()
 997    {
 998      return $this->beacons;
 999    }
1000  }
1001  
1002  class Google_Service_Proximitybeacon_IndoorLevel extends Google_Model
1003  {
1004    protected $internal_gapi_mappings = array(
1005    );
1006    public $name;
1007  
1008  
1009    public function setName($name)
1010    {
1011      $this->name = $name;
1012    }
1013    public function getName()
1014    {
1015      return $this->name;
1016    }
1017  }
1018  
1019  class Google_Service_Proximitybeacon_LatLng extends Google_Model
1020  {
1021    protected $internal_gapi_mappings = array(
1022    );
1023    public $latitude;
1024    public $longitude;
1025  
1026  
1027    public function setLatitude($latitude)
1028    {
1029      $this->latitude = $latitude;
1030    }
1031    public function getLatitude()
1032    {
1033      return $this->latitude;
1034    }
1035    public function setLongitude($longitude)
1036    {
1037      $this->longitude = $longitude;
1038    }
1039    public function getLongitude()
1040    {
1041      return $this->longitude;
1042    }
1043  }
1044  
1045  class Google_Service_Proximitybeacon_ListBeaconAttachmentsResponse extends Google_Collection
1046  {
1047    protected $collection_key = 'attachments';
1048    protected $internal_gapi_mappings = array(
1049    );
1050    protected $attachmentsType = 'Google_Service_Proximitybeacon_BeaconAttachment';
1051    protected $attachmentsDataType = 'array';
1052  
1053  
1054    public function setAttachments($attachments)
1055    {
1056      $this->attachments = $attachments;
1057    }
1058    public function getAttachments()
1059    {
1060      return $this->attachments;
1061    }
1062  }
1063  
1064  class Google_Service_Proximitybeacon_ListBeaconsResponse extends Google_Collection
1065  {
1066    protected $collection_key = 'beacons';
1067    protected $internal_gapi_mappings = array(
1068    );
1069    protected $beaconsType = 'Google_Service_Proximitybeacon_Beacon';
1070    protected $beaconsDataType = 'array';
1071    public $nextPageToken;
1072    public $totalCount;
1073  
1074  
1075    public function setBeacons($beacons)
1076    {
1077      $this->beacons = $beacons;
1078    }
1079    public function getBeacons()
1080    {
1081      return $this->beacons;
1082    }
1083    public function setNextPageToken($nextPageToken)
1084    {
1085      $this->nextPageToken = $nextPageToken;
1086    }
1087    public function getNextPageToken()
1088    {
1089      return $this->nextPageToken;
1090    }
1091    public function setTotalCount($totalCount)
1092    {
1093      $this->totalCount = $totalCount;
1094    }
1095    public function getTotalCount()
1096    {
1097      return $this->totalCount;
1098    }
1099  }
1100  
1101  class Google_Service_Proximitybeacon_ListDiagnosticsResponse extends Google_Collection
1102  {
1103    protected $collection_key = 'diagnostics';
1104    protected $internal_gapi_mappings = array(
1105    );
1106    protected $diagnosticsType = 'Google_Service_Proximitybeacon_Diagnostics';
1107    protected $diagnosticsDataType = 'array';
1108    public $nextPageToken;
1109  
1110  
1111    public function setDiagnostics($diagnostics)
1112    {
1113      $this->diagnostics = $diagnostics;
1114    }
1115    public function getDiagnostics()
1116    {
1117      return $this->diagnostics;
1118    }
1119    public function setNextPageToken($nextPageToken)
1120    {
1121      $this->nextPageToken = $nextPageToken;
1122    }
1123    public function getNextPageToken()
1124    {
1125      return $this->nextPageToken;
1126    }
1127  }
1128  
1129  class Google_Service_Proximitybeacon_ListNamespacesResponse extends Google_Collection
1130  {
1131    protected $collection_key = 'namespaces';
1132    protected $internal_gapi_mappings = array(
1133    );
1134    protected $namespacesType = 'Google_Service_Proximitybeacon_ProximitybeaconNamespace';
1135    protected $namespacesDataType = 'array';
1136  
1137  
1138    public function setNamespaces($namespaces)
1139    {
1140      $this->namespaces = $namespaces;
1141    }
1142    public function getNamespaces()
1143    {
1144      return $this->namespaces;
1145    }
1146  }
1147  
1148  class Google_Service_Proximitybeacon_Observation extends Google_Model
1149  {
1150    protected $internal_gapi_mappings = array(
1151    );
1152    protected $advertisedIdType = 'Google_Service_Proximitybeacon_AdvertisedId';
1153    protected $advertisedIdDataType = '';
1154    public $telemetry;
1155    public $timestampMs;
1156  
1157  
1158    public function setAdvertisedId(Google_Service_Proximitybeacon_AdvertisedId $advertisedId)
1159    {
1160      $this->advertisedId = $advertisedId;
1161    }
1162    public function getAdvertisedId()
1163    {
1164      return $this->advertisedId;
1165    }
1166    public function setTelemetry($telemetry)
1167    {
1168      $this->telemetry = $telemetry;
1169    }
1170    public function getTelemetry()
1171    {
1172      return $this->telemetry;
1173    }
1174    public function setTimestampMs($timestampMs)
1175    {
1176      $this->timestampMs = $timestampMs;
1177    }
1178    public function getTimestampMs()
1179    {
1180      return $this->timestampMs;
1181    }
1182  }
1183  
1184  class Google_Service_Proximitybeacon_ProximitybeaconNamespace extends Google_Model
1185  {
1186    protected $internal_gapi_mappings = array(
1187    );
1188    public $namespaceName;
1189    public $servingVisibility;
1190  
1191  
1192    public function setNamespaceName($namespaceName)
1193    {
1194      $this->namespaceName = $namespaceName;
1195    }
1196    public function getNamespaceName()
1197    {
1198      return $this->namespaceName;
1199    }
1200    public function setServingVisibility($servingVisibility)
1201    {
1202      $this->servingVisibility = $servingVisibility;
1203    }
1204    public function getServingVisibility()
1205    {
1206      return $this->servingVisibility;
1207    }
1208  }