Search moodle.org's
Developer Documentation

See Release Notes

  • Bug fixes for general core bugs in 4.2.x will end 22 April 2024 (12 months).
  • Bug fixes for security issues in 4.2.x will end 7 October 2024 (18 months).
  • PHP version: minimum PHP 8.0.0 Note: minimum PHP version has increased since Moodle 4.1. PHP 8.1.x is supported too.

Differences Between: [Versions 310 and 402] [Versions 311 and 402] [Versions 39 and 402] [Versions 400 and 402] [Versions 401 and 402]

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