google-apis-mybusinesslodging_v1 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4427af2a4ff19d4873ff09cc5a3318414dc9d1cdba9dd20f0ab858592982fae8
+  data.tar.gz: f68ea2de9dd509c617496de993e32f983c32a7d41dbc6a1b9926c3376dc65df2
+SHA512:
+  metadata.gz: 918d81f51e2c835c31ec0eb550c41fdf3bba8d89f6fd9305b24163a6c14052f720ae22e509b89aa1cdddbcd431f1b8db81d73354878ce736365372410cc914e2
+  data.tar.gz: 3c7a2fd4059c299ef3dca422f6ee32dba13e3bf400a5903c2740de9ec3d4b722e057d8a51af5c4c6931d9551b36a3c4013705319839313057717d1a37ddd73d7

data/.yardopts

@@ -0,0 +1,13 @@
+--hide-void-return
+--no-private
+--verbose
+--title=google-apis-mybusinesslodging_v1
+--markup-provider=redcarpet
+--markup=markdown
+--main OVERVIEW.md
+lib/google/apis/mybusinesslodging_v1/*.rb
+lib/google/apis/mybusinesslodging_v1.rb
+-
+OVERVIEW.md
+CHANGELOG.md
+LICENSE.md

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Release history for google-apis-mybusinesslodging_v1
+
+### v0.1.0 (2021-04-08)
+
+* Regenerated from discovery document revision 20210406
+* Regenerated using generator version 0.2.0
+

data/LICENSE.md

@@ -0,0 +1,202 @@
+
+                                  Apache License
+                            Version 2.0, January 2004
+                         http://www.apache.org/licenses/
+
+    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+    1. Definitions.
+
+       "License" shall mean the terms and conditions for use, reproduction,
+       and distribution as defined by Sections 1 through 9 of this document.
+
+       "Licensor" shall mean the copyright owner or entity authorized by
+       the copyright owner that is granting the License.
+
+       "Legal Entity" shall mean the union of the acting entity and all
+       other entities that control, are controlled by, or are under common
+       control with that entity. For the purposes of this definition,
+       "control" means (i) the power, direct or indirect, to cause the
+       direction or management of such entity, whether by contract or
+       otherwise, or (ii) ownership of fifty percent (50%) or more of the
+       outstanding shares, or (iii) beneficial ownership of such entity.
+
+       "You" (or "Your") shall mean an individual or Legal Entity
+       exercising permissions granted by this License.
+
+       "Source" form shall mean the preferred form for making modifications,
+       including but not limited to software source code, documentation
+       source, and configuration files.
+
+       "Object" form shall mean any form resulting from mechanical
+       transformation or translation of a Source form, including but
+       not limited to compiled object code, generated documentation,
+       and conversions to other media types.
+
+       "Work" shall mean the work of authorship, whether in Source or
+       Object form, made available under the License, as indicated by a
+       copyright notice that is included in or attached to the work
+       (an example is provided in the Appendix below).
+
+       "Derivative Works" shall mean any work, whether in Source or Object
+       form, that is based on (or derived from) the Work and for which the
+       editorial revisions, annotations, elaborations, or other modifications
+       represent, as a whole, an original work of authorship. For the purposes
+       of this License, Derivative Works shall not include works that remain
+       separable from, or merely link (or bind by name) to the interfaces of,
+       the Work and Derivative Works thereof.
+
+       "Contribution" shall mean any work of authorship, including
+       the original version of the Work and any modifications or additions
+       to that Work or Derivative Works thereof, that is intentionally
+       submitted to Licensor for inclusion in the Work by the copyright owner
+       or by an individual or Legal Entity authorized to submit on behalf of
+       the copyright owner. For the purposes of this definition, "submitted"
+       means any form of electronic, verbal, or written communication sent
+       to the Licensor or its representatives, including but not limited to
+       communication on electronic mailing lists, source code control systems,
+       and issue tracking systems that are managed by, or on behalf of, the
+       Licensor for the purpose of discussing and improving the Work, but
+       excluding communication that is conspicuously marked or otherwise
+       designated in writing by the copyright owner as "Not a Contribution."
+
+       "Contributor" shall mean Licensor and any individual or Legal Entity
+       on behalf of whom a Contribution has been received by Licensor and
+       subsequently incorporated within the Work.
+
+    2. Grant of Copyright License. Subject to the terms and conditions of
+       this License, each Contributor hereby grants to You a perpetual,
+       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+       copyright license to reproduce, prepare Derivative Works of,
+       publicly display, publicly perform, sublicense, and distribute the
+       Work and such Derivative Works in Source or Object form.
+
+    3. Grant of Patent License. Subject to the terms and conditions of
+       this License, each Contributor hereby grants to You a perpetual,
+       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+       (except as stated in this section) patent license to make, have made,
+       use, offer to sell, sell, import, and otherwise transfer the Work,
+       where such license applies only to those patent claims licensable
+       by such Contributor that are necessarily infringed by their
+       Contribution(s) alone or by combination of their Contribution(s)
+       with the Work to which such Contribution(s) was submitted. If You
+       institute patent litigation against any entity (including a
+       cross-claim or counterclaim in a lawsuit) alleging that the Work
+       or a Contribution incorporated within the Work constitutes direct
+       or contributory patent infringement, then any patent licenses
+       granted to You under this License for that Work shall terminate
+       as of the date such litigation is filed.
+
+    4. Redistribution. You may reproduce and distribute copies of the
+       Work or Derivative Works thereof in any medium, with or without
+       modifications, and in Source or Object form, provided that You
+       meet the following conditions:
+
+       (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+       (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+       (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+       (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+       You may add Your own copyright statement to Your modifications and
+       may provide additional or different license terms and conditions
+       for use, reproduction, or distribution of Your modifications, or
+       for any such Derivative Works as a whole, provided Your use,
+       reproduction, and distribution of the Work otherwise complies with
+       the conditions stated in this License.
+
+    5. Submission of Contributions. Unless You explicitly state otherwise,
+       any Contribution intentionally submitted for inclusion in the Work
+       by You to the Licensor shall be under the terms and conditions of
+       this License, without any additional terms or conditions.
+       Notwithstanding the above, nothing herein shall supersede or modify
+       the terms of any separate license agreement you may have executed
+       with Licensor regarding such Contributions.
+
+    6. Trademarks. This License does not grant permission to use the trade
+       names, trademarks, service marks, or product names of the Licensor,
+       except as required for reasonable and customary use in describing the
+       origin of the Work and reproducing the content of the NOTICE file.
+
+    7. Disclaimer of Warranty. Unless required by applicable law or
+       agreed to in writing, Licensor provides the Work (and each
+       Contributor provides its Contributions) on an "AS IS" BASIS,
+       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+       implied, including, without limitation, any warranties or conditions
+       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+       PARTICULAR PURPOSE. You are solely responsible for determining the
+       appropriateness of using or redistributing the Work and assume any
+       risks associated with Your exercise of permissions under this License.
+
+    8. Limitation of Liability. In no event and under no legal theory,
+       whether in tort (including negligence), contract, or otherwise,
+       unless required by applicable law (such as deliberate and grossly
+       negligent acts) or agreed to in writing, shall any Contributor be
+       liable to You for damages, including any direct, indirect, special,
+       incidental, or consequential damages of any character arising as a
+       result of this License or out of the use or inability to use the
+       Work (including but not limited to damages for loss of goodwill,
+       work stoppage, computer failure or malfunction, or any and all
+       other commercial damages or losses), even if such Contributor
+       has been advised of the possibility of such damages.
+
+    9. Accepting Warranty or Additional Liability. While redistributing
+       the Work or Derivative Works thereof, You may choose to offer,
+       and charge a fee for, acceptance of support, warranty, indemnity,
+       or other liability obligations and/or rights consistent with this
+       License. However, in accepting such obligations, You may act only
+       on Your own behalf and on Your sole responsibility, not on behalf
+       of any other Contributor, and only if You agree to indemnify,
+       defend, and hold each Contributor harmless for any liability
+       incurred by, or claims asserted against, such Contributor by reason
+       of your accepting any such warranty or additional liability.
+
+    END OF TERMS AND CONDITIONS
+
+    APPENDIX: How to apply the Apache License to your work.
+
+       To apply the Apache License to your work, attach the following
+       boilerplate notice, with the fields enclosed by brackets "[]"
+       replaced with your own identifying information. (Don't include
+       the brackets!)  The text should be enclosed in the appropriate
+       comment syntax for the file format. We also recommend that a
+       file or class name and description of purpose be included on the
+       same "printed page" as the copyright notice for easier
+       identification within third-party archives.
+
+    Copyright [yyyy] [name of copyright owner]
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.

data/OVERVIEW.md

@@ -0,0 +1,96 @@
+# Simple REST client for version V1 of the My Business Lodging API
+
+This is a simple client library for version V1 of the My Business Lodging API. It provides:
+
+* A client object that connects to the HTTP/JSON REST endpoint for the service.
+* Ruby objects for data structures related to the service.
+* Integration with the googleauth gem for authentication using OAuth, API keys, and service accounts.
+* Control of retry, pagination, and timeouts.
+
+Note that although this client library is supported and will continue to be updated to track changes to the service, it is otherwise considered complete and not under active development. Many Google services, especially Google Cloud Platform services, may provide a more modern client that is under more active development and improvement. See the section below titled *Which client should I use?* for more information.
+
+## Getting started
+
+### Before you begin
+
+There are a few setup steps you need to complete before you can use this library:
+
+ 1. If you don't already have a Google account, [sign up](https://www.google.com/accounts).
+ 2. If you have never created a Google APIs Console project, read about [Managing Projects](https://cloud.google.com/resource-manager/docs/creating-managing-projects) and create a project in the [Google API Console](https://console.cloud.google.com/).
+ 3. Most APIs need to be enabled for your project. [Enable it](https://console.cloud.google.com/apis/library/mybusinesslodging.googleapis.com) in the console.
+
+### Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'google-apis-mybusinesslodging_v1', '~> 0.1'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+Or install it yourself as:
+
+```
+$ gem install google-apis-mybusinesslodging_v1
+```
+
+### Creating a client object
+
+Once the gem is installed, you can load the client code and instantiate a client.
+
+```ruby
+# Load the client
+require "google/apis/mybusinesslodging_v1"
+
+# Create a client object
+client = Google::Apis::MybusinesslodgingV1::MyBusinessLodgingService.new
+
+# Authenticate calls
+client.authentication = # ... use the googleauth gem to create credentials
+```
+
+See the class reference docs for information on the methods you can call from a client.
+
+## Documentation
+
+More detailed descriptions of the Google simple REST clients are available in two documents.
+
+ *  The [Usage Guide](https://github.com/googleapis/google-api-ruby-client/blob/master/docs/usage-guide.md) discusses how to make API calls, how to use the provided data structures, and how to work the various features of the client library, including media upload and download, error handling, retries, pagination, and logging.
+ *  The [Auth Guide](https://github.com/googleapis/google-api-ruby-client/blob/master/docs/auth-guide.md) discusses authentication in the client libraries, including API keys, OAuth 2.0, service accounts, and environment variables.
+
+(Note: the above documents are written for the simple REST clients in general, and their examples may not reflect the Mybusinesslodging service in particular.)
+
+For reference information on specific calls in the My Business Lodging API, see the {Google::Apis::MybusinesslodgingV1::MyBusinessLodgingService class reference docs}.
+
+## Which client should I use?
+
+Google provides two types of Ruby API client libraries: **simple REST clients** and **modern clients**.
+
+This library, `google-apis-mybusinesslodging_v1`, is a simple REST client. You can identify these clients by their gem names, which are always in the form `google-apis-<servicename>_<serviceversion>`. The simple REST clients connect to HTTP/JSON REST endpoints and are automatically generated from service discovery documents. They support most API functionality, but their class interfaces are sometimes awkward.
+
+Modern clients are produced by a modern code generator, sometimes combined with hand-crafted functionality. Most modern clients connect to high-performance gRPC endpoints, although a few are backed by REST services. Modern clients are available for many Google services, especially Google Cloud Platform services, but do not yet support all the services covered by the simple clients.
+
+Gem names for modern clients are often of the form `google-cloud-<service_name>`. (For example, [google-cloud-pubsub](https://rubygems.org/gems/google-cloud-pubsub).) Note that most modern clients also have corresponding "versioned" gems with names like `google-cloud-<service_name>-<version>`. (For example, [google-cloud-pubsub-v1](https://rubygems.org/gems/google-cloud-pubsub-v1).) The "versioned" gems can be used directly, but often provide lower-level interfaces. In most cases, the main gem is recommended.
+
+**For most users, we recommend the modern client, if one is available.** Compared with simple clients, modern clients are generally much easier to use and more Ruby-like, support more advanced features such as streaming and long-running operations, and often provide much better performance. You may consider using a simple client instead, if a modern client is not yet available for the service you want to use, or if you are not able to use gRPC on your infrastructure.
+
+The [product documentation](https://developers.google.com/my-business/) may provide guidance regarding the preferred client library to use.
+
+## Supported Ruby versions
+
+This library is supported on Ruby 2.5+.
+
+Google provides official support for Ruby versions that are actively supported by Ruby Core -- that is, Ruby versions that are either in normal maintenance or in security maintenance, and not end of life. Currently, this means Ruby 2.5 and later. Older versions of Ruby _may_ still work, but are unsupported and not recommended. See https://www.ruby-lang.org/en/downloads/branches/ for details about the Ruby support schedule.
+
+## License
+
+This library is licensed under Apache 2.0. Full license text is available in the {file:LICENSE.md LICENSE}.
+
+## Support
+
+Please [report bugs at the project on Github](https://github.com/google/google-api-ruby-client/issues). Don't hesitate to [ask questions](http://stackoverflow.com/questions/tagged/google-api-ruby-client) about the client or APIs on [StackOverflow](http://stackoverflow.com).

data/lib/google-apis-mybusinesslodging_v1.rb

@@ -0,0 +1,15 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "google/apis/mybusinesslodging_v1"

data/lib/google/apis/mybusinesslodging_v1.rb

@@ -0,0 +1,34 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'google/apis/mybusinesslodging_v1/service.rb'
+require 'google/apis/mybusinesslodging_v1/classes.rb'
+require 'google/apis/mybusinesslodging_v1/representations.rb'
+require 'google/apis/mybusinesslodging_v1/gem_version.rb'
+
+module Google
+  module Apis
+    # My Business Lodging API
+    #
+    # The My Business Lodging API enables managing lodging business information on
+    # Google.
+    #
+    # @see https://developers.google.com/my-business/
+    module MybusinesslodgingV1
+      # Version of the My Business Lodging API this client connects to.
+      # This is NOT the gem version.
+      VERSION = 'V1'
+    end
+  end
+end

data/lib/google/apis/mybusinesslodging_v1/classes.rb

@@ -0,0 +1,4096 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'date'
+require 'google/apis/core/base_service'
+require 'google/apis/core/json_representation'
+require 'google/apis/core/hashable'
+require 'google/apis/errors'
+
+module Google
+  module Apis
+    module MybusinesslodgingV1
+      
+      # Physical adaptations made to the property in consideration of varying levels
+      # of human physical ability.
+      class Accessibility
+        include Google::Apis::Core::Hashable
+      
+        # Mobility accessible. Throughout the property there are physical adaptations to
+        # ease the stay of a person in a wheelchair, such as auto-opening doors, wide
+        # elevators, wide bathrooms or ramps.
+        # Corresponds to the JSON property `mobilityAccessible`
+        # @return [Boolean]
+        attr_accessor :mobility_accessible
+        alias_method :mobility_accessible?, :mobility_accessible
+      
+        # Mobility accessible elevator. A lift that transports people from one level to
+        # another and is built to accommodate a wheelchair-using passenger owing to the
+        # width of its doors and placement of call buttons.
+        # Corresponds to the JSON property `mobilityAccessibleElevator`
+        # @return [Boolean]
+        attr_accessor :mobility_accessible_elevator
+        alias_method :mobility_accessible_elevator?, :mobility_accessible_elevator
+      
+        # Mobility accessible elevator exception.
+        # Corresponds to the JSON property `mobilityAccessibleElevatorException`
+        # @return [String]
+        attr_accessor :mobility_accessible_elevator_exception
+      
+        # Mobility accessible exception.
+        # Corresponds to the JSON property `mobilityAccessibleException`
+        # @return [String]
+        attr_accessor :mobility_accessible_exception
+      
+        # Mobility accessible parking. The presence of a marked, designated area of
+        # prescribed size in which only registered, labeled vehicles transporting a
+        # person with physical challenges may park.
+        # Corresponds to the JSON property `mobilityAccessibleParking`
+        # @return [Boolean]
+        attr_accessor :mobility_accessible_parking
+        alias_method :mobility_accessible_parking?, :mobility_accessible_parking
+      
+        # Mobility accessible parking exception.
+        # Corresponds to the JSON property `mobilityAccessibleParkingException`
+        # @return [String]
+        attr_accessor :mobility_accessible_parking_exception
+      
+        # Mobility accessible pool. A swimming pool equipped with a mechanical chair
+        # that can be lowered and raised for the purpose of moving physically challenged
+        # guests into and out of the pool. May be powered by electricity or water. Also
+        # known as pool lift.
+        # Corresponds to the JSON property `mobilityAccessiblePool`
+        # @return [Boolean]
+        attr_accessor :mobility_accessible_pool
+        alias_method :mobility_accessible_pool?, :mobility_accessible_pool
+      
+        # Mobility accessible pool exception.
+        # Corresponds to the JSON property `mobilityAccessiblePoolException`
+        # @return [String]
+        attr_accessor :mobility_accessible_pool_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @mobility_accessible = args[:mobility_accessible] if args.key?(:mobility_accessible)
+          @mobility_accessible_elevator = args[:mobility_accessible_elevator] if args.key?(:mobility_accessible_elevator)
+          @mobility_accessible_elevator_exception = args[:mobility_accessible_elevator_exception] if args.key?(:mobility_accessible_elevator_exception)
+          @mobility_accessible_exception = args[:mobility_accessible_exception] if args.key?(:mobility_accessible_exception)
+          @mobility_accessible_parking = args[:mobility_accessible_parking] if args.key?(:mobility_accessible_parking)
+          @mobility_accessible_parking_exception = args[:mobility_accessible_parking_exception] if args.key?(:mobility_accessible_parking_exception)
+          @mobility_accessible_pool = args[:mobility_accessible_pool] if args.key?(:mobility_accessible_pool)
+          @mobility_accessible_pool_exception = args[:mobility_accessible_pool_exception] if args.key?(:mobility_accessible_pool_exception)
+        end
+      end
+      
+      # Amenities and features related to leisure and play.
+      class Activities
+        include Google::Apis::Core::Hashable
+      
+        # Beach access. The hotel property is in close proximity to a beach and offers a
+        # way to get to that beach. This can include a route to the beach such as stairs
+        # down if hotel is on a bluff, or a short trail. Not the same as beachfront (
+        # with beach access, the hotel's proximity is close to but not right on the
+        # beach).
+        # Corresponds to the JSON property `beachAccess`
+        # @return [Boolean]
+        attr_accessor :beach_access
+        alias_method :beach_access?, :beach_access
+      
+        # Beach access exception.
+        # Corresponds to the JSON property `beachAccessException`
+        # @return [String]
+        attr_accessor :beach_access_exception
+      
+        # Breach front. The hotel property is physically located on the beach alongside
+        # an ocean, sea, gulf, or bay. It is not on a lake, river, stream, or pond. The
+        # hotel is not separated from the beach by a public road allowing vehicular,
+        # pedestrian, or bicycle traffic.
+        # Corresponds to the JSON property `beachFront`
+        # @return [Boolean]
+        attr_accessor :beach_front
+        alias_method :beach_front?, :beach_front
+      
+        # Beach front exception.
+        # Corresponds to the JSON property `beachFrontException`
+        # @return [String]
+        attr_accessor :beach_front_exception
+      
+        # Bicycle rental. The hotel owns bicycles that it permits guests to borrow and
+        # use. Can be free or for a fee.
+        # Corresponds to the JSON property `bicycleRental`
+        # @return [Boolean]
+        attr_accessor :bicycle_rental
+        alias_method :bicycle_rental?, :bicycle_rental
+      
+        # Bicycle rental exception.
+        # Corresponds to the JSON property `bicycleRentalException`
+        # @return [String]
+        attr_accessor :bicycle_rental_exception
+      
+        # Boutique stores. There are stores selling clothing, jewelry, art and decor
+        # either on hotel premises or very close by. Does not refer to the hotel gift
+        # shop or convenience store.
+        # Corresponds to the JSON property `boutiqueStores`
+        # @return [Boolean]
+        attr_accessor :boutique_stores
+        alias_method :boutique_stores?, :boutique_stores
+      
+        # Boutique stores exception.
+        # Corresponds to the JSON property `boutiqueStoresException`
+        # @return [String]
+        attr_accessor :boutique_stores_exception
+      
+        # Casino. A space designated for gambling and gaming featuring croupier-run
+        # table and card games, as well as electronic slot machines. May be on hotel
+        # premises or located nearby.
+        # Corresponds to the JSON property `casino`
+        # @return [Boolean]
+        attr_accessor :casino
+        alias_method :casino?, :casino
+      
+        # Casino exception.
+        # Corresponds to the JSON property `casinoException`
+        # @return [String]
+        attr_accessor :casino_exception
+      
+        # Free bicycle rental. The hotel owns bicycles that it permits guests to borrow
+        # and use for free.
+        # Corresponds to the JSON property `freeBicycleRental`
+        # @return [Boolean]
+        attr_accessor :free_bicycle_rental
+        alias_method :free_bicycle_rental?, :free_bicycle_rental
+      
+        # Free bicycle rental exception.
+        # Corresponds to the JSON property `freeBicycleRentalException`
+        # @return [String]
+        attr_accessor :free_bicycle_rental_exception
+      
+        # Free watercraft rental. The hotel owns watercraft that it permits guests to
+        # borrow and use for free.
+        # Corresponds to the JSON property `freeWatercraftRental`
+        # @return [Boolean]
+        attr_accessor :free_watercraft_rental
+        alias_method :free_watercraft_rental?, :free_watercraft_rental
+      
+        # Free Watercraft rental exception.
+        # Corresponds to the JSON property `freeWatercraftRentalException`
+        # @return [String]
+        attr_accessor :free_watercraft_rental_exception
+      
+        # Game room. There is a room at the hotel containing electronic machines for
+        # play such as pinball, prize machines, driving simulators, and other items
+        # commonly found at a family fun center or arcade. May also include non-
+        # electronic games like pool, foosball, darts, and more. May or may not be
+        # designed for children. Also known as arcade, fun room, or family fun center.
+        # Corresponds to the JSON property `gameRoom`
+        # @return [Boolean]
+        attr_accessor :game_room
+        alias_method :game_room?, :game_room
+      
+        # Game room exception.
+        # Corresponds to the JSON property `gameRoomException`
+        # @return [String]
+        attr_accessor :game_room_exception
+      
+        # Golf. There is a golf course on hotel grounds or there is a nearby,
+        # independently run golf course that allows use by hotel guests. Can be free or
+        # for a fee.
+        # Corresponds to the JSON property `golf`
+        # @return [Boolean]
+        attr_accessor :golf
+        alias_method :golf?, :golf
+      
+        # Golf exception.
+        # Corresponds to the JSON property `golfException`
+        # @return [String]
+        attr_accessor :golf_exception
+      
+        # Horseback riding. The hotel has a horse barn onsite or an affiliation with a
+        # nearby barn to allow for guests to sit astride a horse and direct it to walk,
+        # trot, cantor, gallop and/or jump. Can be in a riding ring, on designated paths,
+        # or in the wilderness. May or may not involve instruction.
+        # Corresponds to the JSON property `horsebackRiding`
+        # @return [Boolean]
+        attr_accessor :horseback_riding
+        alias_method :horseback_riding?, :horseback_riding
+      
+        # Horseback riding exception.
+        # Corresponds to the JSON property `horsebackRidingException`
+        # @return [String]
+        attr_accessor :horseback_riding_exception
+      
+        # Nightclub. There is a room at the hotel with a bar, a dance floor, and seating
+        # where designated staffers play dance music. There may also be a designated
+        # area for the performance of live music, singing and comedy acts.
+        # Corresponds to the JSON property `nightclub`
+        # @return [Boolean]
+        attr_accessor :nightclub
+        alias_method :nightclub?, :nightclub
+      
+        # Nightclub exception.
+        # Corresponds to the JSON property `nightclubException`
+        # @return [String]
+        attr_accessor :nightclub_exception
+      
+        # Private beach. The beach which is in close proximity to the hotel is open only
+        # to guests.
+        # Corresponds to the JSON property `privateBeach`
+        # @return [Boolean]
+        attr_accessor :private_beach
+        alias_method :private_beach?, :private_beach
+      
+        # Private beach exception.
+        # Corresponds to the JSON property `privateBeachException`
+        # @return [String]
+        attr_accessor :private_beach_exception
+      
+        # Scuba. The provision for guests to dive under naturally occurring water fitted
+        # with a self-contained underwater breathing apparatus (SCUBA) for the purpose
+        # of exploring underwater life. Apparatus consists of a tank providing oxygen to
+        # the diver through a mask. Requires certification of the diver and supervision.
+        # The hotel may have the activity at its own waterfront or have an affiliation
+        # with a nearby facility. Required equipment is most often supplied to guests.
+        # Can be free or for a fee. Not snorkeling. Not done in a swimming pool.
+        # Corresponds to the JSON property `scuba`
+        # @return [Boolean]
+        attr_accessor :scuba
+        alias_method :scuba?, :scuba
+      
+        # Scuba exception.
+        # Corresponds to the JSON property `scubaException`
+        # @return [String]
+        attr_accessor :scuba_exception
+      
+        # Snorkeling. The provision for guests to participate in a recreational water
+        # activity in which swimmers wear a diving mask, a simple, shaped breathing tube
+        # and flippers/swim fins for the purpose of exploring below the surface of an
+        # ocean, gulf or lake. Does not usually require user certification or
+        # professional supervision. Equipment may or may not be available for rent or
+        # purchase. Not scuba diving.
+        # Corresponds to the JSON property `snorkeling`
+        # @return [Boolean]
+        attr_accessor :snorkeling
+        alias_method :snorkeling?, :snorkeling
+      
+        # Snorkeling exception.
+        # Corresponds to the JSON property `snorkelingException`
+        # @return [String]
+        attr_accessor :snorkeling_exception
+      
+        # Tennis. The hotel has the requisite court(s) on site or has an affiliation
+        # with a nearby facility for the purpose of providing guests with the
+        # opportunity to play a two-sided court-based game in which players use a
+        # stringed racquet to hit a ball across a net to the side of the opposing player.
+        # The court can be indoors or outdoors. Instructors, racquets and balls may or
+        # may not be provided.
+        # Corresponds to the JSON property `tennis`
+        # @return [Boolean]
+        attr_accessor :tennis
+        alias_method :tennis?, :tennis
+      
+        # Tennis exception.
+        # Corresponds to the JSON property `tennisException`
+        # @return [String]
+        attr_accessor :tennis_exception
+      
+        # Water skiing. The provision of giving guests the opportunity to be pulled
+        # across naturally occurring water while standing on skis and holding a tow rope
+        # attached to a motorboat. Can occur on hotel premises or at a nearby waterfront.
+        # Most often performed in a lake or ocean.
+        # Corresponds to the JSON property `waterSkiing`
+        # @return [Boolean]
+        attr_accessor :water_skiing
+        alias_method :water_skiing?, :water_skiing
+      
+        # Water skiing exception.
+        # Corresponds to the JSON property `waterSkiingException`
+        # @return [String]
+        attr_accessor :water_skiing_exception
+      
+        # Watercraft rental. The hotel owns water vessels that it permits guests to
+        # borrow and use. Can be free or for a fee. Watercraft may include boats, pedal
+        # boats, rowboats, sailboats, powerboats, canoes, kayaks, or personal watercraft
+        # (such as a Jet Ski).
+        # Corresponds to the JSON property `watercraftRental`
+        # @return [Boolean]
+        attr_accessor :watercraft_rental
+        alias_method :watercraft_rental?, :watercraft_rental
+      
+        # Watercraft rental exception.
+        # Corresponds to the JSON property `watercraftRentalException`
+        # @return [String]
+        attr_accessor :watercraft_rental_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @beach_access = args[:beach_access] if args.key?(:beach_access)
+          @beach_access_exception = args[:beach_access_exception] if args.key?(:beach_access_exception)
+          @beach_front = args[:beach_front] if args.key?(:beach_front)
+          @beach_front_exception = args[:beach_front_exception] if args.key?(:beach_front_exception)
+          @bicycle_rental = args[:bicycle_rental] if args.key?(:bicycle_rental)
+          @bicycle_rental_exception = args[:bicycle_rental_exception] if args.key?(:bicycle_rental_exception)
+          @boutique_stores = args[:boutique_stores] if args.key?(:boutique_stores)
+          @boutique_stores_exception = args[:boutique_stores_exception] if args.key?(:boutique_stores_exception)
+          @casino = args[:casino] if args.key?(:casino)
+          @casino_exception = args[:casino_exception] if args.key?(:casino_exception)
+          @free_bicycle_rental = args[:free_bicycle_rental] if args.key?(:free_bicycle_rental)
+          @free_bicycle_rental_exception = args[:free_bicycle_rental_exception] if args.key?(:free_bicycle_rental_exception)
+          @free_watercraft_rental = args[:free_watercraft_rental] if args.key?(:free_watercraft_rental)
+          @free_watercraft_rental_exception = args[:free_watercraft_rental_exception] if args.key?(:free_watercraft_rental_exception)
+          @game_room = args[:game_room] if args.key?(:game_room)
+          @game_room_exception = args[:game_room_exception] if args.key?(:game_room_exception)
+          @golf = args[:golf] if args.key?(:golf)
+          @golf_exception = args[:golf_exception] if args.key?(:golf_exception)
+          @horseback_riding = args[:horseback_riding] if args.key?(:horseback_riding)
+          @horseback_riding_exception = args[:horseback_riding_exception] if args.key?(:horseback_riding_exception)
+          @nightclub = args[:nightclub] if args.key?(:nightclub)
+          @nightclub_exception = args[:nightclub_exception] if args.key?(:nightclub_exception)
+          @private_beach = args[:private_beach] if args.key?(:private_beach)
+          @private_beach_exception = args[:private_beach_exception] if args.key?(:private_beach_exception)
+          @scuba = args[:scuba] if args.key?(:scuba)
+          @scuba_exception = args[:scuba_exception] if args.key?(:scuba_exception)
+          @snorkeling = args[:snorkeling] if args.key?(:snorkeling)
+          @snorkeling_exception = args[:snorkeling_exception] if args.key?(:snorkeling_exception)
+          @tennis = args[:tennis] if args.key?(:tennis)
+          @tennis_exception = args[:tennis_exception] if args.key?(:tennis_exception)
+          @water_skiing = args[:water_skiing] if args.key?(:water_skiing)
+          @water_skiing_exception = args[:water_skiing_exception] if args.key?(:water_skiing_exception)
+          @watercraft_rental = args[:watercraft_rental] if args.key?(:watercraft_rental)
+          @watercraft_rental_exception = args[:watercraft_rental_exception] if args.key?(:watercraft_rental_exception)
+        end
+      end
+      
+      # Features of the property of specific interest to the business traveler.
+      class Business
+        include Google::Apis::Core::Hashable
+      
+        # Business center. A designated room at the hotel with one or more desks and
+        # equipped with guest-use computers, printers, fax machines and/or photocopiers.
+        # May or may not be open 24/7. May or may not require a key to access. Not a
+        # meeting room or conference room.
+        # Corresponds to the JSON property `businessCenter`
+        # @return [Boolean]
+        attr_accessor :business_center
+        alias_method :business_center?, :business_center
+      
+        # Business center exception.
+        # Corresponds to the JSON property `businessCenterException`
+        # @return [String]
+        attr_accessor :business_center_exception
+      
+        # Meeting rooms. Rooms at the hotel designated for business-related gatherings.
+        # Rooms are usually equipped with tables or desks, office chairs and audio/
+        # visual facilities to allow for presentations and conference calls. Also known
+        # as conference rooms.
+        # Corresponds to the JSON property `meetingRooms`
+        # @return [Boolean]
+        attr_accessor :meeting_rooms
+        alias_method :meeting_rooms?, :meeting_rooms
+      
+        # Meeting rooms count. The number of meeting rooms at the property.
+        # Corresponds to the JSON property `meetingRoomsCount`
+        # @return [Fixnum]
+        attr_accessor :meeting_rooms_count
+      
+        # Meeting rooms count exception.
+        # Corresponds to the JSON property `meetingRoomsCountException`
+        # @return [String]
+        attr_accessor :meeting_rooms_count_exception
+      
+        # Meeting rooms exception.
+        # Corresponds to the JSON property `meetingRoomsException`
+        # @return [String]
+        attr_accessor :meeting_rooms_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @business_center = args[:business_center] if args.key?(:business_center)
+          @business_center_exception = args[:business_center_exception] if args.key?(:business_center_exception)
+          @meeting_rooms = args[:meeting_rooms] if args.key?(:meeting_rooms)
+          @meeting_rooms_count = args[:meeting_rooms_count] if args.key?(:meeting_rooms_count)
+          @meeting_rooms_count_exception = args[:meeting_rooms_count_exception] if args.key?(:meeting_rooms_count_exception)
+          @meeting_rooms_exception = args[:meeting_rooms_exception] if args.key?(:meeting_rooms_exception)
+        end
+      end
+      
+      # The ways in which the property provides guests with the ability to access the
+      # internet.
+      class Connectivity
+        include Google::Apis::Core::Hashable
+      
+        # Free wifi. The hotel offers guests wifi for free.
+        # Corresponds to the JSON property `freeWifi`
+        # @return [Boolean]
+        attr_accessor :free_wifi
+        alias_method :free_wifi?, :free_wifi
+      
+        # Free wifi exception.
+        # Corresponds to the JSON property `freeWifiException`
+        # @return [String]
+        attr_accessor :free_wifi_exception
+      
+        # Public area wifi available. Guests have the ability to wirelessly connect to
+        # the internet in the areas of the hotel accessible to anyone. Can be free or
+        # for a fee.
+        # Corresponds to the JSON property `publicAreaWifiAvailable`
+        # @return [Boolean]
+        attr_accessor :public_area_wifi_available
+        alias_method :public_area_wifi_available?, :public_area_wifi_available
+      
+        # Public area wifi available exception.
+        # Corresponds to the JSON property `publicAreaWifiAvailableException`
+        # @return [String]
+        attr_accessor :public_area_wifi_available_exception
+      
+        # Public internet terminal. An area of the hotel supplied with computers and
+        # designated for the purpose of providing guests with the ability to access the
+        # internet.
+        # Corresponds to the JSON property `publicInternetTerminal`
+        # @return [Boolean]
+        attr_accessor :public_internet_terminal
+        alias_method :public_internet_terminal?, :public_internet_terminal
+      
+        # Public internet terminal exception.
+        # Corresponds to the JSON property `publicInternetTerminalException`
+        # @return [String]
+        attr_accessor :public_internet_terminal_exception
+      
+        # Wifi available. The hotel provides the ability for guests to wirelessly
+        # connect to the internet. Can be in the public areas of the hotel and/or in the
+        # guest rooms. Can be free or for a fee.
+        # Corresponds to the JSON property `wifiAvailable`
+        # @return [Boolean]
+        attr_accessor :wifi_available
+        alias_method :wifi_available?, :wifi_available
+      
+        # Wifi available exception.
+        # Corresponds to the JSON property `wifiAvailableException`
+        # @return [String]
+        attr_accessor :wifi_available_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @free_wifi = args[:free_wifi] if args.key?(:free_wifi)
+          @free_wifi_exception = args[:free_wifi_exception] if args.key?(:free_wifi_exception)
+          @public_area_wifi_available = args[:public_area_wifi_available] if args.key?(:public_area_wifi_available)
+          @public_area_wifi_available_exception = args[:public_area_wifi_available_exception] if args.key?(:public_area_wifi_available_exception)
+          @public_internet_terminal = args[:public_internet_terminal] if args.key?(:public_internet_terminal)
+          @public_internet_terminal_exception = args[:public_internet_terminal_exception] if args.key?(:public_internet_terminal_exception)
+          @wifi_available = args[:wifi_available] if args.key?(:wifi_available)
+          @wifi_available_exception = args[:wifi_available_exception] if args.key?(:wifi_available_exception)
+        end
+      end
+      
+      # Enhanced cleaning measures implemented by the hotel during COVID-19.
+      class EnhancedCleaning
+        include Google::Apis::Core::Hashable
+      
+        # Commercial-grade disinfectant used to clean the property.
+        # Corresponds to the JSON property `commercialGradeDisinfectantCleaning`
+        # @return [Boolean]
+        attr_accessor :commercial_grade_disinfectant_cleaning
+        alias_method :commercial_grade_disinfectant_cleaning?, :commercial_grade_disinfectant_cleaning
+      
+        # Commercial grade disinfectant cleaning exception.
+        # Corresponds to the JSON property `commercialGradeDisinfectantCleaningException`
+        # @return [String]
+        attr_accessor :commercial_grade_disinfectant_cleaning_exception
+      
+        # Enhanced cleaning of common areas.
+        # Corresponds to the JSON property `commonAreasEnhancedCleaning`
+        # @return [Boolean]
+        attr_accessor :common_areas_enhanced_cleaning
+        alias_method :common_areas_enhanced_cleaning?, :common_areas_enhanced_cleaning
+      
+        # Common areas enhanced cleaning exception.
+        # Corresponds to the JSON property `commonAreasEnhancedCleaningException`
+        # @return [String]
+        attr_accessor :common_areas_enhanced_cleaning_exception
+      
+        # Employees trained in COVID-19 cleaning procedures.
+        # Corresponds to the JSON property `employeesTrainedCleaningProcedures`
+        # @return [Boolean]
+        attr_accessor :employees_trained_cleaning_procedures
+        alias_method :employees_trained_cleaning_procedures?, :employees_trained_cleaning_procedures
+      
+        # Employees trained cleaning procedures exception.
+        # Corresponds to the JSON property `employeesTrainedCleaningProceduresException`
+        # @return [String]
+        attr_accessor :employees_trained_cleaning_procedures_exception
+      
+        # Employees trained in thorough hand-washing.
+        # Corresponds to the JSON property `employeesTrainedThoroughHandWashing`
+        # @return [Boolean]
+        attr_accessor :employees_trained_thorough_hand_washing
+        alias_method :employees_trained_thorough_hand_washing?, :employees_trained_thorough_hand_washing
+      
+        # Employees trained thorough hand washing exception.
+        # Corresponds to the JSON property `employeesTrainedThoroughHandWashingException`
+        # @return [String]
+        attr_accessor :employees_trained_thorough_hand_washing_exception
+      
+        # Employees wear masks, face shields, and/or gloves.
+        # Corresponds to the JSON property `employeesWearProtectiveEquipment`
+        # @return [Boolean]
+        attr_accessor :employees_wear_protective_equipment
+        alias_method :employees_wear_protective_equipment?, :employees_wear_protective_equipment
+      
+        # Employees wear protective equipment exception.
+        # Corresponds to the JSON property `employeesWearProtectiveEquipmentException`
+        # @return [String]
+        attr_accessor :employees_wear_protective_equipment_exception
+      
+        # Enhanced cleaning of guest rooms.
+        # Corresponds to the JSON property `guestRoomsEnhancedCleaning`
+        # @return [Boolean]
+        attr_accessor :guest_rooms_enhanced_cleaning
+        alias_method :guest_rooms_enhanced_cleaning?, :guest_rooms_enhanced_cleaning
+      
+        # Guest rooms enhanced cleaning exception.
+        # Corresponds to the JSON property `guestRoomsEnhancedCleaningException`
+        # @return [String]
+        attr_accessor :guest_rooms_enhanced_cleaning_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @commercial_grade_disinfectant_cleaning = args[:commercial_grade_disinfectant_cleaning] if args.key?(:commercial_grade_disinfectant_cleaning)
+          @commercial_grade_disinfectant_cleaning_exception = args[:commercial_grade_disinfectant_cleaning_exception] if args.key?(:commercial_grade_disinfectant_cleaning_exception)
+          @common_areas_enhanced_cleaning = args[:common_areas_enhanced_cleaning] if args.key?(:common_areas_enhanced_cleaning)
+          @common_areas_enhanced_cleaning_exception = args[:common_areas_enhanced_cleaning_exception] if args.key?(:common_areas_enhanced_cleaning_exception)
+          @employees_trained_cleaning_procedures = args[:employees_trained_cleaning_procedures] if args.key?(:employees_trained_cleaning_procedures)
+          @employees_trained_cleaning_procedures_exception = args[:employees_trained_cleaning_procedures_exception] if args.key?(:employees_trained_cleaning_procedures_exception)
+          @employees_trained_thorough_hand_washing = args[:employees_trained_thorough_hand_washing] if args.key?(:employees_trained_thorough_hand_washing)
+          @employees_trained_thorough_hand_washing_exception = args[:employees_trained_thorough_hand_washing_exception] if args.key?(:employees_trained_thorough_hand_washing_exception)
+          @employees_wear_protective_equipment = args[:employees_wear_protective_equipment] if args.key?(:employees_wear_protective_equipment)
+          @employees_wear_protective_equipment_exception = args[:employees_wear_protective_equipment_exception] if args.key?(:employees_wear_protective_equipment_exception)
+          @guest_rooms_enhanced_cleaning = args[:guest_rooms_enhanced_cleaning] if args.key?(:guest_rooms_enhanced_cleaning)
+          @guest_rooms_enhanced_cleaning_exception = args[:guest_rooms_enhanced_cleaning_exception] if args.key?(:guest_rooms_enhanced_cleaning_exception)
+        end
+      end
+      
+      # Services and amenities for families and young guests.
+      class Families
+        include Google::Apis::Core::Hashable
+      
+        # Babysitting. Child care that is offered by hotel staffers or coordinated by
+        # hotel staffers with local child care professionals. Can be free or for a fee.
+        # Corresponds to the JSON property `babysitting`
+        # @return [Boolean]
+        attr_accessor :babysitting
+        alias_method :babysitting?, :babysitting
+      
+        # Babysitting exception.
+        # Corresponds to the JSON property `babysittingException`
+        # @return [String]
+        attr_accessor :babysitting_exception
+      
+        # Kids activities. Recreational options such as sports, films, crafts and games
+        # designed for the enjoyment of children and offered at the hotel. May or may
+        # not be supervised. May or may not be at a designated time or place. Cab be
+        # free or for a fee.
+        # Corresponds to the JSON property `kidsActivities`
+        # @return [Boolean]
+        attr_accessor :kids_activities
+        alias_method :kids_activities?, :kids_activities
+      
+        # Kids activities exception.
+        # Corresponds to the JSON property `kidsActivitiesException`
+        # @return [String]
+        attr_accessor :kids_activities_exception
+      
+        # Kids club. An organized program of group activities held at the hotel and
+        # designed for the enjoyment of children. Facilitated by hotel staff (or staff
+        # procured by the hotel) in an area(s) designated for the purpose of
+        # entertaining children without their parents. May include games, outings, water
+        # sports, team sports, arts and crafts, and films. Usually has set hours. Can be
+        # free or for a fee. Also known as Kids Camp or Kids program.
+        # Corresponds to the JSON property `kidsClub`
+        # @return [Boolean]
+        attr_accessor :kids_club
+        alias_method :kids_club?, :kids_club
+      
+        # Kids club exception.
+        # Corresponds to the JSON property `kidsClubException`
+        # @return [String]
+        attr_accessor :kids_club_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @babysitting = args[:babysitting] if args.key?(:babysitting)
+          @babysitting_exception = args[:babysitting_exception] if args.key?(:babysitting_exception)
+          @kids_activities = args[:kids_activities] if args.key?(:kids_activities)
+          @kids_activities_exception = args[:kids_activities_exception] if args.key?(:kids_activities_exception)
+          @kids_club = args[:kids_club] if args.key?(:kids_club)
+          @kids_club_exception = args[:kids_club_exception] if args.key?(:kids_club_exception)
+        end
+      end
+      
+      # Meals, snacks, and beverages available at the property.
+      class FoodAndDrink
+        include Google::Apis::Core::Hashable
+      
+        # Bar. A designated room, lounge or area of an on-site restaurant with seating
+        # at a counter behind which a hotel staffer takes the guest's order and provides
+        # the requested alcoholic drink. Can be indoors or outdoors. Also known as Pub.
+        # Corresponds to the JSON property `bar`
+        # @return [Boolean]
+        attr_accessor :bar
+        alias_method :bar?, :bar
+      
+        # Bar exception.
+        # Corresponds to the JSON property `barException`
+        # @return [String]
+        attr_accessor :bar_exception
+      
+        # Breakfast available. The morning meal is offered to all guests. Can be free or
+        # for a fee.
+        # Corresponds to the JSON property `breakfastAvailable`
+        # @return [Boolean]
+        attr_accessor :breakfast_available
+        alias_method :breakfast_available?, :breakfast_available
+      
+        # Breakfast available exception.
+        # Corresponds to the JSON property `breakfastAvailableException`
+        # @return [String]
+        attr_accessor :breakfast_available_exception
+      
+        # Breakfast buffet. Breakfast meal service where guests serve themselves from a
+        # variety of dishes/foods that are put out on a table.
+        # Corresponds to the JSON property `breakfastBuffet`
+        # @return [Boolean]
+        attr_accessor :breakfast_buffet
+        alias_method :breakfast_buffet?, :breakfast_buffet
+      
+        # Breakfast buffet exception.
+        # Corresponds to the JSON property `breakfastBuffetException`
+        # @return [String]
+        attr_accessor :breakfast_buffet_exception
+      
+        # Buffet. A type of meal where guests serve themselves from a variety of dishes/
+        # foods that are put out on a table. Includes lunch and/or dinner meals. A
+        # breakfast-only buffet is not sufficient.
+        # Corresponds to the JSON property `buffet`
+        # @return [Boolean]
+        attr_accessor :buffet
+        alias_method :buffet?, :buffet
+      
+        # Buffet exception.
+        # Corresponds to the JSON property `buffetException`
+        # @return [String]
+        attr_accessor :buffet_exception
+      
+        # Dinner buffet. Dinner meal service where guests serve themselves from a
+        # variety of dishes/foods that are put out on a table.
+        # Corresponds to the JSON property `dinnerBuffet`
+        # @return [Boolean]
+        attr_accessor :dinner_buffet
+        alias_method :dinner_buffet?, :dinner_buffet
+      
+        # Dinner buffet exception.
+        # Corresponds to the JSON property `dinnerBuffetException`
+        # @return [String]
+        attr_accessor :dinner_buffet_exception
+      
+        # Free breakfast. Breakfast is offered for free to all guests. Does not apply if
+        # limited to certain room packages.
+        # Corresponds to the JSON property `freeBreakfast`
+        # @return [Boolean]
+        attr_accessor :free_breakfast
+        alias_method :free_breakfast?, :free_breakfast
+      
+        # Free breakfast exception.
+        # Corresponds to the JSON property `freeBreakfastException`
+        # @return [String]
+        attr_accessor :free_breakfast_exception
+      
+        # Restaurant. A business onsite at the hotel that is open to the public as well
+        # as guests, and offers meals and beverages to consume at tables or counters.
+        # May or may not include table service. Also known as cafe, buffet, eatery. A "
+        # breakfast room" where the hotel serves breakfast only to guests (not the
+        # general public) does not count as a restaurant.
+        # Corresponds to the JSON property `restaurant`
+        # @return [Boolean]
+        attr_accessor :restaurant
+        alias_method :restaurant?, :restaurant
+      
+        # Restaurant exception.
+        # Corresponds to the JSON property `restaurantException`
+        # @return [String]
+        attr_accessor :restaurant_exception
+      
+        # Restaurants count. The number of restaurants at the hotel.
+        # Corresponds to the JSON property `restaurantsCount`
+        # @return [Fixnum]
+        attr_accessor :restaurants_count
+      
+        # Restaurants count exception.
+        # Corresponds to the JSON property `restaurantsCountException`
+        # @return [String]
+        attr_accessor :restaurants_count_exception
+      
+        # Room service. A hotel staffer delivers meals prepared onsite to a guest's room
+        # as per their request. May or may not be available during specific hours.
+        # Services should be available to all guests (not based on rate/room booked/
+        # reward program, etc).
+        # Corresponds to the JSON property `roomService`
+        # @return [Boolean]
+        attr_accessor :room_service
+        alias_method :room_service?, :room_service
+      
+        # Room service exception.
+        # Corresponds to the JSON property `roomServiceException`
+        # @return [String]
+        attr_accessor :room_service_exception
+      
+        # Table service. A restaurant in which a staff member is assigned to a guest's
+        # table to take their order, deliver and clear away food, and deliver the bill,
+        # if applicable. Also known as sit-down restaurant.
+        # Corresponds to the JSON property `tableService`
+        # @return [Boolean]
+        attr_accessor :table_service
+        alias_method :table_service?, :table_service
+      
+        # Table service exception.
+        # Corresponds to the JSON property `tableServiceException`
+        # @return [String]
+        attr_accessor :table_service_exception
+      
+        # 24hr room service. Room service is available 24 hours a day.
+        # Corresponds to the JSON property `twentyFourHourRoomService`
+        # @return [Boolean]
+        attr_accessor :twenty_four_hour_room_service
+        alias_method :twenty_four_hour_room_service?, :twenty_four_hour_room_service
+      
+        # 24hr room service exception.
+        # Corresponds to the JSON property `twentyFourHourRoomServiceException`
+        # @return [String]
+        attr_accessor :twenty_four_hour_room_service_exception
+      
+        # Vending machine. A glass-fronted mechanized cabinet displaying and dispensing
+        # snacks and beverages for purchase by coins, paper money and/or credit cards.
+        # Corresponds to the JSON property `vendingMachine`
+        # @return [Boolean]
+        attr_accessor :vending_machine
+        alias_method :vending_machine?, :vending_machine
+      
+        # Vending machine exception.
+        # Corresponds to the JSON property `vendingMachineException`
+        # @return [String]
+        attr_accessor :vending_machine_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @bar = args[:bar] if args.key?(:bar)
+          @bar_exception = args[:bar_exception] if args.key?(:bar_exception)
+          @breakfast_available = args[:breakfast_available] if args.key?(:breakfast_available)
+          @breakfast_available_exception = args[:breakfast_available_exception] if args.key?(:breakfast_available_exception)
+          @breakfast_buffet = args[:breakfast_buffet] if args.key?(:breakfast_buffet)
+          @breakfast_buffet_exception = args[:breakfast_buffet_exception] if args.key?(:breakfast_buffet_exception)
+          @buffet = args[:buffet] if args.key?(:buffet)
+          @buffet_exception = args[:buffet_exception] if args.key?(:buffet_exception)
+          @dinner_buffet = args[:dinner_buffet] if args.key?(:dinner_buffet)
+          @dinner_buffet_exception = args[:dinner_buffet_exception] if args.key?(:dinner_buffet_exception)
+          @free_breakfast = args[:free_breakfast] if args.key?(:free_breakfast)
+          @free_breakfast_exception = args[:free_breakfast_exception] if args.key?(:free_breakfast_exception)
+          @restaurant = args[:restaurant] if args.key?(:restaurant)
+          @restaurant_exception = args[:restaurant_exception] if args.key?(:restaurant_exception)
+          @restaurants_count = args[:restaurants_count] if args.key?(:restaurants_count)
+          @restaurants_count_exception = args[:restaurants_count_exception] if args.key?(:restaurants_count_exception)
+          @room_service = args[:room_service] if args.key?(:room_service)
+          @room_service_exception = args[:room_service_exception] if args.key?(:room_service_exception)
+          @table_service = args[:table_service] if args.key?(:table_service)
+          @table_service_exception = args[:table_service_exception] if args.key?(:table_service_exception)
+          @twenty_four_hour_room_service = args[:twenty_four_hour_room_service] if args.key?(:twenty_four_hour_room_service)
+          @twenty_four_hour_room_service_exception = args[:twenty_four_hour_room_service_exception] if args.key?(:twenty_four_hour_room_service_exception)
+          @vending_machine = args[:vending_machine] if args.key?(:vending_machine)
+          @vending_machine_exception = args[:vending_machine_exception] if args.key?(:vending_machine_exception)
+        end
+      end
+      
+      # Response message for LodgingService.GetGoogleUpdatedLodging
+      class GetGoogleUpdatedLodgingResponse
+        include Google::Apis::Core::Hashable
+      
+        # Required. The fields in the Lodging that have been updated by Google. Repeated
+        # field items are not individually specified.
+        # Corresponds to the JSON property `diffMask`
+        # @return [String]
+        attr_accessor :diff_mask
+      
+        # Lodging of a location that provides accomodations.
+        # Corresponds to the JSON property `lodging`
+        # @return [Google::Apis::MybusinesslodgingV1::Lodging]
+        attr_accessor :lodging
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @diff_mask = args[:diff_mask] if args.key?(:diff_mask)
+          @lodging = args[:lodging] if args.key?(:lodging)
+        end
+      end
+      
+      # Features and available amenities in the guest unit.
+      class GuestUnitFeatures
+        include Google::Apis::Core::Hashable
+      
+        # Bungalow or villa. An independent structure that is part of a hotel or resort
+        # that is rented to one party for a vacation stay. The hotel or resort may be
+        # completely comprised of bungalows or villas, or they may be one of several
+        # guestroom options. Guests in the bungalows or villas most often have the same,
+        # if not more, amenities and services offered to guests in other guestroom types.
+        # Corresponds to the JSON property `bungalowOrVilla`
+        # @return [Boolean]
+        attr_accessor :bungalow_or_villa
+        alias_method :bungalow_or_villa?, :bungalow_or_villa
+      
+        # Bungalow or villa exception.
+        # Corresponds to the JSON property `bungalowOrVillaException`
+        # @return [String]
+        attr_accessor :bungalow_or_villa_exception
+      
+        # Connecting unit available. A guestroom type that features access to an
+        # adjacent guestroom for the purpose of booking both rooms. Most often used by
+        # families who need more than one room to accommodate the number of people in
+        # their group.
+        # Corresponds to the JSON property `connectingUnitAvailable`
+        # @return [Boolean]
+        attr_accessor :connecting_unit_available
+        alias_method :connecting_unit_available?, :connecting_unit_available
+      
+        # Connecting unit available exception.
+        # Corresponds to the JSON property `connectingUnitAvailableException`
+        # @return [String]
+        attr_accessor :connecting_unit_available_exception
+      
+        # Executive floor. A floor of the hotel where the guestrooms are only bookable
+        # by members of the hotel's frequent guest membership program. Benefits of this
+        # room class include access to a designated lounge which may or may not feature
+        # free breakfast, cocktails or other perks specific to members of the program.
+        # Corresponds to the JSON property `executiveFloor`
+        # @return [Boolean]
+        attr_accessor :executive_floor
+        alias_method :executive_floor?, :executive_floor
+      
+        # Executive floor exception.
+        # Corresponds to the JSON property `executiveFloorException`
+        # @return [String]
+        attr_accessor :executive_floor_exception
+      
+        # Max adult occupants count. The total number of adult guests allowed to stay
+        # overnight in the guestroom.
+        # Corresponds to the JSON property `maxAdultOccupantsCount`
+        # @return [Fixnum]
+        attr_accessor :max_adult_occupants_count
+      
+        # Max adult occupants count exception.
+        # Corresponds to the JSON property `maxAdultOccupantsCountException`
+        # @return [String]
+        attr_accessor :max_adult_occupants_count_exception
+      
+        # Max child occupants count. The total number of children allowed to stay
+        # overnight in the room.
+        # Corresponds to the JSON property `maxChildOccupantsCount`
+        # @return [Fixnum]
+        attr_accessor :max_child_occupants_count
+      
+        # Max child occupants count exception.
+        # Corresponds to the JSON property `maxChildOccupantsCountException`
+        # @return [String]
+        attr_accessor :max_child_occupants_count_exception
+      
+        # Max occupants count. The total number of guests allowed to stay overnight in
+        # the guestroom.
+        # Corresponds to the JSON property `maxOccupantsCount`
+        # @return [Fixnum]
+        attr_accessor :max_occupants_count
+      
+        # Max occupants count exception.
+        # Corresponds to the JSON property `maxOccupantsCountException`
+        # @return [String]
+        attr_accessor :max_occupants_count_exception
+      
+        # Private home. A privately owned home (house, townhouse, apartment, cabin,
+        # bungalow etc) that may or not serve as the owner's residence, but is rented
+        # out in its entirety or by the room(s) to paying guest(s) for vacation stays.
+        # Not for lease-based, long-term residency.
+        # Corresponds to the JSON property `privateHome`
+        # @return [Boolean]
+        attr_accessor :private_home
+        alias_method :private_home?, :private_home
+      
+        # Private home exception.
+        # Corresponds to the JSON property `privateHomeException`
+        # @return [String]
+        attr_accessor :private_home_exception
+      
+        # Suite. A guestroom category that implies both a bedroom area and a separate
+        # living area. There may or may not be full walls and doors separating the two
+        # areas, but regardless, they are very distinct. Does not mean a couch or chair
+        # in a bedroom.
+        # Corresponds to the JSON property `suite`
+        # @return [Boolean]
+        attr_accessor :suite
+        alias_method :suite?, :suite
+      
+        # Suite exception.
+        # Corresponds to the JSON property `suiteException`
+        # @return [String]
+        attr_accessor :suite_exception
+      
+        # Tier. Classification of the unit based on available features/amenities. A non-
+        # standard tier is only permitted if at least one other unit type falls under
+        # the standard tier.
+        # Corresponds to the JSON property `tier`
+        # @return [String]
+        attr_accessor :tier
+      
+        # Tier exception.
+        # Corresponds to the JSON property `tierException`
+        # @return [String]
+        attr_accessor :tier_exception
+      
+        # An individual room, such as kitchen, bathroom, bedroom, within a bookable
+        # guest unit.
+        # Corresponds to the JSON property `totalLivingAreas`
+        # @return [Google::Apis::MybusinesslodgingV1::LivingArea]
+        attr_accessor :total_living_areas
+      
+        # Views available from the guest unit itself.
+        # Corresponds to the JSON property `views`
+        # @return [Google::Apis::MybusinesslodgingV1::ViewsFromUnit]
+        attr_accessor :views
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @bungalow_or_villa = args[:bungalow_or_villa] if args.key?(:bungalow_or_villa)
+          @bungalow_or_villa_exception = args[:bungalow_or_villa_exception] if args.key?(:bungalow_or_villa_exception)
+          @connecting_unit_available = args[:connecting_unit_available] if args.key?(:connecting_unit_available)
+          @connecting_unit_available_exception = args[:connecting_unit_available_exception] if args.key?(:connecting_unit_available_exception)
+          @executive_floor = args[:executive_floor] if args.key?(:executive_floor)
+          @executive_floor_exception = args[:executive_floor_exception] if args.key?(:executive_floor_exception)
+          @max_adult_occupants_count = args[:max_adult_occupants_count] if args.key?(:max_adult_occupants_count)
+          @max_adult_occupants_count_exception = args[:max_adult_occupants_count_exception] if args.key?(:max_adult_occupants_count_exception)
+          @max_child_occupants_count = args[:max_child_occupants_count] if args.key?(:max_child_occupants_count)
+          @max_child_occupants_count_exception = args[:max_child_occupants_count_exception] if args.key?(:max_child_occupants_count_exception)
+          @max_occupants_count = args[:max_occupants_count] if args.key?(:max_occupants_count)
+          @max_occupants_count_exception = args[:max_occupants_count_exception] if args.key?(:max_occupants_count_exception)
+          @private_home = args[:private_home] if args.key?(:private_home)
+          @private_home_exception = args[:private_home_exception] if args.key?(:private_home_exception)
+          @suite = args[:suite] if args.key?(:suite)
+          @suite_exception = args[:suite_exception] if args.key?(:suite_exception)
+          @tier = args[:tier] if args.key?(:tier)
+          @tier_exception = args[:tier_exception] if args.key?(:tier_exception)
+          @total_living_areas = args[:total_living_areas] if args.key?(:total_living_areas)
+          @views = args[:views] if args.key?(:views)
+        end
+      end
+      
+      # A specific type of unit primarily defined by its features.
+      class GuestUnitType
+        include Google::Apis::Core::Hashable
+      
+        # Required. Unit or room code identifiers for a single GuestUnitType. Each code
+        # must be unique within a Lodging instance.
+        # Corresponds to the JSON property `codes`
+        # @return [Array<String>]
+        attr_accessor :codes
+      
+        # Features and available amenities in the guest unit.
+        # Corresponds to the JSON property `features`
+        # @return [Google::Apis::MybusinesslodgingV1::GuestUnitFeatures]
+        attr_accessor :features
+      
+        # Required. Short, English label or name of the GuestUnitType. Target <50 chars.
+        # Corresponds to the JSON property `label`
+        # @return [String]
+        attr_accessor :label
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @codes = args[:codes] if args.key?(:codes)
+          @features = args[:features] if args.key?(:features)
+          @label = args[:label] if args.key?(:label)
+        end
+      end
+      
+      # Health and safety measures implemented by the hotel during COVID-19.
+      class HealthAndSafety
+        include Google::Apis::Core::Hashable
+      
+        # Enhanced cleaning measures implemented by the hotel during COVID-19.
+        # Corresponds to the JSON property `enhancedCleaning`
+        # @return [Google::Apis::MybusinesslodgingV1::EnhancedCleaning]
+        attr_accessor :enhanced_cleaning
+      
+        # Increased food safety measures implemented by the hotel during COVID-19.
+        # Corresponds to the JSON property `increasedFoodSafety`
+        # @return [Google::Apis::MybusinesslodgingV1::IncreasedFoodSafety]
+        attr_accessor :increased_food_safety
+      
+        # Minimized contact measures implemented by the hotel during COVID-19.
+        # Corresponds to the JSON property `minimizedContact`
+        # @return [Google::Apis::MybusinesslodgingV1::MinimizedContact]
+        attr_accessor :minimized_contact
+      
+        # Personal protection measures implemented by the hotel during COVID-19.
+        # Corresponds to the JSON property `personalProtection`
+        # @return [Google::Apis::MybusinesslodgingV1::PersonalProtection]
+        attr_accessor :personal_protection
+      
+        # Physical distancing measures implemented by the hotel during COVID-19.
+        # Corresponds to the JSON property `physicalDistancing`
+        # @return [Google::Apis::MybusinesslodgingV1::PhysicalDistancing]
+        attr_accessor :physical_distancing
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @enhanced_cleaning = args[:enhanced_cleaning] if args.key?(:enhanced_cleaning)
+          @increased_food_safety = args[:increased_food_safety] if args.key?(:increased_food_safety)
+          @minimized_contact = args[:minimized_contact] if args.key?(:minimized_contact)
+          @personal_protection = args[:personal_protection] if args.key?(:personal_protection)
+          @physical_distancing = args[:physical_distancing] if args.key?(:physical_distancing)
+        end
+      end
+      
+      # Conveniences provided in guest units to facilitate an easier, more comfortable
+      # stay.
+      class Housekeeping
+        include Google::Apis::Core::Hashable
+      
+        # Daily housekeeping. Guest units are cleaned by hotel staff daily during guest'
+        # s stay.
+        # Corresponds to the JSON property `dailyHousekeeping`
+        # @return [Boolean]
+        attr_accessor :daily_housekeeping
+        alias_method :daily_housekeeping?, :daily_housekeeping
+      
+        # Daily housekeeping exception.
+        # Corresponds to the JSON property `dailyHousekeepingException`
+        # @return [String]
+        attr_accessor :daily_housekeeping_exception
+      
+        # Housekeeping available. Guest units are cleaned by hotel staff during guest's
+        # stay. Schedule may vary from daily, weekly, or specific days of the week.
+        # Corresponds to the JSON property `housekeepingAvailable`
+        # @return [Boolean]
+        attr_accessor :housekeeping_available
+        alias_method :housekeeping_available?, :housekeeping_available
+      
+        # Housekeeping available exception.
+        # Corresponds to the JSON property `housekeepingAvailableException`
+        # @return [String]
+        attr_accessor :housekeeping_available_exception
+      
+        # Turndown service. Hotel staff enters guest units to prepare the bed for sleep
+        # use. May or may not include some light housekeeping. May or may not include an
+        # evening snack or candy. Also known as evening service.
+        # Corresponds to the JSON property `turndownService`
+        # @return [Boolean]
+        attr_accessor :turndown_service
+        alias_method :turndown_service?, :turndown_service
+      
+        # Turndown service exception.
+        # Corresponds to the JSON property `turndownServiceException`
+        # @return [String]
+        attr_accessor :turndown_service_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @daily_housekeeping = args[:daily_housekeeping] if args.key?(:daily_housekeeping)
+          @daily_housekeeping_exception = args[:daily_housekeeping_exception] if args.key?(:daily_housekeeping_exception)
+          @housekeeping_available = args[:housekeeping_available] if args.key?(:housekeeping_available)
+          @housekeeping_available_exception = args[:housekeeping_available_exception] if args.key?(:housekeeping_available_exception)
+          @turndown_service = args[:turndown_service] if args.key?(:turndown_service)
+          @turndown_service_exception = args[:turndown_service_exception] if args.key?(:turndown_service_exception)
+        end
+      end
+      
+      # Increased food safety measures implemented by the hotel during COVID-19.
+      class IncreasedFoodSafety
+        include Google::Apis::Core::Hashable
+      
+        # Additional sanitation in dining areas.
+        # Corresponds to the JSON property `diningAreasAdditionalSanitation`
+        # @return [Boolean]
+        attr_accessor :dining_areas_additional_sanitation
+        alias_method :dining_areas_additional_sanitation?, :dining_areas_additional_sanitation
+      
+        # Dining areas additional sanitation exception.
+        # Corresponds to the JSON property `diningAreasAdditionalSanitationException`
+        # @return [String]
+        attr_accessor :dining_areas_additional_sanitation_exception
+      
+        # Disposable flatware.
+        # Corresponds to the JSON property `disposableFlatware`
+        # @return [Boolean]
+        attr_accessor :disposable_flatware
+        alias_method :disposable_flatware?, :disposable_flatware
+      
+        # Disposable flatware exception.
+        # Corresponds to the JSON property `disposableFlatwareException`
+        # @return [String]
+        attr_accessor :disposable_flatware_exception
+      
+        # Additional safety measures during food prep and serving.
+        # Corresponds to the JSON property `foodPreparationAndServingAdditionalSafety`
+        # @return [Boolean]
+        attr_accessor :food_preparation_and_serving_additional_safety
+        alias_method :food_preparation_and_serving_additional_safety?, :food_preparation_and_serving_additional_safety
+      
+        # Food preparation and serving additional safety exception.
+        # Corresponds to the JSON property `foodPreparationAndServingAdditionalSafetyException`
+        # @return [String]
+        attr_accessor :food_preparation_and_serving_additional_safety_exception
+      
+        # Individually-packaged meals.
+        # Corresponds to the JSON property `individualPackagedMeals`
+        # @return [Boolean]
+        attr_accessor :individual_packaged_meals
+        alias_method :individual_packaged_meals?, :individual_packaged_meals
+      
+        # Individual packaged meals exception.
+        # Corresponds to the JSON property `individualPackagedMealsException`
+        # @return [String]
+        attr_accessor :individual_packaged_meals_exception
+      
+        # Single-use menus.
+        # Corresponds to the JSON property `singleUseFoodMenus`
+        # @return [Boolean]
+        attr_accessor :single_use_food_menus
+        alias_method :single_use_food_menus?, :single_use_food_menus
+      
+        # Single use food menus exception.
+        # Corresponds to the JSON property `singleUseFoodMenusException`
+        # @return [String]
+        attr_accessor :single_use_food_menus_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @dining_areas_additional_sanitation = args[:dining_areas_additional_sanitation] if args.key?(:dining_areas_additional_sanitation)
+          @dining_areas_additional_sanitation_exception = args[:dining_areas_additional_sanitation_exception] if args.key?(:dining_areas_additional_sanitation_exception)
+          @disposable_flatware = args[:disposable_flatware] if args.key?(:disposable_flatware)
+          @disposable_flatware_exception = args[:disposable_flatware_exception] if args.key?(:disposable_flatware_exception)
+          @food_preparation_and_serving_additional_safety = args[:food_preparation_and_serving_additional_safety] if args.key?(:food_preparation_and_serving_additional_safety)
+          @food_preparation_and_serving_additional_safety_exception = args[:food_preparation_and_serving_additional_safety_exception] if args.key?(:food_preparation_and_serving_additional_safety_exception)
+          @individual_packaged_meals = args[:individual_packaged_meals] if args.key?(:individual_packaged_meals)
+          @individual_packaged_meals_exception = args[:individual_packaged_meals_exception] if args.key?(:individual_packaged_meals_exception)
+          @single_use_food_menus = args[:single_use_food_menus] if args.key?(:single_use_food_menus)
+          @single_use_food_menus_exception = args[:single_use_food_menus_exception] if args.key?(:single_use_food_menus_exception)
+        end
+      end
+      
+      # Language spoken by at least one staff member.
+      class LanguageSpoken
+        include Google::Apis::Core::Hashable
+      
+        # Required. The BCP-47 language code for the spoken language. Currently accepted
+        # codes: ar, de, en, es, fil, fr, hi, id, it, ja, ko, nl, pt, ru, vi, yue, zh.
+        # Corresponds to the JSON property `languageCode`
+        # @return [String]
+        attr_accessor :language_code
+      
+        # At least one member of the staff can speak the language.
+        # Corresponds to the JSON property `spoken`
+        # @return [Boolean]
+        attr_accessor :spoken
+        alias_method :spoken?, :spoken
+      
+        # Spoken exception.
+        # Corresponds to the JSON property `spokenException`
+        # @return [String]
+        attr_accessor :spoken_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @language_code = args[:language_code] if args.key?(:language_code)
+          @spoken = args[:spoken] if args.key?(:spoken)
+          @spoken_exception = args[:spoken_exception] if args.key?(:spoken_exception)
+        end
+      end
+      
+      # An individual room, such as kitchen, bathroom, bedroom, within a bookable
+      # guest unit.
+      class LivingArea
+        include Google::Apis::Core::Hashable
+      
+        # Accessibility features of the living area.
+        # Corresponds to the JSON property `accessibility`
+        # @return [Google::Apis::MybusinesslodgingV1::LivingAreaAccessibility]
+        attr_accessor :accessibility
+      
+        # Information about eating features in the living area.
+        # Corresponds to the JSON property `eating`
+        # @return [Google::Apis::MybusinesslodgingV1::LivingAreaEating]
+        attr_accessor :eating
+      
+        # Features in the living area.
+        # Corresponds to the JSON property `features`
+        # @return [Google::Apis::MybusinesslodgingV1::LivingAreaFeatures]
+        attr_accessor :features
+      
+        # Information about the layout of the living area.
+        # Corresponds to the JSON property `layout`
+        # @return [Google::Apis::MybusinesslodgingV1::LivingAreaLayout]
+        attr_accessor :layout
+      
+        # Information about sleeping features in the living area.
+        # Corresponds to the JSON property `sleeping`
+        # @return [Google::Apis::MybusinesslodgingV1::LivingAreaSleeping]
+        attr_accessor :sleeping
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @accessibility = args[:accessibility] if args.key?(:accessibility)
+          @eating = args[:eating] if args.key?(:eating)
+          @features = args[:features] if args.key?(:features)
+          @layout = args[:layout] if args.key?(:layout)
+          @sleeping = args[:sleeping] if args.key?(:sleeping)
+        end
+      end
+      
+      # Accessibility features of the living area.
+      class LivingAreaAccessibility
+        include Google::Apis::Core::Hashable
+      
+        # ADA compliant unit. A guestroom designed to accommodate the physical
+        # challenges of a guest with mobility and/or auditory and/or visual issues, as
+        # determined by legislative policy. Usually features enlarged doorways, roll-in
+        # showers with seats, bathroom grab bars, and communication equipment for the
+        # hearing and sight challenged.
+        # Corresponds to the JSON property `adaCompliantUnit`
+        # @return [Boolean]
+        attr_accessor :ada_compliant_unit
+        alias_method :ada_compliant_unit?, :ada_compliant_unit
+      
+        # ADA compliant unit exception.
+        # Corresponds to the JSON property `adaCompliantUnitException`
+        # @return [String]
+        attr_accessor :ada_compliant_unit_exception
+      
+        # Hearing-accessible doorbell. A visual indicator(s) of a knock or ring at the
+        # door.
+        # Corresponds to the JSON property `hearingAccessibleDoorbell`
+        # @return [Boolean]
+        attr_accessor :hearing_accessible_doorbell
+        alias_method :hearing_accessible_doorbell?, :hearing_accessible_doorbell
+      
+        # Hearing-accessible doorbell exception.
+        # Corresponds to the JSON property `hearingAccessibleDoorbellException`
+        # @return [String]
+        attr_accessor :hearing_accessible_doorbell_exception
+      
+        # Hearing-accessible fire alarm. A device that gives warning of a fire through
+        # flashing lights.
+        # Corresponds to the JSON property `hearingAccessibleFireAlarm`
+        # @return [Boolean]
+        attr_accessor :hearing_accessible_fire_alarm
+        alias_method :hearing_accessible_fire_alarm?, :hearing_accessible_fire_alarm
+      
+        # Hearing-accessible fire alarm exception.
+        # Corresponds to the JSON property `hearingAccessibleFireAlarmException`
+        # @return [String]
+        attr_accessor :hearing_accessible_fire_alarm_exception
+      
+        # Hearing-accessible unit. A guestroom designed to accommodate the physical
+        # challenges of a guest with auditory issues.
+        # Corresponds to the JSON property `hearingAccessibleUnit`
+        # @return [Boolean]
+        attr_accessor :hearing_accessible_unit
+        alias_method :hearing_accessible_unit?, :hearing_accessible_unit
+      
+        # Hearing-accessible unit exception.
+        # Corresponds to the JSON property `hearingAccessibleUnitException`
+        # @return [String]
+        attr_accessor :hearing_accessible_unit_exception
+      
+        # Mobility-accessible bathtub. A bathtub that accomodates the physically
+        # challenged with additional railings or hand grips, a transfer seat or lift,
+        # and/or a door to enable walking into the tub.
+        # Corresponds to the JSON property `mobilityAccessibleBathtub`
+        # @return [Boolean]
+        attr_accessor :mobility_accessible_bathtub
+        alias_method :mobility_accessible_bathtub?, :mobility_accessible_bathtub
+      
+        # Mobility-accessible bathtub exception.
+        # Corresponds to the JSON property `mobilityAccessibleBathtubException`
+        # @return [String]
+        attr_accessor :mobility_accessible_bathtub_exception
+      
+        # Mobility-accessible shower. A shower with an enlarged door or access point to
+        # accommodate a wheelchair or a waterproof seat for the physically challenged.
+        # Corresponds to the JSON property `mobilityAccessibleShower`
+        # @return [Boolean]
+        attr_accessor :mobility_accessible_shower
+        alias_method :mobility_accessible_shower?, :mobility_accessible_shower
+      
+        # Mobility-accessible shower exception.
+        # Corresponds to the JSON property `mobilityAccessibleShowerException`
+        # @return [String]
+        attr_accessor :mobility_accessible_shower_exception
+      
+        # Mobility-accessible toilet. A toilet with a higher seat, grab bars, and/or a
+        # larger area around it to accommodate the physically challenged.
+        # Corresponds to the JSON property `mobilityAccessibleToilet`
+        # @return [Boolean]
+        attr_accessor :mobility_accessible_toilet
+        alias_method :mobility_accessible_toilet?, :mobility_accessible_toilet
+      
+        # Mobility-accessible toilet exception.
+        # Corresponds to the JSON property `mobilityAccessibleToiletException`
+        # @return [String]
+        attr_accessor :mobility_accessible_toilet_exception
+      
+        # Mobility-accessible unit. A guestroom designed to accommodate the physical
+        # challenges of a guest with mobility and/or auditory and/or visual issues.
+        # Usually features enlarged doorways, roll-in showers with seats, bathroom grab
+        # bars, and communication equipment for the hearing and sight challenged.
+        # Corresponds to the JSON property `mobilityAccessibleUnit`
+        # @return [Boolean]
+        attr_accessor :mobility_accessible_unit
+        alias_method :mobility_accessible_unit?, :mobility_accessible_unit
+      
+        # Mobility-accessible unit exception.
+        # Corresponds to the JSON property `mobilityAccessibleUnitException`
+        # @return [String]
+        attr_accessor :mobility_accessible_unit_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @ada_compliant_unit = args[:ada_compliant_unit] if args.key?(:ada_compliant_unit)
+          @ada_compliant_unit_exception = args[:ada_compliant_unit_exception] if args.key?(:ada_compliant_unit_exception)
+          @hearing_accessible_doorbell = args[:hearing_accessible_doorbell] if args.key?(:hearing_accessible_doorbell)
+          @hearing_accessible_doorbell_exception = args[:hearing_accessible_doorbell_exception] if args.key?(:hearing_accessible_doorbell_exception)
+          @hearing_accessible_fire_alarm = args[:hearing_accessible_fire_alarm] if args.key?(:hearing_accessible_fire_alarm)
+          @hearing_accessible_fire_alarm_exception = args[:hearing_accessible_fire_alarm_exception] if args.key?(:hearing_accessible_fire_alarm_exception)
+          @hearing_accessible_unit = args[:hearing_accessible_unit] if args.key?(:hearing_accessible_unit)
+          @hearing_accessible_unit_exception = args[:hearing_accessible_unit_exception] if args.key?(:hearing_accessible_unit_exception)
+          @mobility_accessible_bathtub = args[:mobility_accessible_bathtub] if args.key?(:mobility_accessible_bathtub)
+          @mobility_accessible_bathtub_exception = args[:mobility_accessible_bathtub_exception] if args.key?(:mobility_accessible_bathtub_exception)
+          @mobility_accessible_shower = args[:mobility_accessible_shower] if args.key?(:mobility_accessible_shower)
+          @mobility_accessible_shower_exception = args[:mobility_accessible_shower_exception] if args.key?(:mobility_accessible_shower_exception)
+          @mobility_accessible_toilet = args[:mobility_accessible_toilet] if args.key?(:mobility_accessible_toilet)
+          @mobility_accessible_toilet_exception = args[:mobility_accessible_toilet_exception] if args.key?(:mobility_accessible_toilet_exception)
+          @mobility_accessible_unit = args[:mobility_accessible_unit] if args.key?(:mobility_accessible_unit)
+          @mobility_accessible_unit_exception = args[:mobility_accessible_unit_exception] if args.key?(:mobility_accessible_unit_exception)
+        end
+      end
+      
+      # Information about eating features in the living area.
+      class LivingAreaEating
+        include Google::Apis::Core::Hashable
+      
+        # Coffee maker. An electric appliance that brews coffee by heating and forcing
+        # water through ground coffee.
+        # Corresponds to the JSON property `coffeeMaker`
+        # @return [Boolean]
+        attr_accessor :coffee_maker
+        alias_method :coffee_maker?, :coffee_maker
+      
+        # Coffee maker exception.
+        # Corresponds to the JSON property `coffeeMakerException`
+        # @return [String]
+        attr_accessor :coffee_maker_exception
+      
+        # Cookware. Kitchen pots, pans and utensils used in connection with the
+        # preparation of food.
+        # Corresponds to the JSON property `cookware`
+        # @return [Boolean]
+        attr_accessor :cookware
+        alias_method :cookware?, :cookware
+      
+        # Cookware exception.
+        # Corresponds to the JSON property `cookwareException`
+        # @return [String]
+        attr_accessor :cookware_exception
+      
+        # Dishwasher. A counter-height electrical cabinet containing racks for dirty
+        # dishware, cookware and cutlery, and a dispenser for soap built into the pull-
+        # down door. The cabinet is attached to the plumbing system to facilitate the
+        # automatic cleaning of its contents.
+        # Corresponds to the JSON property `dishwasher`
+        # @return [Boolean]
+        attr_accessor :dishwasher
+        alias_method :dishwasher?, :dishwasher
+      
+        # Dishwasher exception.
+        # Corresponds to the JSON property `dishwasherException`
+        # @return [String]
+        attr_accessor :dishwasher_exception
+      
+        # Indoor grill. Metal grates built into an indoor cooktop on which food is
+        # cooked over an open flame or electric heat source.
+        # Corresponds to the JSON property `indoorGrill`
+        # @return [Boolean]
+        attr_accessor :indoor_grill
+        alias_method :indoor_grill?, :indoor_grill
+      
+        # Indoor grill exception.
+        # Corresponds to the JSON property `indoorGrillException`
+        # @return [String]
+        attr_accessor :indoor_grill_exception
+      
+        # Kettle. A covered container with a handle and a spout used for boiling water.
+        # Corresponds to the JSON property `kettle`
+        # @return [Boolean]
+        attr_accessor :kettle
+        alias_method :kettle?, :kettle
+      
+        # Kettle exception.
+        # Corresponds to the JSON property `kettleException`
+        # @return [String]
+        attr_accessor :kettle_exception
+      
+        # Kitchen available. An area of the guestroom designated for the preparation and
+        # storage of food via the presence of a refrigerator, cook top, oven and sink,
+        # as well as cutlery, dishes and cookware. Usually includes small appliances
+        # such a coffee maker and a microwave. May or may not include an automatic
+        # dishwasher.
+        # Corresponds to the JSON property `kitchenAvailable`
+        # @return [Boolean]
+        attr_accessor :kitchen_available
+        alias_method :kitchen_available?, :kitchen_available
+      
+        # Kitchen available exception.
+        # Corresponds to the JSON property `kitchenAvailableException`
+        # @return [String]
+        attr_accessor :kitchen_available_exception
+      
+        # Microwave. An electric oven that quickly cooks and heats food by microwave
+        # energy. Smaller than a standing or wall mounted oven. Usually placed on a
+        # kitchen counter, a shelf or tabletop or mounted above a cooktop.
+        # Corresponds to the JSON property `microwave`
+        # @return [Boolean]
+        attr_accessor :microwave
+        alias_method :microwave?, :microwave
+      
+        # Microwave exception.
+        # Corresponds to the JSON property `microwaveException`
+        # @return [String]
+        attr_accessor :microwave_exception
+      
+        # Minibar. A small refrigerated cabinet in the guestroom containing bottles/cans
+        # of soft drinks, mini bottles of alcohol, and snacks. The items are most
+        # commonly available for a fee.
+        # Corresponds to the JSON property `minibar`
+        # @return [Boolean]
+        attr_accessor :minibar
+        alias_method :minibar?, :minibar
+      
+        # Minibar exception.
+        # Corresponds to the JSON property `minibarException`
+        # @return [String]
+        attr_accessor :minibar_exception
+      
+        # Outdoor grill. Metal grates on which food is cooked over an open flame or
+        # electric heat source. Part of an outdoor apparatus that supports the grates.
+        # Also known as barbecue grill or barbecue.
+        # Corresponds to the JSON property `outdoorGrill`
+        # @return [Boolean]
+        attr_accessor :outdoor_grill
+        alias_method :outdoor_grill?, :outdoor_grill
+      
+        # Outdoor grill exception.
+        # Corresponds to the JSON property `outdoorGrillException`
+        # @return [String]
+        attr_accessor :outdoor_grill_exception
+      
+        # Oven. A temperature controlled, heated metal cabinet powered by gas or
+        # electricity in which food is placed for the purpose of cooking or reheating.
+        # Corresponds to the JSON property `oven`
+        # @return [Boolean]
+        attr_accessor :oven
+        alias_method :oven?, :oven
+      
+        # Oven exception.
+        # Corresponds to the JSON property `ovenException`
+        # @return [String]
+        attr_accessor :oven_exception
+      
+        # Refrigerator. A large, climate-controlled electrical cabinet with vertical
+        # doors. Built for the purpose of chilling and storing perishable foods.
+        # Corresponds to the JSON property `refrigerator`
+        # @return [Boolean]
+        attr_accessor :refrigerator
+        alias_method :refrigerator?, :refrigerator
+      
+        # Refrigerator exception.
+        # Corresponds to the JSON property `refrigeratorException`
+        # @return [String]
+        attr_accessor :refrigerator_exception
+      
+        # Sink. A basin with a faucet attached to a water source and used for the
+        # purpose of washing and rinsing.
+        # Corresponds to the JSON property `sink`
+        # @return [Boolean]
+        attr_accessor :sink
+        alias_method :sink?, :sink
+      
+        # Sink exception.
+        # Corresponds to the JSON property `sinkException`
+        # @return [String]
+        attr_accessor :sink_exception
+      
+        # Snackbar. A small cabinet in the guestroom containing snacks. The items are
+        # most commonly available for a fee.
+        # Corresponds to the JSON property `snackbar`
+        # @return [Boolean]
+        attr_accessor :snackbar
+        alias_method :snackbar?, :snackbar
+      
+        # Snackbar exception.
+        # Corresponds to the JSON property `snackbarException`
+        # @return [String]
+        attr_accessor :snackbar_exception
+      
+        # Stove. A kitchen appliance powered by gas or electricity for the purpose of
+        # creating a flame or hot surface on which pots of food can be cooked. Also
+        # known as cooktop or hob.
+        # Corresponds to the JSON property `stove`
+        # @return [Boolean]
+        attr_accessor :stove
+        alias_method :stove?, :stove
+      
+        # Stove exception.
+        # Corresponds to the JSON property `stoveException`
+        # @return [String]
+        attr_accessor :stove_exception
+      
+        # Tea station. A small area with the supplies needed to heat water and make tea.
+        # Corresponds to the JSON property `teaStation`
+        # @return [Boolean]
+        attr_accessor :tea_station
+        alias_method :tea_station?, :tea_station
+      
+        # Tea station exception.
+        # Corresponds to the JSON property `teaStationException`
+        # @return [String]
+        attr_accessor :tea_station_exception
+      
+        # Toaster. A small, temperature controlled electric appliance with rectangular
+        # slots at the top that are lined with heated coils for the purpose of browning
+        # slices of bread products.
+        # Corresponds to the JSON property `toaster`
+        # @return [Boolean]
+        attr_accessor :toaster
+        alias_method :toaster?, :toaster
+      
+        # Toaster exception.
+        # Corresponds to the JSON property `toasterException`
+        # @return [String]
+        attr_accessor :toaster_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @coffee_maker = args[:coffee_maker] if args.key?(:coffee_maker)
+          @coffee_maker_exception = args[:coffee_maker_exception] if args.key?(:coffee_maker_exception)
+          @cookware = args[:cookware] if args.key?(:cookware)
+          @cookware_exception = args[:cookware_exception] if args.key?(:cookware_exception)
+          @dishwasher = args[:dishwasher] if args.key?(:dishwasher)
+          @dishwasher_exception = args[:dishwasher_exception] if args.key?(:dishwasher_exception)
+          @indoor_grill = args[:indoor_grill] if args.key?(:indoor_grill)
+          @indoor_grill_exception = args[:indoor_grill_exception] if args.key?(:indoor_grill_exception)
+          @kettle = args[:kettle] if args.key?(:kettle)
+          @kettle_exception = args[:kettle_exception] if args.key?(:kettle_exception)
+          @kitchen_available = args[:kitchen_available] if args.key?(:kitchen_available)
+          @kitchen_available_exception = args[:kitchen_available_exception] if args.key?(:kitchen_available_exception)
+          @microwave = args[:microwave] if args.key?(:microwave)
+          @microwave_exception = args[:microwave_exception] if args.key?(:microwave_exception)
+          @minibar = args[:minibar] if args.key?(:minibar)
+          @minibar_exception = args[:minibar_exception] if args.key?(:minibar_exception)
+          @outdoor_grill = args[:outdoor_grill] if args.key?(:outdoor_grill)
+          @outdoor_grill_exception = args[:outdoor_grill_exception] if args.key?(:outdoor_grill_exception)
+          @oven = args[:oven] if args.key?(:oven)
+          @oven_exception = args[:oven_exception] if args.key?(:oven_exception)
+          @refrigerator = args[:refrigerator] if args.key?(:refrigerator)
+          @refrigerator_exception = args[:refrigerator_exception] if args.key?(:refrigerator_exception)
+          @sink = args[:sink] if args.key?(:sink)
+          @sink_exception = args[:sink_exception] if args.key?(:sink_exception)
+          @snackbar = args[:snackbar] if args.key?(:snackbar)
+          @snackbar_exception = args[:snackbar_exception] if args.key?(:snackbar_exception)
+          @stove = args[:stove] if args.key?(:stove)
+          @stove_exception = args[:stove_exception] if args.key?(:stove_exception)
+          @tea_station = args[:tea_station] if args.key?(:tea_station)
+          @tea_station_exception = args[:tea_station_exception] if args.key?(:tea_station_exception)
+          @toaster = args[:toaster] if args.key?(:toaster)
+          @toaster_exception = args[:toaster_exception] if args.key?(:toaster_exception)
+        end
+      end
+      
+      # Features in the living area.
+      class LivingAreaFeatures
+        include Google::Apis::Core::Hashable
+      
+        # Air conditioning. An electrical machine used to cool the temperature of the
+        # guestroom.
+        # Corresponds to the JSON property `airConditioning`
+        # @return [Boolean]
+        attr_accessor :air_conditioning
+        alias_method :air_conditioning?, :air_conditioning
+      
+        # Air conditioning exception.
+        # Corresponds to the JSON property `airConditioningException`
+        # @return [String]
+        attr_accessor :air_conditioning_exception
+      
+        # Bathtub. A fixed plumbing feature set on the floor and consisting of a large
+        # container that accommodates the body of an adult for the purpose of seated
+        # bathing. Includes knobs or fixtures to control the temperature of the water, a
+        # faucet through which the water flows, and a drain that can be closed for
+        # filling and opened for draining.
+        # Corresponds to the JSON property `bathtub`
+        # @return [Boolean]
+        attr_accessor :bathtub
+        alias_method :bathtub?, :bathtub
+      
+        # Bathtub exception.
+        # Corresponds to the JSON property `bathtubException`
+        # @return [String]
+        attr_accessor :bathtub_exception
+      
+        # Bidet. A plumbing fixture attached to a toilet or a low, fixed sink designed
+        # for the purpose of washing after toilet use.
+        # Corresponds to the JSON property `bidet`
+        # @return [Boolean]
+        attr_accessor :bidet
+        alias_method :bidet?, :bidet
+      
+        # Bidet exception.
+        # Corresponds to the JSON property `bidetException`
+        # @return [String]
+        attr_accessor :bidet_exception
+      
+        # Dryer. An electrical machine designed to dry clothing.
+        # Corresponds to the JSON property `dryer`
+        # @return [Boolean]
+        attr_accessor :dryer
+        alias_method :dryer?, :dryer
+      
+        # Dryer exception.
+        # Corresponds to the JSON property `dryerException`
+        # @return [String]
+        attr_accessor :dryer_exception
+      
+        # Electronic room key. A card coded by the check-in computer that is read by the
+        # lock on the hotel guestroom door to allow for entry.
+        # Corresponds to the JSON property `electronicRoomKey`
+        # @return [Boolean]
+        attr_accessor :electronic_room_key
+        alias_method :electronic_room_key?, :electronic_room_key
+      
+        # Electronic room key exception.
+        # Corresponds to the JSON property `electronicRoomKeyException`
+        # @return [String]
+        attr_accessor :electronic_room_key_exception
+      
+        # Fireplace. A framed opening (aka hearth) at the base of a chimney in which
+        # logs or an electrical fire feature are burned to provide a relaxing ambiance
+        # or to heat the room. Often made of bricks or stone.
+        # Corresponds to the JSON property `fireplace`
+        # @return [Boolean]
+        attr_accessor :fireplace
+        alias_method :fireplace?, :fireplace
+      
+        # Fireplace exception.
+        # Corresponds to the JSON property `fireplaceException`
+        # @return [String]
+        attr_accessor :fireplace_exception
+      
+        # Hairdryer. A handheld electric appliance that blows temperature-controlled air
+        # for the purpose of drying wet hair. Can be mounted to a bathroom wall or a
+        # freestanding device stored in the guestroom's bathroom or closet.
+        # Corresponds to the JSON property `hairdryer`
+        # @return [Boolean]
+        attr_accessor :hairdryer
+        alias_method :hairdryer?, :hairdryer
+      
+        # Hairdryer exception.
+        # Corresponds to the JSON property `hairdryerException`
+        # @return [String]
+        attr_accessor :hairdryer_exception
+      
+        # Heating. An electrical machine used to warm the temperature of the guestroom.
+        # Corresponds to the JSON property `heating`
+        # @return [Boolean]
+        attr_accessor :heating
+        alias_method :heating?, :heating
+      
+        # Heating exception.
+        # Corresponds to the JSON property `heatingException`
+        # @return [String]
+        attr_accessor :heating_exception
+      
+        # In-unit safe. A strong fireproof cabinet with a programmable lock, used for
+        # the protected storage of valuables in a guestroom. Often built into a closet.
+        # Corresponds to the JSON property `inunitSafe`
+        # @return [Boolean]
+        attr_accessor :inunit_safe
+        alias_method :inunit_safe?, :inunit_safe
+      
+        # In-unit safe exception.
+        # Corresponds to the JSON property `inunitSafeException`
+        # @return [String]
+        attr_accessor :inunit_safe_exception
+      
+        # In-unit Wifi available. Guests can wirelessly connect to the Internet in the
+        # guestroom. Can be free or for a fee.
+        # Corresponds to the JSON property `inunitWifiAvailable`
+        # @return [Boolean]
+        attr_accessor :inunit_wifi_available
+        alias_method :inunit_wifi_available?, :inunit_wifi_available
+      
+        # In-unit Wifi available exception.
+        # Corresponds to the JSON property `inunitWifiAvailableException`
+        # @return [String]
+        attr_accessor :inunit_wifi_available_exception
+      
+        # Ironing equipment. A device, usually with a flat metal base, that is heated to
+        # smooth, finish, or press clothes and a flat, padded, cloth-covered surface on
+        # which the clothes are worked.
+        # Corresponds to the JSON property `ironingEquipment`
+        # @return [Boolean]
+        attr_accessor :ironing_equipment
+        alias_method :ironing_equipment?, :ironing_equipment
+      
+        # Ironing equipment exception.
+        # Corresponds to the JSON property `ironingEquipmentException`
+        # @return [String]
+        attr_accessor :ironing_equipment_exception
+      
+        # Pay per view movies. Televisions with channels that offer films that can be
+        # viewed for a fee, and have an interface to allow the viewer to accept the
+        # terms and approve payment.
+        # Corresponds to the JSON property `payPerViewMovies`
+        # @return [Boolean]
+        attr_accessor :pay_per_view_movies
+        alias_method :pay_per_view_movies?, :pay_per_view_movies
+      
+        # Pay per view movies exception.
+        # Corresponds to the JSON property `payPerViewMoviesException`
+        # @return [String]
+        attr_accessor :pay_per_view_movies_exception
+      
+        # Private bathroom. A bathroom designated for the express use of the guests
+        # staying in a specific guestroom.
+        # Corresponds to the JSON property `privateBathroom`
+        # @return [Boolean]
+        attr_accessor :private_bathroom
+        alias_method :private_bathroom?, :private_bathroom
+      
+        # Private bathroom exception.
+        # Corresponds to the JSON property `privateBathroomException`
+        # @return [String]
+        attr_accessor :private_bathroom_exception
+      
+        # Shower. A fixed plumbing fixture for standing bathing that features a tall
+        # spray spout or faucet through which water flows, a knob or knobs that control
+        # the water's temperature, and a drain in the floor.
+        # Corresponds to the JSON property `shower`
+        # @return [Boolean]
+        attr_accessor :shower
+        alias_method :shower?, :shower
+      
+        # Shower exception.
+        # Corresponds to the JSON property `showerException`
+        # @return [String]
+        attr_accessor :shower_exception
+      
+        # Toilet. A fixed bathroom feature connected to a sewer or septic system and
+        # consisting of a water-flushed bowl with a seat, as well as a device that
+        # elicites the water-flushing action. Used for the process and disposal of human
+        # waste.
+        # Corresponds to the JSON property `toilet`
+        # @return [Boolean]
+        attr_accessor :toilet
+        alias_method :toilet?, :toilet
+      
+        # Toilet exception.
+        # Corresponds to the JSON property `toiletException`
+        # @return [String]
+        attr_accessor :toilet_exception
+      
+        # TV. A television is available in the guestroom.
+        # Corresponds to the JSON property `tv`
+        # @return [Boolean]
+        attr_accessor :tv
+        alias_method :tv?, :tv
+      
+        # TV casting. A television equipped with a device through which the video
+        # entertainment accessed on a personal computer, phone or tablet can be
+        # wirelessly delivered to and viewed on the guestroom's television.
+        # Corresponds to the JSON property `tvCasting`
+        # @return [Boolean]
+        attr_accessor :tv_casting
+        alias_method :tv_casting?, :tv_casting
+      
+        # TV exception.
+        # Corresponds to the JSON property `tvCastingException`
+        # @return [String]
+        attr_accessor :tv_casting_exception
+      
+        # TV exception.
+        # Corresponds to the JSON property `tvException`
+        # @return [String]
+        attr_accessor :tv_exception
+      
+        # TV streaming. Televisions that embed a range of web-based apps to allow for
+        # watching media from those apps.
+        # Corresponds to the JSON property `tvStreaming`
+        # @return [Boolean]
+        attr_accessor :tv_streaming
+        alias_method :tv_streaming?, :tv_streaming
+      
+        # TV streaming exception.
+        # Corresponds to the JSON property `tvStreamingException`
+        # @return [String]
+        attr_accessor :tv_streaming_exception
+      
+        # Universal power adapters. A power supply for electronic devices which plugs
+        # into a wall for the purpose of converting AC to a single DC voltage. Also know
+        # as AC adapter or charger.
+        # Corresponds to the JSON property `universalPowerAdapters`
+        # @return [Boolean]
+        attr_accessor :universal_power_adapters
+        alias_method :universal_power_adapters?, :universal_power_adapters
+      
+        # Universal power adapters exception.
+        # Corresponds to the JSON property `universalPowerAdaptersException`
+        # @return [String]
+        attr_accessor :universal_power_adapters_exception
+      
+        # Washer. An electrical machine connected to a running water source designed to
+        # launder clothing.
+        # Corresponds to the JSON property `washer`
+        # @return [Boolean]
+        attr_accessor :washer
+        alias_method :washer?, :washer
+      
+        # Washer exception.
+        # Corresponds to the JSON property `washerException`
+        # @return [String]
+        attr_accessor :washer_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @air_conditioning = args[:air_conditioning] if args.key?(:air_conditioning)
+          @air_conditioning_exception = args[:air_conditioning_exception] if args.key?(:air_conditioning_exception)
+          @bathtub = args[:bathtub] if args.key?(:bathtub)
+          @bathtub_exception = args[:bathtub_exception] if args.key?(:bathtub_exception)
+          @bidet = args[:bidet] if args.key?(:bidet)
+          @bidet_exception = args[:bidet_exception] if args.key?(:bidet_exception)
+          @dryer = args[:dryer] if args.key?(:dryer)
+          @dryer_exception = args[:dryer_exception] if args.key?(:dryer_exception)
+          @electronic_room_key = args[:electronic_room_key] if args.key?(:electronic_room_key)
+          @electronic_room_key_exception = args[:electronic_room_key_exception] if args.key?(:electronic_room_key_exception)
+          @fireplace = args[:fireplace] if args.key?(:fireplace)
+          @fireplace_exception = args[:fireplace_exception] if args.key?(:fireplace_exception)
+          @hairdryer = args[:hairdryer] if args.key?(:hairdryer)
+          @hairdryer_exception = args[:hairdryer_exception] if args.key?(:hairdryer_exception)
+          @heating = args[:heating] if args.key?(:heating)
+          @heating_exception = args[:heating_exception] if args.key?(:heating_exception)
+          @inunit_safe = args[:inunit_safe] if args.key?(:inunit_safe)
+          @inunit_safe_exception = args[:inunit_safe_exception] if args.key?(:inunit_safe_exception)
+          @inunit_wifi_available = args[:inunit_wifi_available] if args.key?(:inunit_wifi_available)
+          @inunit_wifi_available_exception = args[:inunit_wifi_available_exception] if args.key?(:inunit_wifi_available_exception)
+          @ironing_equipment = args[:ironing_equipment] if args.key?(:ironing_equipment)
+          @ironing_equipment_exception = args[:ironing_equipment_exception] if args.key?(:ironing_equipment_exception)
+          @pay_per_view_movies = args[:pay_per_view_movies] if args.key?(:pay_per_view_movies)
+          @pay_per_view_movies_exception = args[:pay_per_view_movies_exception] if args.key?(:pay_per_view_movies_exception)
+          @private_bathroom = args[:private_bathroom] if args.key?(:private_bathroom)
+          @private_bathroom_exception = args[:private_bathroom_exception] if args.key?(:private_bathroom_exception)
+          @shower = args[:shower] if args.key?(:shower)
+          @shower_exception = args[:shower_exception] if args.key?(:shower_exception)
+          @toilet = args[:toilet] if args.key?(:toilet)
+          @toilet_exception = args[:toilet_exception] if args.key?(:toilet_exception)
+          @tv = args[:tv] if args.key?(:tv)
+          @tv_casting = args[:tv_casting] if args.key?(:tv_casting)
+          @tv_casting_exception = args[:tv_casting_exception] if args.key?(:tv_casting_exception)
+          @tv_exception = args[:tv_exception] if args.key?(:tv_exception)
+          @tv_streaming = args[:tv_streaming] if args.key?(:tv_streaming)
+          @tv_streaming_exception = args[:tv_streaming_exception] if args.key?(:tv_streaming_exception)
+          @universal_power_adapters = args[:universal_power_adapters] if args.key?(:universal_power_adapters)
+          @universal_power_adapters_exception = args[:universal_power_adapters_exception] if args.key?(:universal_power_adapters_exception)
+          @washer = args[:washer] if args.key?(:washer)
+          @washer_exception = args[:washer_exception] if args.key?(:washer_exception)
+        end
+      end
+      
+      # Information about the layout of the living area.
+      class LivingAreaLayout
+        include Google::Apis::Core::Hashable
+      
+        # Balcony. An outdoor platform attached to a building and surrounded by a short
+        # wall, fence or other safety railing. The balcony is accessed through a door in
+        # a guestroom or suite and is for use by the guest staying in that room. May or
+        # may not include seating or outdoor furniture. Is not located on the ground
+        # floor. Also lanai.
+        # Corresponds to the JSON property `balcony`
+        # @return [Boolean]
+        attr_accessor :balcony
+        alias_method :balcony?, :balcony
+      
+        # Balcony exception.
+        # Corresponds to the JSON property `balconyException`
+        # @return [String]
+        attr_accessor :balcony_exception
+      
+        # Living area sq meters. The measurement in meters of the area of a guestroom's
+        # living space.
+        # Corresponds to the JSON property `livingAreaSqMeters`
+        # @return [Float]
+        attr_accessor :living_area_sq_meters
+      
+        # Living area sq meters exception.
+        # Corresponds to the JSON property `livingAreaSqMetersException`
+        # @return [String]
+        attr_accessor :living_area_sq_meters_exception
+      
+        # Loft. A three-walled upper area accessed by stairs or a ladder that overlooks
+        # the lower area of a room.
+        # Corresponds to the JSON property `loft`
+        # @return [Boolean]
+        attr_accessor :loft
+        alias_method :loft?, :loft
+      
+        # Loft exception.
+        # Corresponds to the JSON property `loftException`
+        # @return [String]
+        attr_accessor :loft_exception
+      
+        # Non smoking. A guestroom in which the smoking of cigarettes, cigars and pipes
+        # is prohibited.
+        # Corresponds to the JSON property `nonSmoking`
+        # @return [Boolean]
+        attr_accessor :non_smoking
+        alias_method :non_smoking?, :non_smoking
+      
+        # Non smoking exception.
+        # Corresponds to the JSON property `nonSmokingException`
+        # @return [String]
+        attr_accessor :non_smoking_exception
+      
+        # Patio. A paved, outdoor area with seating attached to and accessed through a
+        # ground-floor guestroom for use by the occupants of the guestroom.
+        # Corresponds to the JSON property `patio`
+        # @return [Boolean]
+        attr_accessor :patio
+        alias_method :patio?, :patio
+      
+        # Patio exception.
+        # Corresponds to the JSON property `patioException`
+        # @return [String]
+        attr_accessor :patio_exception
+      
+        # Stairs. There are steps leading from one level or story to another in the unit.
+        # Corresponds to the JSON property `stairs`
+        # @return [Boolean]
+        attr_accessor :stairs
+        alias_method :stairs?, :stairs
+      
+        # Stairs exception.
+        # Corresponds to the JSON property `stairsException`
+        # @return [String]
+        attr_accessor :stairs_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @balcony = args[:balcony] if args.key?(:balcony)
+          @balcony_exception = args[:balcony_exception] if args.key?(:balcony_exception)
+          @living_area_sq_meters = args[:living_area_sq_meters] if args.key?(:living_area_sq_meters)
+          @living_area_sq_meters_exception = args[:living_area_sq_meters_exception] if args.key?(:living_area_sq_meters_exception)
+          @loft = args[:loft] if args.key?(:loft)
+          @loft_exception = args[:loft_exception] if args.key?(:loft_exception)
+          @non_smoking = args[:non_smoking] if args.key?(:non_smoking)
+          @non_smoking_exception = args[:non_smoking_exception] if args.key?(:non_smoking_exception)
+          @patio = args[:patio] if args.key?(:patio)
+          @patio_exception = args[:patio_exception] if args.key?(:patio_exception)
+          @stairs = args[:stairs] if args.key?(:stairs)
+          @stairs_exception = args[:stairs_exception] if args.key?(:stairs_exception)
+        end
+      end
+      
+      # Information about sleeping features in the living area.
+      class LivingAreaSleeping
+        include Google::Apis::Core::Hashable
+      
+        # Beds count. The number of permanent beds present in a guestroom. Does not
+        # include rollaway beds, cribs or sofabeds.
+        # Corresponds to the JSON property `bedsCount`
+        # @return [Fixnum]
+        attr_accessor :beds_count
+      
+        # Beds count exception.
+        # Corresponds to the JSON property `bedsCountException`
+        # @return [String]
+        attr_accessor :beds_count_exception
+      
+        # Bunk beds count. The number of furniture pieces in which one framed mattress
+        # is fixed directly above another by means of a physical frame. This allows one
+        # person(s) to sleep in the bottom bunk and one person(s) to sleep in the top
+        # bunk. Also known as double decker bed.
+        # Corresponds to the JSON property `bunkBedsCount`
+        # @return [Fixnum]
+        attr_accessor :bunk_beds_count
+      
+        # Bunk beds count exception.
+        # Corresponds to the JSON property `bunkBedsCountException`
+        # @return [String]
+        attr_accessor :bunk_beds_count_exception
+      
+        # Cribs count. The number of small beds for an infant or toddler that the
+        # guestroom can obtain. The bed is surrounded by a high railing to prevent the
+        # child from falling or climbing out of the bed
+        # Corresponds to the JSON property `cribsCount`
+        # @return [Fixnum]
+        attr_accessor :cribs_count
+      
+        # Cribs count exception.
+        # Corresponds to the JSON property `cribsCountException`
+        # @return [String]
+        attr_accessor :cribs_count_exception
+      
+        # Double beds count. The number of medium beds measuring 53"W x 75"L (135cm x
+        # 191cm). Also known as full size bed.
+        # Corresponds to the JSON property `doubleBedsCount`
+        # @return [Fixnum]
+        attr_accessor :double_beds_count
+      
+        # Double beds count exception.
+        # Corresponds to the JSON property `doubleBedsCountException`
+        # @return [String]
+        attr_accessor :double_beds_count_exception
+      
+        # Feather pillows. The option for guests to obtain bed pillows that are stuffed
+        # with the feathers and down of ducks or geese.
+        # Corresponds to the JSON property `featherPillows`
+        # @return [Boolean]
+        attr_accessor :feather_pillows
+        alias_method :feather_pillows?, :feather_pillows
+      
+        # Feather pillows exception.
+        # Corresponds to the JSON property `featherPillowsException`
+        # @return [String]
+        attr_accessor :feather_pillows_exception
+      
+        # Hypoallergenic bedding. Bedding such as linens, pillows, mattress covers and/
+        # or mattresses that are made of materials known to be resistant to allergens
+        # such as mold, dust and dander.
+        # Corresponds to the JSON property `hypoallergenicBedding`
+        # @return [Boolean]
+        attr_accessor :hypoallergenic_bedding
+        alias_method :hypoallergenic_bedding?, :hypoallergenic_bedding
+      
+        # Hypoallergenic bedding exception.
+        # Corresponds to the JSON property `hypoallergenicBeddingException`
+        # @return [String]
+        attr_accessor :hypoallergenic_bedding_exception
+      
+        # King beds count. The number of large beds measuring 76"W x 80"L (193cm x 102cm)
+        # . Most often meant to accompany two people. Includes California king and super
+        # king.
+        # Corresponds to the JSON property `kingBedsCount`
+        # @return [Fixnum]
+        attr_accessor :king_beds_count
+      
+        # King beds count exception.
+        # Corresponds to the JSON property `kingBedsCountException`
+        # @return [String]
+        attr_accessor :king_beds_count_exception
+      
+        # Memory foam pillows. The option for guests to obtain bed pillows that are
+        # stuffed with a man-made foam that responds to body heat by conforming to the
+        # body closely, and then recovers its shape when the pillow cools down.
+        # Corresponds to the JSON property `memoryFoamPillows`
+        # @return [Boolean]
+        attr_accessor :memory_foam_pillows
+        alias_method :memory_foam_pillows?, :memory_foam_pillows
+      
+        # Memory foam pillows exception.
+        # Corresponds to the JSON property `memoryFoamPillowsException`
+        # @return [String]
+        attr_accessor :memory_foam_pillows_exception
+      
+        # Other beds count. The number of beds that are not standard mattress and
+        # boxspring setups such as Japanese tatami mats, trundle beds, air mattresses
+        # and cots.
+        # Corresponds to the JSON property `otherBedsCount`
+        # @return [Fixnum]
+        attr_accessor :other_beds_count
+      
+        # Other beds count exception.
+        # Corresponds to the JSON property `otherBedsCountException`
+        # @return [String]
+        attr_accessor :other_beds_count_exception
+      
+        # Queen beds count. The number of medium-large beds measuring 60"W x 80"L (152cm
+        # x 102cm).
+        # Corresponds to the JSON property `queenBedsCount`
+        # @return [Fixnum]
+        attr_accessor :queen_beds_count
+      
+        # Queen beds count exception.
+        # Corresponds to the JSON property `queenBedsCountException`
+        # @return [String]
+        attr_accessor :queen_beds_count_exception
+      
+        # Roll away beds count. The number of mattresses on wheeled frames that can be
+        # folded in half and rolled away for easy storage that the guestroom can obtain
+        # upon request.
+        # Corresponds to the JSON property `rollAwayBedsCount`
+        # @return [Fixnum]
+        attr_accessor :roll_away_beds_count
+      
+        # Roll away beds count exception.
+        # Corresponds to the JSON property `rollAwayBedsCountException`
+        # @return [String]
+        attr_accessor :roll_away_beds_count_exception
+      
+        # Single or twin count beds. The number of smaller beds measuring 38"W x 75"L (
+        # 97cm x 191cm) that can accommodate one adult.
+        # Corresponds to the JSON property `singleOrTwinBedsCount`
+        # @return [Fixnum]
+        attr_accessor :single_or_twin_beds_count
+      
+        # Single or twin beds count exception.
+        # Corresponds to the JSON property `singleOrTwinBedsCountException`
+        # @return [String]
+        attr_accessor :single_or_twin_beds_count_exception
+      
+        # Sofa beds count. The number of specially designed sofas that can be made to
+        # serve as a bed by lowering its hinged upholstered back to horizontal position
+        # or by pulling out a concealed mattress.
+        # Corresponds to the JSON property `sofaBedsCount`
+        # @return [Fixnum]
+        attr_accessor :sofa_beds_count
+      
+        # Sofa beds count exception.
+        # Corresponds to the JSON property `sofaBedsCountException`
+        # @return [String]
+        attr_accessor :sofa_beds_count_exception
+      
+        # Synthetic pillows. The option for guests to obtain bed pillows stuffed with
+        # polyester material crafted to reproduce the feel of a pillow stuffed with down
+        # and feathers.
+        # Corresponds to the JSON property `syntheticPillows`
+        # @return [Boolean]
+        attr_accessor :synthetic_pillows
+        alias_method :synthetic_pillows?, :synthetic_pillows
+      
+        # Synthetic pillows exception.
+        # Corresponds to the JSON property `syntheticPillowsException`
+        # @return [String]
+        attr_accessor :synthetic_pillows_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @beds_count = args[:beds_count] if args.key?(:beds_count)
+          @beds_count_exception = args[:beds_count_exception] if args.key?(:beds_count_exception)
+          @bunk_beds_count = args[:bunk_beds_count] if args.key?(:bunk_beds_count)
+          @bunk_beds_count_exception = args[:bunk_beds_count_exception] if args.key?(:bunk_beds_count_exception)
+          @cribs_count = args[:cribs_count] if args.key?(:cribs_count)
+          @cribs_count_exception = args[:cribs_count_exception] if args.key?(:cribs_count_exception)
+          @double_beds_count = args[:double_beds_count] if args.key?(:double_beds_count)
+          @double_beds_count_exception = args[:double_beds_count_exception] if args.key?(:double_beds_count_exception)
+          @feather_pillows = args[:feather_pillows] if args.key?(:feather_pillows)
+          @feather_pillows_exception = args[:feather_pillows_exception] if args.key?(:feather_pillows_exception)
+          @hypoallergenic_bedding = args[:hypoallergenic_bedding] if args.key?(:hypoallergenic_bedding)
+          @hypoallergenic_bedding_exception = args[:hypoallergenic_bedding_exception] if args.key?(:hypoallergenic_bedding_exception)
+          @king_beds_count = args[:king_beds_count] if args.key?(:king_beds_count)
+          @king_beds_count_exception = args[:king_beds_count_exception] if args.key?(:king_beds_count_exception)
+          @memory_foam_pillows = args[:memory_foam_pillows] if args.key?(:memory_foam_pillows)
+          @memory_foam_pillows_exception = args[:memory_foam_pillows_exception] if args.key?(:memory_foam_pillows_exception)
+          @other_beds_count = args[:other_beds_count] if args.key?(:other_beds_count)
+          @other_beds_count_exception = args[:other_beds_count_exception] if args.key?(:other_beds_count_exception)
+          @queen_beds_count = args[:queen_beds_count] if args.key?(:queen_beds_count)
+          @queen_beds_count_exception = args[:queen_beds_count_exception] if args.key?(:queen_beds_count_exception)
+          @roll_away_beds_count = args[:roll_away_beds_count] if args.key?(:roll_away_beds_count)
+          @roll_away_beds_count_exception = args[:roll_away_beds_count_exception] if args.key?(:roll_away_beds_count_exception)
+          @single_or_twin_beds_count = args[:single_or_twin_beds_count] if args.key?(:single_or_twin_beds_count)
+          @single_or_twin_beds_count_exception = args[:single_or_twin_beds_count_exception] if args.key?(:single_or_twin_beds_count_exception)
+          @sofa_beds_count = args[:sofa_beds_count] if args.key?(:sofa_beds_count)
+          @sofa_beds_count_exception = args[:sofa_beds_count_exception] if args.key?(:sofa_beds_count_exception)
+          @synthetic_pillows = args[:synthetic_pillows] if args.key?(:synthetic_pillows)
+          @synthetic_pillows_exception = args[:synthetic_pillows_exception] if args.key?(:synthetic_pillows_exception)
+        end
+      end
+      
+      # Lodging of a location that provides accomodations.
+      class Lodging
+        include Google::Apis::Core::Hashable
+      
+        # Physical adaptations made to the property in consideration of varying levels
+        # of human physical ability.
+        # Corresponds to the JSON property `accessibility`
+        # @return [Google::Apis::MybusinesslodgingV1::Accessibility]
+        attr_accessor :accessibility
+      
+        # Amenities and features related to leisure and play.
+        # Corresponds to the JSON property `activities`
+        # @return [Google::Apis::MybusinesslodgingV1::Activities]
+        attr_accessor :activities
+      
+        # Features and available amenities in the guest unit.
+        # Corresponds to the JSON property `allUnits`
+        # @return [Google::Apis::MybusinesslodgingV1::GuestUnitFeatures]
+        attr_accessor :all_units
+      
+        # Features of the property of specific interest to the business traveler.
+        # Corresponds to the JSON property `business`
+        # @return [Google::Apis::MybusinesslodgingV1::Business]
+        attr_accessor :business
+      
+        # An individual room, such as kitchen, bathroom, bedroom, within a bookable
+        # guest unit.
+        # Corresponds to the JSON property `commonLivingArea`
+        # @return [Google::Apis::MybusinesslodgingV1::LivingArea]
+        attr_accessor :common_living_area
+      
+        # The ways in which the property provides guests with the ability to access the
+        # internet.
+        # Corresponds to the JSON property `connectivity`
+        # @return [Google::Apis::MybusinesslodgingV1::Connectivity]
+        attr_accessor :connectivity
+      
+        # Services and amenities for families and young guests.
+        # Corresponds to the JSON property `families`
+        # @return [Google::Apis::MybusinesslodgingV1::Families]
+        attr_accessor :families
+      
+        # Meals, snacks, and beverages available at the property.
+        # Corresponds to the JSON property `foodAndDrink`
+        # @return [Google::Apis::MybusinesslodgingV1::FoodAndDrink]
+        attr_accessor :food_and_drink
+      
+        # Individual GuestUnitTypes that are available in this Lodging.
+        # Corresponds to the JSON property `guestUnits`
+        # @return [Array<Google::Apis::MybusinesslodgingV1::GuestUnitType>]
+        attr_accessor :guest_units
+      
+        # Health and safety measures implemented by the hotel during COVID-19.
+        # Corresponds to the JSON property `healthAndSafety`
+        # @return [Google::Apis::MybusinesslodgingV1::HealthAndSafety]
+        attr_accessor :health_and_safety
+      
+        # Conveniences provided in guest units to facilitate an easier, more comfortable
+        # stay.
+        # Corresponds to the JSON property `housekeeping`
+        # @return [Google::Apis::MybusinesslodgingV1::Housekeeping]
+        attr_accessor :housekeeping
+      
+        # Metadata for the Lodging.
+        # Corresponds to the JSON property `metadata`
+        # @return [Google::Apis::MybusinesslodgingV1::LodgingMetadata]
+        attr_accessor :metadata
+      
+        # Required. Google identifier for this location in the form: `locations/`
+        # location_id`/lodging`
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # Parking options at the property.
+        # Corresponds to the JSON property `parking`
+        # @return [Google::Apis::MybusinesslodgingV1::Parking]
+        attr_accessor :parking
+      
+        # Policies regarding guest-owned animals.
+        # Corresponds to the JSON property `pets`
+        # @return [Google::Apis::MybusinesslodgingV1::Pets]
+        attr_accessor :pets
+      
+        # Property rules that impact guests.
+        # Corresponds to the JSON property `policies`
+        # @return [Google::Apis::MybusinesslodgingV1::Policies]
+        attr_accessor :policies
+      
+        # Swimming pool or recreational water facilities available at the hotel.
+        # Corresponds to the JSON property `pools`
+        # @return [Google::Apis::MybusinesslodgingV1::Pools]
+        attr_accessor :pools
+      
+        # General factual information about the property's physical structure and
+        # important dates.
+        # Corresponds to the JSON property `property`
+        # @return [Google::Apis::MybusinesslodgingV1::Property]
+        attr_accessor :property
+      
+        # Conveniences or help provided by the property to facilitate an easier, more
+        # comfortable stay.
+        # Corresponds to the JSON property `services`
+        # @return [Google::Apis::MybusinesslodgingV1::Services]
+        attr_accessor :services
+      
+        # Features and available amenities in the guest unit.
+        # Corresponds to the JSON property `someUnits`
+        # @return [Google::Apis::MybusinesslodgingV1::GuestUnitFeatures]
+        attr_accessor :some_units
+      
+        # Vehicles or vehicular services facilitated or owned by the property.
+        # Corresponds to the JSON property `transportation`
+        # @return [Google::Apis::MybusinesslodgingV1::Transportation]
+        attr_accessor :transportation
+      
+        # Guest facilities at the property to promote or maintain health, beauty, and
+        # fitness.
+        # Corresponds to the JSON property `wellness`
+        # @return [Google::Apis::MybusinesslodgingV1::Wellness]
+        attr_accessor :wellness
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @accessibility = args[:accessibility] if args.key?(:accessibility)
+          @activities = args[:activities] if args.key?(:activities)
+          @all_units = args[:all_units] if args.key?(:all_units)
+          @business = args[:business] if args.key?(:business)
+          @common_living_area = args[:common_living_area] if args.key?(:common_living_area)
+          @connectivity = args[:connectivity] if args.key?(:connectivity)
+          @families = args[:families] if args.key?(:families)
+          @food_and_drink = args[:food_and_drink] if args.key?(:food_and_drink)
+          @guest_units = args[:guest_units] if args.key?(:guest_units)
+          @health_and_safety = args[:health_and_safety] if args.key?(:health_and_safety)
+          @housekeeping = args[:housekeeping] if args.key?(:housekeeping)
+          @metadata = args[:metadata] if args.key?(:metadata)
+          @name = args[:name] if args.key?(:name)
+          @parking = args[:parking] if args.key?(:parking)
+          @pets = args[:pets] if args.key?(:pets)
+          @policies = args[:policies] if args.key?(:policies)
+          @pools = args[:pools] if args.key?(:pools)
+          @property = args[:property] if args.key?(:property)
+          @services = args[:services] if args.key?(:services)
+          @some_units = args[:some_units] if args.key?(:some_units)
+          @transportation = args[:transportation] if args.key?(:transportation)
+          @wellness = args[:wellness] if args.key?(:wellness)
+        end
+      end
+      
+      # Metadata for the Lodging.
+      class LodgingMetadata
+        include Google::Apis::Core::Hashable
+      
+        # Required. The latest time at which the Lodging data is asserted to be true in
+        # the real world. This is not necessarily the time at which the request is made.
+        # Corresponds to the JSON property `updateTime`
+        # @return [String]
+        attr_accessor :update_time
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @update_time = args[:update_time] if args.key?(:update_time)
+        end
+      end
+      
+      # Minimized contact measures implemented by the hotel during COVID-19.
+      class MinimizedContact
+        include Google::Apis::Core::Hashable
+      
+        # No-contact check-in and check-out.
+        # Corresponds to the JSON property `contactlessCheckinCheckout`
+        # @return [Boolean]
+        attr_accessor :contactless_checkin_checkout
+        alias_method :contactless_checkin_checkout?, :contactless_checkin_checkout
+      
+        # Contactless check-in check-out exception.
+        # Corresponds to the JSON property `contactlessCheckinCheckoutException`
+        # @return [String]
+        attr_accessor :contactless_checkin_checkout_exception
+      
+        # Keyless mobile entry to guest rooms.
+        # Corresponds to the JSON property `digitalGuestRoomKeys`
+        # @return [Boolean]
+        attr_accessor :digital_guest_room_keys
+        alias_method :digital_guest_room_keys?, :digital_guest_room_keys
+      
+        # Digital guest room keys exception.
+        # Corresponds to the JSON property `digitalGuestRoomKeysException`
+        # @return [String]
+        attr_accessor :digital_guest_room_keys_exception
+      
+        # Housekeeping scheduled by request only.
+        # Corresponds to the JSON property `housekeepingScheduledRequestOnly`
+        # @return [Boolean]
+        attr_accessor :housekeeping_scheduled_request_only
+        alias_method :housekeeping_scheduled_request_only?, :housekeeping_scheduled_request_only
+      
+        # Housekeeping scheduled request only exception.
+        # Corresponds to the JSON property `housekeepingScheduledRequestOnlyException`
+        # @return [String]
+        attr_accessor :housekeeping_scheduled_request_only_exception
+      
+        # High-touch items, such as magazines, removed from common areas.
+        # Corresponds to the JSON property `noHighTouchItemsCommonAreas`
+        # @return [Boolean]
+        attr_accessor :no_high_touch_items_common_areas
+        alias_method :no_high_touch_items_common_areas?, :no_high_touch_items_common_areas
+      
+        # No high touch items common areas exception.
+        # Corresponds to the JSON property `noHighTouchItemsCommonAreasException`
+        # @return [String]
+        attr_accessor :no_high_touch_items_common_areas_exception
+      
+        # High-touch items, such as decorative pillows, removed from guest rooms.
+        # Corresponds to the JSON property `noHighTouchItemsGuestRooms`
+        # @return [Boolean]
+        attr_accessor :no_high_touch_items_guest_rooms
+        alias_method :no_high_touch_items_guest_rooms?, :no_high_touch_items_guest_rooms
+      
+        # No high touch items guest rooms exception.
+        # Corresponds to the JSON property `noHighTouchItemsGuestRoomsException`
+        # @return [String]
+        attr_accessor :no_high_touch_items_guest_rooms_exception
+      
+        # Plastic key cards are disinfected or discarded.
+        # Corresponds to the JSON property `plasticKeycardsDisinfected`
+        # @return [Boolean]
+        attr_accessor :plastic_keycards_disinfected
+        alias_method :plastic_keycards_disinfected?, :plastic_keycards_disinfected
+      
+        # Plastic keycards disinfected exception.
+        # Corresponds to the JSON property `plasticKeycardsDisinfectedException`
+        # @return [String]
+        attr_accessor :plastic_keycards_disinfected_exception
+      
+        # Buffer maintained between room bookings.
+        # Corresponds to the JSON property `roomBookingsBuffer`
+        # @return [Boolean]
+        attr_accessor :room_bookings_buffer
+        alias_method :room_bookings_buffer?, :room_bookings_buffer
+      
+        # Room bookings buffer exception.
+        # Corresponds to the JSON property `roomBookingsBufferException`
+        # @return [String]
+        attr_accessor :room_bookings_buffer_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @contactless_checkin_checkout = args[:contactless_checkin_checkout] if args.key?(:contactless_checkin_checkout)
+          @contactless_checkin_checkout_exception = args[:contactless_checkin_checkout_exception] if args.key?(:contactless_checkin_checkout_exception)
+          @digital_guest_room_keys = args[:digital_guest_room_keys] if args.key?(:digital_guest_room_keys)
+          @digital_guest_room_keys_exception = args[:digital_guest_room_keys_exception] if args.key?(:digital_guest_room_keys_exception)
+          @housekeeping_scheduled_request_only = args[:housekeeping_scheduled_request_only] if args.key?(:housekeeping_scheduled_request_only)
+          @housekeeping_scheduled_request_only_exception = args[:housekeeping_scheduled_request_only_exception] if args.key?(:housekeeping_scheduled_request_only_exception)
+          @no_high_touch_items_common_areas = args[:no_high_touch_items_common_areas] if args.key?(:no_high_touch_items_common_areas)
+          @no_high_touch_items_common_areas_exception = args[:no_high_touch_items_common_areas_exception] if args.key?(:no_high_touch_items_common_areas_exception)
+          @no_high_touch_items_guest_rooms = args[:no_high_touch_items_guest_rooms] if args.key?(:no_high_touch_items_guest_rooms)
+          @no_high_touch_items_guest_rooms_exception = args[:no_high_touch_items_guest_rooms_exception] if args.key?(:no_high_touch_items_guest_rooms_exception)
+          @plastic_keycards_disinfected = args[:plastic_keycards_disinfected] if args.key?(:plastic_keycards_disinfected)
+          @plastic_keycards_disinfected_exception = args[:plastic_keycards_disinfected_exception] if args.key?(:plastic_keycards_disinfected_exception)
+          @room_bookings_buffer = args[:room_bookings_buffer] if args.key?(:room_bookings_buffer)
+          @room_bookings_buffer_exception = args[:room_bookings_buffer_exception] if args.key?(:room_bookings_buffer_exception)
+        end
+      end
+      
+      # Parking options at the property.
+      class Parking
+        include Google::Apis::Core::Hashable
+      
+        # Electric car charging stations. Electric power stations, usually located
+        # outdoors, into which guests plug their electric cars to receive a charge.
+        # Corresponds to the JSON property `electricCarChargingStations`
+        # @return [Boolean]
+        attr_accessor :electric_car_charging_stations
+        alias_method :electric_car_charging_stations?, :electric_car_charging_stations
+      
+        # Electric car charging stations exception.
+        # Corresponds to the JSON property `electricCarChargingStationsException`
+        # @return [String]
+        attr_accessor :electric_car_charging_stations_exception
+      
+        # Free parking. The hotel allows the cars of guests to be parked for free.
+        # Parking facility may be an outdoor lot or an indoor garage, but must be onsite.
+        # Nearby parking does not apply. Parking may be performed by the guest or by
+        # hotel staff. Free parking must be available to all guests (limited conditions
+        # does not apply).
+        # Corresponds to the JSON property `freeParking`
+        # @return [Boolean]
+        attr_accessor :free_parking
+        alias_method :free_parking?, :free_parking
+      
+        # Free parking exception.
+        # Corresponds to the JSON property `freeParkingException`
+        # @return [String]
+        attr_accessor :free_parking_exception
+      
+        # Free self parking. Guests park their own cars for free. Parking facility may
+        # be an outdoor lot or an indoor garage, but must be onsite. Nearby parking does
+        # not apply.
+        # Corresponds to the JSON property `freeSelfParking`
+        # @return [Boolean]
+        attr_accessor :free_self_parking
+        alias_method :free_self_parking?, :free_self_parking
+      
+        # Free self parking exception.
+        # Corresponds to the JSON property `freeSelfParkingException`
+        # @return [String]
+        attr_accessor :free_self_parking_exception
+      
+        # Free valet parking. Hotel staff member parks the cars of guests. Parking with
+        # this service is free.
+        # Corresponds to the JSON property `freeValetParking`
+        # @return [Boolean]
+        attr_accessor :free_valet_parking
+        alias_method :free_valet_parking?, :free_valet_parking
+      
+        # Free valet parking exception.
+        # Corresponds to the JSON property `freeValetParkingException`
+        # @return [String]
+        attr_accessor :free_valet_parking_exception
+      
+        # Parking available. The hotel allows the cars of guests to be parked. Can be
+        # free or for a fee. Parking facility may be an outdoor lot or an indoor garage,
+        # but must be onsite. Nearby parking does not apply. Parking may be performed by
+        # the guest or by hotel staff.
+        # Corresponds to the JSON property `parkingAvailable`
+        # @return [Boolean]
+        attr_accessor :parking_available
+        alias_method :parking_available?, :parking_available
+      
+        # Parking available exception.
+        # Corresponds to the JSON property `parkingAvailableException`
+        # @return [String]
+        attr_accessor :parking_available_exception
+      
+        # Self parking available. Guests park their own cars. Parking facility may be an
+        # outdoor lot or an indoor garage, but must be onsite. Nearby parking does not
+        # apply. Can be free or for a fee.
+        # Corresponds to the JSON property `selfParkingAvailable`
+        # @return [Boolean]
+        attr_accessor :self_parking_available
+        alias_method :self_parking_available?, :self_parking_available
+      
+        # Self parking available exception.
+        # Corresponds to the JSON property `selfParkingAvailableException`
+        # @return [String]
+        attr_accessor :self_parking_available_exception
+      
+        # Valet parking available. Hotel staff member parks the cars of guests. Parking
+        # with this service can be free or for a fee.
+        # Corresponds to the JSON property `valetParkingAvailable`
+        # @return [Boolean]
+        attr_accessor :valet_parking_available
+        alias_method :valet_parking_available?, :valet_parking_available
+      
+        # Valet parking available exception.
+        # Corresponds to the JSON property `valetParkingAvailableException`
+        # @return [String]
+        attr_accessor :valet_parking_available_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @electric_car_charging_stations = args[:electric_car_charging_stations] if args.key?(:electric_car_charging_stations)
+          @electric_car_charging_stations_exception = args[:electric_car_charging_stations_exception] if args.key?(:electric_car_charging_stations_exception)
+          @free_parking = args[:free_parking] if args.key?(:free_parking)
+          @free_parking_exception = args[:free_parking_exception] if args.key?(:free_parking_exception)
+          @free_self_parking = args[:free_self_parking] if args.key?(:free_self_parking)
+          @free_self_parking_exception = args[:free_self_parking_exception] if args.key?(:free_self_parking_exception)
+          @free_valet_parking = args[:free_valet_parking] if args.key?(:free_valet_parking)
+          @free_valet_parking_exception = args[:free_valet_parking_exception] if args.key?(:free_valet_parking_exception)
+          @parking_available = args[:parking_available] if args.key?(:parking_available)
+          @parking_available_exception = args[:parking_available_exception] if args.key?(:parking_available_exception)
+          @self_parking_available = args[:self_parking_available] if args.key?(:self_parking_available)
+          @self_parking_available_exception = args[:self_parking_available_exception] if args.key?(:self_parking_available_exception)
+          @valet_parking_available = args[:valet_parking_available] if args.key?(:valet_parking_available)
+          @valet_parking_available_exception = args[:valet_parking_available_exception] if args.key?(:valet_parking_available_exception)
+        end
+      end
+      
+      # Forms of payment accepted at the property.
+      class PaymentOptions
+        include Google::Apis::Core::Hashable
+      
+        # Cash. The hotel accepts payment by paper/coin currency.
+        # Corresponds to the JSON property `cash`
+        # @return [Boolean]
+        attr_accessor :cash
+        alias_method :cash?, :cash
+      
+        # Cash exception.
+        # Corresponds to the JSON property `cashException`
+        # @return [String]
+        attr_accessor :cash_exception
+      
+        # Cheque. The hotel accepts a printed document issued by the guest's bank in the
+        # guest's name as a form of payment.
+        # Corresponds to the JSON property `cheque`
+        # @return [Boolean]
+        attr_accessor :cheque
+        alias_method :cheque?, :cheque
+      
+        # Cheque exception.
+        # Corresponds to the JSON property `chequeException`
+        # @return [String]
+        attr_accessor :cheque_exception
+      
+        # Credit card. The hotel accepts payment by a card issued by a bank or credit
+        # card company. Also known as charge card, debit card, bank card, or charge
+        # plate.
+        # Corresponds to the JSON property `creditCard`
+        # @return [Boolean]
+        attr_accessor :credit_card
+        alias_method :credit_card?, :credit_card
+      
+        # Credit card exception.
+        # Corresponds to the JSON property `creditCardException`
+        # @return [String]
+        attr_accessor :credit_card_exception
+      
+        # Debit card. The hotel accepts a bank-issued card that immediately deducts the
+        # charged funds from the guest's bank account upon processing.
+        # Corresponds to the JSON property `debitCard`
+        # @return [Boolean]
+        attr_accessor :debit_card
+        alias_method :debit_card?, :debit_card
+      
+        # Debit card exception.
+        # Corresponds to the JSON property `debitCardException`
+        # @return [String]
+        attr_accessor :debit_card_exception
+      
+        # Mobile nfc. The hotel has the compatible computer hardware terminal that reads
+        # and charges a payment app on the guest's smartphone without requiring the two
+        # devices to make physical contact. Also known as Apple Pay, Google Pay, Samsung
+        # Pay.
+        # Corresponds to the JSON property `mobileNfc`
+        # @return [Boolean]
+        attr_accessor :mobile_nfc
+        alias_method :mobile_nfc?, :mobile_nfc
+      
+        # Mobile nfc exception.
+        # Corresponds to the JSON property `mobileNfcException`
+        # @return [String]
+        attr_accessor :mobile_nfc_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @cash = args[:cash] if args.key?(:cash)
+          @cash_exception = args[:cash_exception] if args.key?(:cash_exception)
+          @cheque = args[:cheque] if args.key?(:cheque)
+          @cheque_exception = args[:cheque_exception] if args.key?(:cheque_exception)
+          @credit_card = args[:credit_card] if args.key?(:credit_card)
+          @credit_card_exception = args[:credit_card_exception] if args.key?(:credit_card_exception)
+          @debit_card = args[:debit_card] if args.key?(:debit_card)
+          @debit_card_exception = args[:debit_card_exception] if args.key?(:debit_card_exception)
+          @mobile_nfc = args[:mobile_nfc] if args.key?(:mobile_nfc)
+          @mobile_nfc_exception = args[:mobile_nfc_exception] if args.key?(:mobile_nfc_exception)
+        end
+      end
+      
+      # Personal protection measures implemented by the hotel during COVID-19.
+      class PersonalProtection
+        include Google::Apis::Core::Hashable
+      
+        # Hand-sanitizer and/or sanitizing wipes are offered in common areas.
+        # Corresponds to the JSON property `commonAreasOfferSanitizingItems`
+        # @return [Boolean]
+        attr_accessor :common_areas_offer_sanitizing_items
+        alias_method :common_areas_offer_sanitizing_items?, :common_areas_offer_sanitizing_items
+      
+        # Common areas offer sanitizing items exception.
+        # Corresponds to the JSON property `commonAreasOfferSanitizingItemsException`
+        # @return [String]
+        attr_accessor :common_areas_offer_sanitizing_items_exception
+      
+        # Masks required on the property.
+        # Corresponds to the JSON property `faceMaskRequired`
+        # @return [Boolean]
+        attr_accessor :face_mask_required
+        alias_method :face_mask_required?, :face_mask_required
+      
+        # Face mask required exception.
+        # Corresponds to the JSON property `faceMaskRequiredException`
+        # @return [String]
+        attr_accessor :face_mask_required_exception
+      
+        # In-room hygiene kits with masks, hand sanitizer, and/or antibacterial wipes.
+        # Corresponds to the JSON property `guestRoomHygieneKitsAvailable`
+        # @return [Boolean]
+        attr_accessor :guest_room_hygiene_kits_available
+        alias_method :guest_room_hygiene_kits_available?, :guest_room_hygiene_kits_available
+      
+        # Guest room hygiene kits available exception.
+        # Corresponds to the JSON property `guestRoomHygieneKitsAvailableException`
+        # @return [String]
+        attr_accessor :guest_room_hygiene_kits_available_exception
+      
+        # Masks and/or gloves available for guests.
+        # Corresponds to the JSON property `protectiveEquipmentAvailable`
+        # @return [Boolean]
+        attr_accessor :protective_equipment_available
+        alias_method :protective_equipment_available?, :protective_equipment_available
+      
+        # Protective equipment available exception.
+        # Corresponds to the JSON property `protectiveEquipmentAvailableException`
+        # @return [String]
+        attr_accessor :protective_equipment_available_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @common_areas_offer_sanitizing_items = args[:common_areas_offer_sanitizing_items] if args.key?(:common_areas_offer_sanitizing_items)
+          @common_areas_offer_sanitizing_items_exception = args[:common_areas_offer_sanitizing_items_exception] if args.key?(:common_areas_offer_sanitizing_items_exception)
+          @face_mask_required = args[:face_mask_required] if args.key?(:face_mask_required)
+          @face_mask_required_exception = args[:face_mask_required_exception] if args.key?(:face_mask_required_exception)
+          @guest_room_hygiene_kits_available = args[:guest_room_hygiene_kits_available] if args.key?(:guest_room_hygiene_kits_available)
+          @guest_room_hygiene_kits_available_exception = args[:guest_room_hygiene_kits_available_exception] if args.key?(:guest_room_hygiene_kits_available_exception)
+          @protective_equipment_available = args[:protective_equipment_available] if args.key?(:protective_equipment_available)
+          @protective_equipment_available_exception = args[:protective_equipment_available_exception] if args.key?(:protective_equipment_available_exception)
+        end
+      end
+      
+      # Policies regarding guest-owned animals.
+      class Pets
+        include Google::Apis::Core::Hashable
+      
+        # Cats allowed. Domesticated felines are permitted at the property and allowed
+        # to stay in the guest room of their owner. May or may not require a fee.
+        # Corresponds to the JSON property `catsAllowed`
+        # @return [Boolean]
+        attr_accessor :cats_allowed
+        alias_method :cats_allowed?, :cats_allowed
+      
+        # Cats allowed exception.
+        # Corresponds to the JSON property `catsAllowedException`
+        # @return [String]
+        attr_accessor :cats_allowed_exception
+      
+        # Dogs allowed. Domesticated canines are permitted at the property and allowed
+        # to stay in the guest room of their owner. May or may not require a fee.
+        # Corresponds to the JSON property `dogsAllowed`
+        # @return [Boolean]
+        attr_accessor :dogs_allowed
+        alias_method :dogs_allowed?, :dogs_allowed
+      
+        # Dogs allowed exception.
+        # Corresponds to the JSON property `dogsAllowedException`
+        # @return [String]
+        attr_accessor :dogs_allowed_exception
+      
+        # Pets allowed. Household animals are allowed at the property and in the
+        # specific guest room of their owner. May or may not include dogs, cats,
+        # reptiles and/or fish. May or may not require a fee. Service animals are not
+        # considered to be pets, so not governed by this policy.
+        # Corresponds to the JSON property `petsAllowed`
+        # @return [Boolean]
+        attr_accessor :pets_allowed
+        alias_method :pets_allowed?, :pets_allowed
+      
+        # Pets allowed exception.
+        # Corresponds to the JSON property `petsAllowedException`
+        # @return [String]
+        attr_accessor :pets_allowed_exception
+      
+        # Pets allowed free. Household animals are allowed at the property and in the
+        # specific guest room of their owner for free. May or may not include dogs, cats,
+        # reptiles, and/or fish.
+        # Corresponds to the JSON property `petsAllowedFree`
+        # @return [Boolean]
+        attr_accessor :pets_allowed_free
+        alias_method :pets_allowed_free?, :pets_allowed_free
+      
+        # Pets allowed free exception.
+        # Corresponds to the JSON property `petsAllowedFreeException`
+        # @return [String]
+        attr_accessor :pets_allowed_free_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @cats_allowed = args[:cats_allowed] if args.key?(:cats_allowed)
+          @cats_allowed_exception = args[:cats_allowed_exception] if args.key?(:cats_allowed_exception)
+          @dogs_allowed = args[:dogs_allowed] if args.key?(:dogs_allowed)
+          @dogs_allowed_exception = args[:dogs_allowed_exception] if args.key?(:dogs_allowed_exception)
+          @pets_allowed = args[:pets_allowed] if args.key?(:pets_allowed)
+          @pets_allowed_exception = args[:pets_allowed_exception] if args.key?(:pets_allowed_exception)
+          @pets_allowed_free = args[:pets_allowed_free] if args.key?(:pets_allowed_free)
+          @pets_allowed_free_exception = args[:pets_allowed_free_exception] if args.key?(:pets_allowed_free_exception)
+        end
+      end
+      
+      # Physical distancing measures implemented by the hotel during COVID-19.
+      class PhysicalDistancing
+        include Google::Apis::Core::Hashable
+      
+        # Common areas arranged to maintain physical distancing.
+        # Corresponds to the JSON property `commonAreasPhysicalDistancingArranged`
+        # @return [Boolean]
+        attr_accessor :common_areas_physical_distancing_arranged
+        alias_method :common_areas_physical_distancing_arranged?, :common_areas_physical_distancing_arranged
+      
+        # Common areas physical distancing arranged exception.
+        # Corresponds to the JSON property `commonAreasPhysicalDistancingArrangedException`
+        # @return [String]
+        attr_accessor :common_areas_physical_distancing_arranged_exception
+      
+        # Physical distancing required.
+        # Corresponds to the JSON property `physicalDistancingRequired`
+        # @return [Boolean]
+        attr_accessor :physical_distancing_required
+        alias_method :physical_distancing_required?, :physical_distancing_required
+      
+        # Physical distancing required exception.
+        # Corresponds to the JSON property `physicalDistancingRequiredException`
+        # @return [String]
+        attr_accessor :physical_distancing_required_exception
+      
+        # Safety dividers at front desk and other locations.
+        # Corresponds to the JSON property `safetyDividers`
+        # @return [Boolean]
+        attr_accessor :safety_dividers
+        alias_method :safety_dividers?, :safety_dividers
+      
+        # Safety dividers exception.
+        # Corresponds to the JSON property `safetyDividersException`
+        # @return [String]
+        attr_accessor :safety_dividers_exception
+      
+        # Guest occupancy limited within shared facilities.
+        # Corresponds to the JSON property `sharedAreasLimitedOccupancy`
+        # @return [Boolean]
+        attr_accessor :shared_areas_limited_occupancy
+        alias_method :shared_areas_limited_occupancy?, :shared_areas_limited_occupancy
+      
+        # Shared areas limited occupancy exception.
+        # Corresponds to the JSON property `sharedAreasLimitedOccupancyException`
+        # @return [String]
+        attr_accessor :shared_areas_limited_occupancy_exception
+      
+        # Private spaces designated in spa and wellness areas.
+        # Corresponds to the JSON property `wellnessAreasHavePrivateSpaces`
+        # @return [Boolean]
+        attr_accessor :wellness_areas_have_private_spaces
+        alias_method :wellness_areas_have_private_spaces?, :wellness_areas_have_private_spaces
+      
+        # Wellness areas have private spaces exception.
+        # Corresponds to the JSON property `wellnessAreasHavePrivateSpacesException`
+        # @return [String]
+        attr_accessor :wellness_areas_have_private_spaces_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @common_areas_physical_distancing_arranged = args[:common_areas_physical_distancing_arranged] if args.key?(:common_areas_physical_distancing_arranged)
+          @common_areas_physical_distancing_arranged_exception = args[:common_areas_physical_distancing_arranged_exception] if args.key?(:common_areas_physical_distancing_arranged_exception)
+          @physical_distancing_required = args[:physical_distancing_required] if args.key?(:physical_distancing_required)
+          @physical_distancing_required_exception = args[:physical_distancing_required_exception] if args.key?(:physical_distancing_required_exception)
+          @safety_dividers = args[:safety_dividers] if args.key?(:safety_dividers)
+          @safety_dividers_exception = args[:safety_dividers_exception] if args.key?(:safety_dividers_exception)
+          @shared_areas_limited_occupancy = args[:shared_areas_limited_occupancy] if args.key?(:shared_areas_limited_occupancy)
+          @shared_areas_limited_occupancy_exception = args[:shared_areas_limited_occupancy_exception] if args.key?(:shared_areas_limited_occupancy_exception)
+          @wellness_areas_have_private_spaces = args[:wellness_areas_have_private_spaces] if args.key?(:wellness_areas_have_private_spaces)
+          @wellness_areas_have_private_spaces_exception = args[:wellness_areas_have_private_spaces_exception] if args.key?(:wellness_areas_have_private_spaces_exception)
+        end
+      end
+      
+      # Property rules that impact guests.
+      class Policies
+        include Google::Apis::Core::Hashable
+      
+        # All inclusive available. The hotel offers a rate option that includes the cost
+        # of the room, meals, activities, and other amenities that might otherwise be
+        # charged separately.
+        # Corresponds to the JSON property `allInclusiveAvailable`
+        # @return [Boolean]
+        attr_accessor :all_inclusive_available
+        alias_method :all_inclusive_available?, :all_inclusive_available
+      
+        # All inclusive available exception.
+        # Corresponds to the JSON property `allInclusiveAvailableException`
+        # @return [String]
+        attr_accessor :all_inclusive_available_exception
+      
+        # All inclusive only. The only rate option offered by the hotel is a rate that
+        # includes the cost of the room, meals, activities and other amenities that
+        # might otherwise be charged separately.
+        # Corresponds to the JSON property `allInclusiveOnly`
+        # @return [Boolean]
+        attr_accessor :all_inclusive_only
+        alias_method :all_inclusive_only?, :all_inclusive_only
+      
+        # All inclusive only exception.
+        # Corresponds to the JSON property `allInclusiveOnlyException`
+        # @return [String]
+        attr_accessor :all_inclusive_only_exception
+      
+        # Represents a time of day. The date and time zone are either not significant or
+        # are specified elsewhere. An API may choose to allow leap seconds. Related
+        # types are google.type.Date and `google.protobuf.Timestamp`.
+        # Corresponds to the JSON property `checkinTime`
+        # @return [Google::Apis::MybusinesslodgingV1::TimeOfDay]
+        attr_accessor :checkin_time
+      
+        # Check-in time exception.
+        # Corresponds to the JSON property `checkinTimeException`
+        # @return [String]
+        attr_accessor :checkin_time_exception
+      
+        # Represents a time of day. The date and time zone are either not significant or
+        # are specified elsewhere. An API may choose to allow leap seconds. Related
+        # types are google.type.Date and `google.protobuf.Timestamp`.
+        # Corresponds to the JSON property `checkoutTime`
+        # @return [Google::Apis::MybusinesslodgingV1::TimeOfDay]
+        attr_accessor :checkout_time
+      
+        # Check-out time exception.
+        # Corresponds to the JSON property `checkoutTimeException`
+        # @return [String]
+        attr_accessor :checkout_time_exception
+      
+        # Kids stay free. The children of guests are allowed to stay in the room/suite
+        # of a parent or adult without an additional fee. The policy may or may not
+        # stipulate a limit of the child's age or the overall number of children allowed.
+        # Corresponds to the JSON property `kidsStayFree`
+        # @return [Boolean]
+        attr_accessor :kids_stay_free
+        alias_method :kids_stay_free?, :kids_stay_free
+      
+        # Kids stay free exception.
+        # Corresponds to the JSON property `kidsStayFreeException`
+        # @return [String]
+        attr_accessor :kids_stay_free_exception
+      
+        # Max child age. The hotel allows children up to a certain age to stay in the
+        # room/suite of a parent or adult without an additional fee.
+        # Corresponds to the JSON property `maxChildAge`
+        # @return [Fixnum]
+        attr_accessor :max_child_age
+      
+        # Max child age exception.
+        # Corresponds to the JSON property `maxChildAgeException`
+        # @return [String]
+        attr_accessor :max_child_age_exception
+      
+        # Max kids stay free count. The hotel allows a specific, defined number of
+        # children to stay in the room/suite of a parent or adult without an additional
+        # fee.
+        # Corresponds to the JSON property `maxKidsStayFreeCount`
+        # @return [Fixnum]
+        attr_accessor :max_kids_stay_free_count
+      
+        # Max kids stay free count exception.
+        # Corresponds to the JSON property `maxKidsStayFreeCountException`
+        # @return [String]
+        attr_accessor :max_kids_stay_free_count_exception
+      
+        # Forms of payment accepted at the property.
+        # Corresponds to the JSON property `paymentOptions`
+        # @return [Google::Apis::MybusinesslodgingV1::PaymentOptions]
+        attr_accessor :payment_options
+      
+        # Smoke free property. Smoking is not allowed inside the building, on balconies,
+        # or in outside spaces. Hotels that offer a designated area for guests to smoke
+        # are not considered smoke-free properties.
+        # Corresponds to the JSON property `smokeFreeProperty`
+        # @return [Boolean]
+        attr_accessor :smoke_free_property
+        alias_method :smoke_free_property?, :smoke_free_property
+      
+        # Smoke free property exception.
+        # Corresponds to the JSON property `smokeFreePropertyException`
+        # @return [String]
+        attr_accessor :smoke_free_property_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @all_inclusive_available = args[:all_inclusive_available] if args.key?(:all_inclusive_available)
+          @all_inclusive_available_exception = args[:all_inclusive_available_exception] if args.key?(:all_inclusive_available_exception)
+          @all_inclusive_only = args[:all_inclusive_only] if args.key?(:all_inclusive_only)
+          @all_inclusive_only_exception = args[:all_inclusive_only_exception] if args.key?(:all_inclusive_only_exception)
+          @checkin_time = args[:checkin_time] if args.key?(:checkin_time)
+          @checkin_time_exception = args[:checkin_time_exception] if args.key?(:checkin_time_exception)
+          @checkout_time = args[:checkout_time] if args.key?(:checkout_time)
+          @checkout_time_exception = args[:checkout_time_exception] if args.key?(:checkout_time_exception)
+          @kids_stay_free = args[:kids_stay_free] if args.key?(:kids_stay_free)
+          @kids_stay_free_exception = args[:kids_stay_free_exception] if args.key?(:kids_stay_free_exception)
+          @max_child_age = args[:max_child_age] if args.key?(:max_child_age)
+          @max_child_age_exception = args[:max_child_age_exception] if args.key?(:max_child_age_exception)
+          @max_kids_stay_free_count = args[:max_kids_stay_free_count] if args.key?(:max_kids_stay_free_count)
+          @max_kids_stay_free_count_exception = args[:max_kids_stay_free_count_exception] if args.key?(:max_kids_stay_free_count_exception)
+          @payment_options = args[:payment_options] if args.key?(:payment_options)
+          @smoke_free_property = args[:smoke_free_property] if args.key?(:smoke_free_property)
+          @smoke_free_property_exception = args[:smoke_free_property_exception] if args.key?(:smoke_free_property_exception)
+        end
+      end
+      
+      # Swimming pool or recreational water facilities available at the hotel.
+      class Pools
+        include Google::Apis::Core::Hashable
+      
+        # Adult pool. A pool restricted for use by adults only. Can be indoors or
+        # outdoors.
+        # Corresponds to the JSON property `adultPool`
+        # @return [Boolean]
+        attr_accessor :adult_pool
+        alias_method :adult_pool?, :adult_pool
+      
+        # Adult pool exception.
+        # Corresponds to the JSON property `adultPoolException`
+        # @return [String]
+        attr_accessor :adult_pool_exception
+      
+        # Hot tub. A man-made pool containing bubbling water maintained at a higher
+        # temperature and circulated by aerating jets for the purpose of soaking,
+        # relaxation and hydrotherapy. Can be indoors or outdoors. Not used for active
+        # swimming. Also known as Jacuzzi. Hot tub must be in a common area where all
+        # guests can access it. Does not apply to room-specific hot tubs that are only
+        # accessible to guest occupying that room.
+        # Corresponds to the JSON property `hotTub`
+        # @return [Boolean]
+        attr_accessor :hot_tub
+        alias_method :hot_tub?, :hot_tub
+      
+        # Hot tub exception.
+        # Corresponds to the JSON property `hotTubException`
+        # @return [String]
+        attr_accessor :hot_tub_exception
+      
+        # Indoor pool. A pool located inside the hotel and available for guests to use
+        # for swimming and/or soaking. Use may or may not be restricted to adults and/or
+        # children.
+        # Corresponds to the JSON property `indoorPool`
+        # @return [Boolean]
+        attr_accessor :indoor_pool
+        alias_method :indoor_pool?, :indoor_pool
+      
+        # Indoor pool exception.
+        # Corresponds to the JSON property `indoorPoolException`
+        # @return [String]
+        attr_accessor :indoor_pool_exception
+      
+        # Indoor pools count. The sum of all indoor pools at the hotel.
+        # Corresponds to the JSON property `indoorPoolsCount`
+        # @return [Fixnum]
+        attr_accessor :indoor_pools_count
+      
+        # Indoor pools count exception.
+        # Corresponds to the JSON property `indoorPoolsCountException`
+        # @return [String]
+        attr_accessor :indoor_pools_count_exception
+      
+        # Lazy river. A man-made pool or several interconnected recreational pools built
+        # to mimic the shape and current of a winding river where guests float in the
+        # water on inflated rubber tubes. Can be indoors or outdoors.
+        # Corresponds to the JSON property `lazyRiver`
+        # @return [Boolean]
+        attr_accessor :lazy_river
+        alias_method :lazy_river?, :lazy_river
+      
+        # Lazy river exception.
+        # Corresponds to the JSON property `lazyRiverException`
+        # @return [String]
+        attr_accessor :lazy_river_exception
+      
+        # Lifeguard. A trained member of the hotel staff stationed by the hotel's indoor
+        # or outdoor swimming area and responsible for the safety of swimming guests.
+        # Corresponds to the JSON property `lifeguard`
+        # @return [Boolean]
+        attr_accessor :lifeguard
+        alias_method :lifeguard?, :lifeguard
+      
+        # Lifeguard exception.
+        # Corresponds to the JSON property `lifeguardException`
+        # @return [String]
+        attr_accessor :lifeguard_exception
+      
+        # Outdoor pool. A pool located outside on the grounds of the hotel and available
+        # for guests to use for swimming, soaking or recreation. Use may or may not be
+        # restricted to adults and/or children.
+        # Corresponds to the JSON property `outdoorPool`
+        # @return [Boolean]
+        attr_accessor :outdoor_pool
+        alias_method :outdoor_pool?, :outdoor_pool
+      
+        # Outdoor pool exception.
+        # Corresponds to the JSON property `outdoorPoolException`
+        # @return [String]
+        attr_accessor :outdoor_pool_exception
+      
+        # Outdoor pools count. The sum of all outdoor pools at the hotel.
+        # Corresponds to the JSON property `outdoorPoolsCount`
+        # @return [Fixnum]
+        attr_accessor :outdoor_pools_count
+      
+        # Outdoor pools count exception.
+        # Corresponds to the JSON property `outdoorPoolsCountException`
+        # @return [String]
+        attr_accessor :outdoor_pools_count_exception
+      
+        # Pool. The presence of a pool, either indoors or outdoors, for guests to use
+        # for swimming and/or soaking. Use may or may not be restricted to adults and/or
+        # children.
+        # Corresponds to the JSON property `pool`
+        # @return [Boolean]
+        attr_accessor :pool
+        alias_method :pool?, :pool
+      
+        # Pool exception.
+        # Corresponds to the JSON property `poolException`
+        # @return [String]
+        attr_accessor :pool_exception
+      
+        # Pools count. The sum of all pools at the hotel.
+        # Corresponds to the JSON property `poolsCount`
+        # @return [Fixnum]
+        attr_accessor :pools_count
+      
+        # Pools count exception.
+        # Corresponds to the JSON property `poolsCountException`
+        # @return [String]
+        attr_accessor :pools_count_exception
+      
+        # Wading pool. A shallow pool designed for small children to play in. Can be
+        # indoors or outdoors. Also known as kiddie pool.
+        # Corresponds to the JSON property `wadingPool`
+        # @return [Boolean]
+        attr_accessor :wading_pool
+        alias_method :wading_pool?, :wading_pool
+      
+        # Wading pool exception.
+        # Corresponds to the JSON property `wadingPoolException`
+        # @return [String]
+        attr_accessor :wading_pool_exception
+      
+        # Water park. An aquatic recreation area with a large pool or series of pools
+        # that has features such as a water slide or tube, wavepool, fountains, rope
+        # swings, and/or obstacle course. Can be indoors or outdoors. Also known as
+        # adventure pool.
+        # Corresponds to the JSON property `waterPark`
+        # @return [Boolean]
+        attr_accessor :water_park
+        alias_method :water_park?, :water_park
+      
+        # Water park exception.
+        # Corresponds to the JSON property `waterParkException`
+        # @return [String]
+        attr_accessor :water_park_exception
+      
+        # Waterslide. A continuously wetted chute positioned by an indoor or outdoor
+        # pool which people slide down into the water.
+        # Corresponds to the JSON property `waterslide`
+        # @return [Boolean]
+        attr_accessor :waterslide
+        alias_method :waterslide?, :waterslide
+      
+        # Waterslide exception.
+        # Corresponds to the JSON property `waterslideException`
+        # @return [String]
+        attr_accessor :waterslide_exception
+      
+        # Wave pool. A large indoor or outdoor pool with a machine that produces water
+        # currents to mimic the ocean's crests.
+        # Corresponds to the JSON property `wavePool`
+        # @return [Boolean]
+        attr_accessor :wave_pool
+        alias_method :wave_pool?, :wave_pool
+      
+        # Wave pool exception.
+        # Corresponds to the JSON property `wavePoolException`
+        # @return [String]
+        attr_accessor :wave_pool_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @adult_pool = args[:adult_pool] if args.key?(:adult_pool)
+          @adult_pool_exception = args[:adult_pool_exception] if args.key?(:adult_pool_exception)
+          @hot_tub = args[:hot_tub] if args.key?(:hot_tub)
+          @hot_tub_exception = args[:hot_tub_exception] if args.key?(:hot_tub_exception)
+          @indoor_pool = args[:indoor_pool] if args.key?(:indoor_pool)
+          @indoor_pool_exception = args[:indoor_pool_exception] if args.key?(:indoor_pool_exception)
+          @indoor_pools_count = args[:indoor_pools_count] if args.key?(:indoor_pools_count)
+          @indoor_pools_count_exception = args[:indoor_pools_count_exception] if args.key?(:indoor_pools_count_exception)
+          @lazy_river = args[:lazy_river] if args.key?(:lazy_river)
+          @lazy_river_exception = args[:lazy_river_exception] if args.key?(:lazy_river_exception)
+          @lifeguard = args[:lifeguard] if args.key?(:lifeguard)
+          @lifeguard_exception = args[:lifeguard_exception] if args.key?(:lifeguard_exception)
+          @outdoor_pool = args[:outdoor_pool] if args.key?(:outdoor_pool)
+          @outdoor_pool_exception = args[:outdoor_pool_exception] if args.key?(:outdoor_pool_exception)
+          @outdoor_pools_count = args[:outdoor_pools_count] if args.key?(:outdoor_pools_count)
+          @outdoor_pools_count_exception = args[:outdoor_pools_count_exception] if args.key?(:outdoor_pools_count_exception)
+          @pool = args[:pool] if args.key?(:pool)
+          @pool_exception = args[:pool_exception] if args.key?(:pool_exception)
+          @pools_count = args[:pools_count] if args.key?(:pools_count)
+          @pools_count_exception = args[:pools_count_exception] if args.key?(:pools_count_exception)
+          @wading_pool = args[:wading_pool] if args.key?(:wading_pool)
+          @wading_pool_exception = args[:wading_pool_exception] if args.key?(:wading_pool_exception)
+          @water_park = args[:water_park] if args.key?(:water_park)
+          @water_park_exception = args[:water_park_exception] if args.key?(:water_park_exception)
+          @waterslide = args[:waterslide] if args.key?(:waterslide)
+          @waterslide_exception = args[:waterslide_exception] if args.key?(:waterslide_exception)
+          @wave_pool = args[:wave_pool] if args.key?(:wave_pool)
+          @wave_pool_exception = args[:wave_pool_exception] if args.key?(:wave_pool_exception)
+        end
+      end
+      
+      # General factual information about the property's physical structure and
+      # important dates.
+      class Property
+        include Google::Apis::Core::Hashable
+      
+        # Built year. The year that construction of the property was completed.
+        # Corresponds to the JSON property `builtYear`
+        # @return [Fixnum]
+        attr_accessor :built_year
+      
+        # Built year exception.
+        # Corresponds to the JSON property `builtYearException`
+        # @return [String]
+        attr_accessor :built_year_exception
+      
+        # Floors count. The number of stories the building has from the ground floor to
+        # the top floor that are accessible to guests.
+        # Corresponds to the JSON property `floorsCount`
+        # @return [Fixnum]
+        attr_accessor :floors_count
+      
+        # Floors count exception.
+        # Corresponds to the JSON property `floorsCountException`
+        # @return [String]
+        attr_accessor :floors_count_exception
+      
+        # Last renovated year. The year when the most recent renovation of the property
+        # was completed. Renovation may include all or any combination of the following:
+        # the units, the public spaces, the exterior, or the interior.
+        # Corresponds to the JSON property `lastRenovatedYear`
+        # @return [Fixnum]
+        attr_accessor :last_renovated_year
+      
+        # Last renovated year exception.
+        # Corresponds to the JSON property `lastRenovatedYearException`
+        # @return [String]
+        attr_accessor :last_renovated_year_exception
+      
+        # Rooms count. The total number of rooms and suites bookable by guests for an
+        # overnight stay. Does not include event space, public spaces, conference rooms,
+        # fitness rooms, business centers, spa, salon, restaurants/bars, or shops.
+        # Corresponds to the JSON property `roomsCount`
+        # @return [Fixnum]
+        attr_accessor :rooms_count
+      
+        # Rooms count exception.
+        # Corresponds to the JSON property `roomsCountException`
+        # @return [String]
+        attr_accessor :rooms_count_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @built_year = args[:built_year] if args.key?(:built_year)
+          @built_year_exception = args[:built_year_exception] if args.key?(:built_year_exception)
+          @floors_count = args[:floors_count] if args.key?(:floors_count)
+          @floors_count_exception = args[:floors_count_exception] if args.key?(:floors_count_exception)
+          @last_renovated_year = args[:last_renovated_year] if args.key?(:last_renovated_year)
+          @last_renovated_year_exception = args[:last_renovated_year_exception] if args.key?(:last_renovated_year_exception)
+          @rooms_count = args[:rooms_count] if args.key?(:rooms_count)
+          @rooms_count_exception = args[:rooms_count_exception] if args.key?(:rooms_count_exception)
+        end
+      end
+      
+      # Conveniences or help provided by the property to facilitate an easier, more
+      # comfortable stay.
+      class Services
+        include Google::Apis::Core::Hashable
+      
+        # Baggage storage. A provision for guests to leave their bags at the hotel when
+        # they arrive for their stay before the official check-in time. May or may not
+        # apply for guests who wish to leave their bags after check-out and before
+        # departing the locale. Also known as bag dropoff.
+        # Corresponds to the JSON property `baggageStorage`
+        # @return [Boolean]
+        attr_accessor :baggage_storage
+        alias_method :baggage_storage?, :baggage_storage
+      
+        # Baggage storage exception.
+        # Corresponds to the JSON property `baggageStorageException`
+        # @return [String]
+        attr_accessor :baggage_storage_exception
+      
+        # Concierge. Hotel staff member(s) responsible for facilitating an easy,
+        # comfortable stay through making reservations for meals, sourcing theater
+        # tickets, arranging tours, finding a doctor, making recommendations, and
+        # answering questions.
+        # Corresponds to the JSON property `concierge`
+        # @return [Boolean]
+        attr_accessor :concierge
+        alias_method :concierge?, :concierge
+      
+        # Concierge exception.
+        # Corresponds to the JSON property `conciergeException`
+        # @return [String]
+        attr_accessor :concierge_exception
+      
+        # Convenience store. A shop at the hotel primarily selling snacks, drinks, non-
+        # prescription medicines, health and beauty aids, magazines and newspapers.
+        # Corresponds to the JSON property `convenienceStore`
+        # @return [Boolean]
+        attr_accessor :convenience_store
+        alias_method :convenience_store?, :convenience_store
+      
+        # Convenience store exception.
+        # Corresponds to the JSON property `convenienceStoreException`
+        # @return [String]
+        attr_accessor :convenience_store_exception
+      
+        # Currency exchange. A staff member or automated machine tasked with the
+        # transaction of providing the native currency of the hotel's locale in exchange
+        # for the foreign currency provided by a guest.
+        # Corresponds to the JSON property `currencyExchange`
+        # @return [Boolean]
+        attr_accessor :currency_exchange
+        alias_method :currency_exchange?, :currency_exchange
+      
+        # Currency exchange exception.
+        # Corresponds to the JSON property `currencyExchangeException`
+        # @return [String]
+        attr_accessor :currency_exchange_exception
+      
+        # Elevator. A passenger elevator that transports guests from one story to
+        # another. Also known as lift.
+        # Corresponds to the JSON property `elevator`
+        # @return [Boolean]
+        attr_accessor :elevator
+        alias_method :elevator?, :elevator
+      
+        # Elevator exception.
+        # Corresponds to the JSON property `elevatorException`
+        # @return [String]
+        attr_accessor :elevator_exception
+      
+        # Front desk. A counter or desk in the lobby or the immediate interior of the
+        # hotel where a member of the staff greets guests and processes the information
+        # related to their stay (including check-in and check-out). May or may not be
+        # manned and open 24/7.
+        # Corresponds to the JSON property `frontDesk`
+        # @return [Boolean]
+        attr_accessor :front_desk
+        alias_method :front_desk?, :front_desk
+      
+        # Front desk exception.
+        # Corresponds to the JSON property `frontDeskException`
+        # @return [String]
+        attr_accessor :front_desk_exception
+      
+        # Full service laundry. Laundry and dry cleaning facilitated and handled by the
+        # hotel on behalf of the guest. Does not include the provision for guests to do
+        # their own laundry in on-site machines.
+        # Corresponds to the JSON property `fullServiceLaundry`
+        # @return [Boolean]
+        attr_accessor :full_service_laundry
+        alias_method :full_service_laundry?, :full_service_laundry
+      
+        # Full service laundry exception.
+        # Corresponds to the JSON property `fullServiceLaundryException`
+        # @return [String]
+        attr_accessor :full_service_laundry_exception
+      
+        # Gift shop. An on-site store primarily selling souvenirs, mementos and other
+        # gift items. May or may not also sell sundries, magazines and newspapers,
+        # clothing, or snacks.
+        # Corresponds to the JSON property `giftShop`
+        # @return [Boolean]
+        attr_accessor :gift_shop
+        alias_method :gift_shop?, :gift_shop
+      
+        # Gift shop exception.
+        # Corresponds to the JSON property `giftShopException`
+        # @return [String]
+        attr_accessor :gift_shop_exception
+      
+        # Languages spoken by at least one staff member.
+        # Corresponds to the JSON property `languagesSpoken`
+        # @return [Array<Google::Apis::MybusinesslodgingV1::LanguageSpoken>]
+        attr_accessor :languages_spoken
+      
+        # Self service laundry. On-site clothes washers and dryers accessible to guests
+        # for the purpose of washing and drying their own clothes. May or may not
+        # require payment to use the machines.
+        # Corresponds to the JSON property `selfServiceLaundry`
+        # @return [Boolean]
+        attr_accessor :self_service_laundry
+        alias_method :self_service_laundry?, :self_service_laundry
+      
+        # Self service laundry exception.
+        # Corresponds to the JSON property `selfServiceLaundryException`
+        # @return [String]
+        attr_accessor :self_service_laundry_exception
+      
+        # Social hour. A reception with complimentary soft drinks, tea, coffee, wine and/
+        # or cocktails in the afternoon or evening. Can be hosted by hotel staff or
+        # guests may serve themselves. Also known as wine hour. The availability of
+        # coffee/tea in the lobby throughout the day does not constitute a social or
+        # wine hour.
+        # Corresponds to the JSON property `socialHour`
+        # @return [Boolean]
+        attr_accessor :social_hour
+        alias_method :social_hour?, :social_hour
+      
+        # Social hour exception.
+        # Corresponds to the JSON property `socialHourException`
+        # @return [String]
+        attr_accessor :social_hour_exception
+      
+        # 24hr front desk. Front desk is staffed 24 hours a day.
+        # Corresponds to the JSON property `twentyFourHourFrontDesk`
+        # @return [Boolean]
+        attr_accessor :twenty_four_hour_front_desk
+        alias_method :twenty_four_hour_front_desk?, :twenty_four_hour_front_desk
+      
+        # 24hr front desk exception.
+        # Corresponds to the JSON property `twentyFourHourFrontDeskException`
+        # @return [String]
+        attr_accessor :twenty_four_hour_front_desk_exception
+      
+        # Wake up calls. By direction of the guest, a hotel staff member will phone the
+        # guest unit at the requested hour. Also known as morning call.
+        # Corresponds to the JSON property `wakeUpCalls`
+        # @return [Boolean]
+        attr_accessor :wake_up_calls
+        alias_method :wake_up_calls?, :wake_up_calls
+      
+        # Wake up calls exception.
+        # Corresponds to the JSON property `wakeUpCallsException`
+        # @return [String]
+        attr_accessor :wake_up_calls_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @baggage_storage = args[:baggage_storage] if args.key?(:baggage_storage)
+          @baggage_storage_exception = args[:baggage_storage_exception] if args.key?(:baggage_storage_exception)
+          @concierge = args[:concierge] if args.key?(:concierge)
+          @concierge_exception = args[:concierge_exception] if args.key?(:concierge_exception)
+          @convenience_store = args[:convenience_store] if args.key?(:convenience_store)
+          @convenience_store_exception = args[:convenience_store_exception] if args.key?(:convenience_store_exception)
+          @currency_exchange = args[:currency_exchange] if args.key?(:currency_exchange)
+          @currency_exchange_exception = args[:currency_exchange_exception] if args.key?(:currency_exchange_exception)
+          @elevator = args[:elevator] if args.key?(:elevator)
+          @elevator_exception = args[:elevator_exception] if args.key?(:elevator_exception)
+          @front_desk = args[:front_desk] if args.key?(:front_desk)
+          @front_desk_exception = args[:front_desk_exception] if args.key?(:front_desk_exception)
+          @full_service_laundry = args[:full_service_laundry] if args.key?(:full_service_laundry)
+          @full_service_laundry_exception = args[:full_service_laundry_exception] if args.key?(:full_service_laundry_exception)
+          @gift_shop = args[:gift_shop] if args.key?(:gift_shop)
+          @gift_shop_exception = args[:gift_shop_exception] if args.key?(:gift_shop_exception)
+          @languages_spoken = args[:languages_spoken] if args.key?(:languages_spoken)
+          @self_service_laundry = args[:self_service_laundry] if args.key?(:self_service_laundry)
+          @self_service_laundry_exception = args[:self_service_laundry_exception] if args.key?(:self_service_laundry_exception)
+          @social_hour = args[:social_hour] if args.key?(:social_hour)
+          @social_hour_exception = args[:social_hour_exception] if args.key?(:social_hour_exception)
+          @twenty_four_hour_front_desk = args[:twenty_four_hour_front_desk] if args.key?(:twenty_four_hour_front_desk)
+          @twenty_four_hour_front_desk_exception = args[:twenty_four_hour_front_desk_exception] if args.key?(:twenty_four_hour_front_desk_exception)
+          @wake_up_calls = args[:wake_up_calls] if args.key?(:wake_up_calls)
+          @wake_up_calls_exception = args[:wake_up_calls_exception] if args.key?(:wake_up_calls_exception)
+        end
+      end
+      
+      # Represents a time of day. The date and time zone are either not significant or
+      # are specified elsewhere. An API may choose to allow leap seconds. Related
+      # types are google.type.Date and `google.protobuf.Timestamp`.
+      class TimeOfDay
+        include Google::Apis::Core::Hashable
+      
+        # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to
+        # allow the value "24:00:00" for scenarios like business closing time.
+        # Corresponds to the JSON property `hours`
+        # @return [Fixnum]
+        attr_accessor :hours
+      
+        # Minutes of hour of day. Must be from 0 to 59.
+        # Corresponds to the JSON property `minutes`
+        # @return [Fixnum]
+        attr_accessor :minutes
+      
+        # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
+        # Corresponds to the JSON property `nanos`
+        # @return [Fixnum]
+        attr_accessor :nanos
+      
+        # Seconds of minutes of the time. Must normally be from 0 to 59. An API may
+        # allow the value 60 if it allows leap-seconds.
+        # Corresponds to the JSON property `seconds`
+        # @return [Fixnum]
+        attr_accessor :seconds
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @hours = args[:hours] if args.key?(:hours)
+          @minutes = args[:minutes] if args.key?(:minutes)
+          @nanos = args[:nanos] if args.key?(:nanos)
+          @seconds = args[:seconds] if args.key?(:seconds)
+        end
+      end
+      
+      # Vehicles or vehicular services facilitated or owned by the property.
+      class Transportation
+        include Google::Apis::Core::Hashable
+      
+        # Airport shuttle. The hotel provides guests with a chauffeured van or bus to
+        # and from the airport. Can be free or for a fee. Guests may share the vehicle
+        # with other guests unknown to them. Applies if the hotel has a third-party
+        # shuttle service (office/desk etc.) within the hotel. As long as hotel provides
+        # this service, it doesn't matter if it's directly with them or a third party
+        # they work with. Does not apply if guest has to coordinate with an entity
+        # outside/other than the hotel.
+        # Corresponds to the JSON property `airportShuttle`
+        # @return [Boolean]
+        attr_accessor :airport_shuttle
+        alias_method :airport_shuttle?, :airport_shuttle
+      
+        # Airport shuttle exception.
+        # Corresponds to the JSON property `airportShuttleException`
+        # @return [String]
+        attr_accessor :airport_shuttle_exception
+      
+        # Car rental on property. A branch of a rental car company with a processing
+        # desk in the hotel. Available cars for rent may be awaiting at the hotel or in
+        # a nearby lot.
+        # Corresponds to the JSON property `carRentalOnProperty`
+        # @return [Boolean]
+        attr_accessor :car_rental_on_property
+        alias_method :car_rental_on_property?, :car_rental_on_property
+      
+        # Car rental on property exception.
+        # Corresponds to the JSON property `carRentalOnPropertyException`
+        # @return [String]
+        attr_accessor :car_rental_on_property_exception
+      
+        # Free airport shuttle. Airport shuttle is free to guests. Must be free to all
+        # guests without any conditions.
+        # Corresponds to the JSON property `freeAirportShuttle`
+        # @return [Boolean]
+        attr_accessor :free_airport_shuttle
+        alias_method :free_airport_shuttle?, :free_airport_shuttle
+      
+        # Free airport shuttle exception.
+        # Corresponds to the JSON property `freeAirportShuttleException`
+        # @return [String]
+        attr_accessor :free_airport_shuttle_exception
+      
+        # Free private car service. Private chauffeured car service is free to guests.
+        # Corresponds to the JSON property `freePrivateCarService`
+        # @return [Boolean]
+        attr_accessor :free_private_car_service
+        alias_method :free_private_car_service?, :free_private_car_service
+      
+        # Free private car service exception.
+        # Corresponds to the JSON property `freePrivateCarServiceException`
+        # @return [String]
+        attr_accessor :free_private_car_service_exception
+      
+        # Local shuttle. A car, van or bus provided by the hotel to transport guests to
+        # destinations within a specified range of distance around the hotel. Usually
+        # shopping and/or convention centers, downtown districts, or beaches. Can be
+        # free or for a fee.
+        # Corresponds to the JSON property `localShuttle`
+        # @return [Boolean]
+        attr_accessor :local_shuttle
+        alias_method :local_shuttle?, :local_shuttle
+      
+        # Local shuttle exception.
+        # Corresponds to the JSON property `localShuttleException`
+        # @return [String]
+        attr_accessor :local_shuttle_exception
+      
+        # Private car service. Hotel provides a private chauffeured car to transport
+        # guests to destinations. Passengers in the car are either alone or are known to
+        # one another and have requested the car together. Service can be free or for a
+        # fee and travel distance is usually limited to a specific range. Not a taxi.
+        # Corresponds to the JSON property `privateCarService`
+        # @return [Boolean]
+        attr_accessor :private_car_service
+        alias_method :private_car_service?, :private_car_service
+      
+        # Private car service exception.
+        # Corresponds to the JSON property `privateCarServiceException`
+        # @return [String]
+        attr_accessor :private_car_service_exception
+      
+        # Transfer. Hotel provides a shuttle service or car service to take guests to
+        # and from the nearest airport or train station. Can be free or for a fee.
+        # Guests may share the vehicle with other guests unknown to them.
+        # Corresponds to the JSON property `transfer`
+        # @return [Boolean]
+        attr_accessor :transfer
+        alias_method :transfer?, :transfer
+      
+        # Transfer exception.
+        # Corresponds to the JSON property `transferException`
+        # @return [String]
+        attr_accessor :transfer_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @airport_shuttle = args[:airport_shuttle] if args.key?(:airport_shuttle)
+          @airport_shuttle_exception = args[:airport_shuttle_exception] if args.key?(:airport_shuttle_exception)
+          @car_rental_on_property = args[:car_rental_on_property] if args.key?(:car_rental_on_property)
+          @car_rental_on_property_exception = args[:car_rental_on_property_exception] if args.key?(:car_rental_on_property_exception)
+          @free_airport_shuttle = args[:free_airport_shuttle] if args.key?(:free_airport_shuttle)
+          @free_airport_shuttle_exception = args[:free_airport_shuttle_exception] if args.key?(:free_airport_shuttle_exception)
+          @free_private_car_service = args[:free_private_car_service] if args.key?(:free_private_car_service)
+          @free_private_car_service_exception = args[:free_private_car_service_exception] if args.key?(:free_private_car_service_exception)
+          @local_shuttle = args[:local_shuttle] if args.key?(:local_shuttle)
+          @local_shuttle_exception = args[:local_shuttle_exception] if args.key?(:local_shuttle_exception)
+          @private_car_service = args[:private_car_service] if args.key?(:private_car_service)
+          @private_car_service_exception = args[:private_car_service_exception] if args.key?(:private_car_service_exception)
+          @transfer = args[:transfer] if args.key?(:transfer)
+          @transfer_exception = args[:transfer_exception] if args.key?(:transfer_exception)
+        end
+      end
+      
+      # Views available from the guest unit itself.
+      class ViewsFromUnit
+        include Google::Apis::Core::Hashable
+      
+        # Beach view. A guestroom that features a window through which guests can see
+        # the beach.
+        # Corresponds to the JSON property `beachView`
+        # @return [Boolean]
+        attr_accessor :beach_view
+        alias_method :beach_view?, :beach_view
+      
+        # Beach view exception.
+        # Corresponds to the JSON property `beachViewException`
+        # @return [String]
+        attr_accessor :beach_view_exception
+      
+        # City view. A guestroom that features a window through which guests can see the
+        # buildings, parks and/or streets of the city.
+        # Corresponds to the JSON property `cityView`
+        # @return [Boolean]
+        attr_accessor :city_view
+        alias_method :city_view?, :city_view
+      
+        # City view exception.
+        # Corresponds to the JSON property `cityViewException`
+        # @return [String]
+        attr_accessor :city_view_exception
+      
+        # Garden view. A guestroom that features a window through which guests can see a
+        # garden.
+        # Corresponds to the JSON property `gardenView`
+        # @return [Boolean]
+        attr_accessor :garden_view
+        alias_method :garden_view?, :garden_view
+      
+        # Garden view exception.
+        # Corresponds to the JSON property `gardenViewException`
+        # @return [String]
+        attr_accessor :garden_view_exception
+      
+        # Lake view.
+        # Corresponds to the JSON property `lakeView`
+        # @return [Boolean]
+        attr_accessor :lake_view
+        alias_method :lake_view?, :lake_view
+      
+        # Lake view exception.
+        # Corresponds to the JSON property `lakeViewException`
+        # @return [String]
+        attr_accessor :lake_view_exception
+      
+        # Landmark view. A guestroom that features a window through which guests can see
+        # a landmark such as the countryside, a golf course, the forest, a park, a rain
+        # forst, a mountain or a slope.
+        # Corresponds to the JSON property `landmarkView`
+        # @return [Boolean]
+        attr_accessor :landmark_view
+        alias_method :landmark_view?, :landmark_view
+      
+        # Landmark view exception.
+        # Corresponds to the JSON property `landmarkViewException`
+        # @return [String]
+        attr_accessor :landmark_view_exception
+      
+        # Ocean view. A guestroom that features a window through which guests can see
+        # the ocean.
+        # Corresponds to the JSON property `oceanView`
+        # @return [Boolean]
+        attr_accessor :ocean_view
+        alias_method :ocean_view?, :ocean_view
+      
+        # Ocean view exception.
+        # Corresponds to the JSON property `oceanViewException`
+        # @return [String]
+        attr_accessor :ocean_view_exception
+      
+        # Pool view. A guestroom that features a window through which guests can see the
+        # hotel's swimming pool.
+        # Corresponds to the JSON property `poolView`
+        # @return [Boolean]
+        attr_accessor :pool_view
+        alias_method :pool_view?, :pool_view
+      
+        # Pool view exception.
+        # Corresponds to the JSON property `poolViewException`
+        # @return [String]
+        attr_accessor :pool_view_exception
+      
+        # Valley view. A guestroom that features a window through which guests can see
+        # over a valley.
+        # Corresponds to the JSON property `valleyView`
+        # @return [Boolean]
+        attr_accessor :valley_view
+        alias_method :valley_view?, :valley_view
+      
+        # Valley view exception.
+        # Corresponds to the JSON property `valleyViewException`
+        # @return [String]
+        attr_accessor :valley_view_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @beach_view = args[:beach_view] if args.key?(:beach_view)
+          @beach_view_exception = args[:beach_view_exception] if args.key?(:beach_view_exception)
+          @city_view = args[:city_view] if args.key?(:city_view)
+          @city_view_exception = args[:city_view_exception] if args.key?(:city_view_exception)
+          @garden_view = args[:garden_view] if args.key?(:garden_view)
+          @garden_view_exception = args[:garden_view_exception] if args.key?(:garden_view_exception)
+          @lake_view = args[:lake_view] if args.key?(:lake_view)
+          @lake_view_exception = args[:lake_view_exception] if args.key?(:lake_view_exception)
+          @landmark_view = args[:landmark_view] if args.key?(:landmark_view)
+          @landmark_view_exception = args[:landmark_view_exception] if args.key?(:landmark_view_exception)
+          @ocean_view = args[:ocean_view] if args.key?(:ocean_view)
+          @ocean_view_exception = args[:ocean_view_exception] if args.key?(:ocean_view_exception)
+          @pool_view = args[:pool_view] if args.key?(:pool_view)
+          @pool_view_exception = args[:pool_view_exception] if args.key?(:pool_view_exception)
+          @valley_view = args[:valley_view] if args.key?(:valley_view)
+          @valley_view_exception = args[:valley_view_exception] if args.key?(:valley_view_exception)
+        end
+      end
+      
+      # Guest facilities at the property to promote or maintain health, beauty, and
+      # fitness.
+      class Wellness
+        include Google::Apis::Core::Hashable
+      
+        # Doctor on call. The hotel has a contract with a medical professional who
+        # provides services to hotel guests should they fall ill during their stay. The
+        # doctor may or may not have an on-site office or be at the hotel at all times.
+        # Corresponds to the JSON property `doctorOnCall`
+        # @return [Boolean]
+        attr_accessor :doctor_on_call
+        alias_method :doctor_on_call?, :doctor_on_call
+      
+        # Doctor on call exception.
+        # Corresponds to the JSON property `doctorOnCallException`
+        # @return [String]
+        attr_accessor :doctor_on_call_exception
+      
+        # Elliptical machine. An electric, stationary fitness machine with pedals that
+        # simulates climbing, walking or running and provides a user-controlled range of
+        # speeds and tensions. May not have arm-controlled levers to work out the upper
+        # body as well. Commonly found in a gym, fitness room, health center, or health
+        # club.
+        # Corresponds to the JSON property `ellipticalMachine`
+        # @return [Boolean]
+        attr_accessor :elliptical_machine
+        alias_method :elliptical_machine?, :elliptical_machine
+      
+        # Elliptical machine exception.
+        # Corresponds to the JSON property `ellipticalMachineException`
+        # @return [String]
+        attr_accessor :elliptical_machine_exception
+      
+        # Fitness center. A room or building at the hotel containing equipment to
+        # promote physical activity, such as treadmills, elliptical machines, stationary
+        # bikes, weight machines, free weights, and/or stretching mats. Use of the
+        # fitness center can be free or for a fee. May or may not be staffed. May or may
+        # not offer instructor-led classes in various styles of physical conditioning.
+        # May or may not be open 24/7. May or may not include locker rooms and showers.
+        # Also known as health club, gym, fitness room, health center.
+        # Corresponds to the JSON property `fitnessCenter`
+        # @return [Boolean]
+        attr_accessor :fitness_center
+        alias_method :fitness_center?, :fitness_center
+      
+        # Fitness center exception.
+        # Corresponds to the JSON property `fitnessCenterException`
+        # @return [String]
+        attr_accessor :fitness_center_exception
+      
+        # Free fitness center. Guests may use the fitness center for free.
+        # Corresponds to the JSON property `freeFitnessCenter`
+        # @return [Boolean]
+        attr_accessor :free_fitness_center
+        alias_method :free_fitness_center?, :free_fitness_center
+      
+        # Free fitness center exception.
+        # Corresponds to the JSON property `freeFitnessCenterException`
+        # @return [String]
+        attr_accessor :free_fitness_center_exception
+      
+        # Free weights. Individual handheld fitness equipment of varied weights used for
+        # upper body strength training or bodybuilding. Also known as barbells,
+        # dumbbells, or kettlebells. Often stored on a rack with the weights arranged
+        # from light to heavy. Commonly found in a gym, fitness room, health center, or
+        # health club.
+        # Corresponds to the JSON property `freeWeights`
+        # @return [Boolean]
+        attr_accessor :free_weights
+        alias_method :free_weights?, :free_weights
+      
+        # Free weights exception.
+        # Corresponds to the JSON property `freeWeightsException`
+        # @return [String]
+        attr_accessor :free_weights_exception
+      
+        # Massage. A service provided by a trained massage therapist involving the
+        # physical manipulation of a guest's muscles in order to achieve relaxation or
+        # pain relief.
+        # Corresponds to the JSON property `massage`
+        # @return [Boolean]
+        attr_accessor :massage
+        alias_method :massage?, :massage
+      
+        # Massage exception.
+        # Corresponds to the JSON property `massageException`
+        # @return [String]
+        attr_accessor :massage_exception
+      
+        # Salon. A room at the hotel where professionals provide hair styling services
+        # such as shampooing, blow drying, hair dos, hair cutting and hair coloring.
+        # Also known as hairdresser or beauty salon.
+        # Corresponds to the JSON property `salon`
+        # @return [Boolean]
+        attr_accessor :salon
+        alias_method :salon?, :salon
+      
+        # Salon exception.
+        # Corresponds to the JSON property `salonException`
+        # @return [String]
+        attr_accessor :salon_exception
+      
+        # Sauna. A wood-paneled room heated to a high temperature where guests sit on
+        # built-in wood benches for the purpose of perspiring and relaxing their muscles.
+        # Can be dry or slightly wet heat. Not a steam room.
+        # Corresponds to the JSON property `sauna`
+        # @return [Boolean]
+        attr_accessor :sauna
+        alias_method :sauna?, :sauna
+      
+        # Sauna exception.
+        # Corresponds to the JSON property `saunaException`
+        # @return [String]
+        attr_accessor :sauna_exception
+      
+        # Spa. A designated area, room or building at the hotel offering health and
+        # beauty treatment through such means as steam baths, exercise equipment, and
+        # massage. May also offer facials, nail care, and hair care. Services are
+        # usually available by appointment and for an additional fee. Does not apply if
+        # hotel only offers a steam room; must offer other beauty and/or health
+        # treatments as well.
+        # Corresponds to the JSON property `spa`
+        # @return [Boolean]
+        attr_accessor :spa
+        alias_method :spa?, :spa
+      
+        # Spa exception.
+        # Corresponds to the JSON property `spaException`
+        # @return [String]
+        attr_accessor :spa_exception
+      
+        # Treadmill. An electric stationary fitness machine that simulates a moving path
+        # to promote walking or running within a range of user-controlled speeds and
+        # inclines. Also known as running machine. Commonly found in a gym, fitness room,
+        # health center, or health club.
+        # Corresponds to the JSON property `treadmill`
+        # @return [Boolean]
+        attr_accessor :treadmill
+        alias_method :treadmill?, :treadmill
+      
+        # Treadmill exception.
+        # Corresponds to the JSON property `treadmillException`
+        # @return [String]
+        attr_accessor :treadmill_exception
+      
+        # Weight machine. Non-electronic fitness equipment designed for the user to
+        # target the exertion of different muscles. Usually incorporates a padded seat,
+        # a stack of flat weights and various bars and pulleys. May be designed for
+        # toning a specific part of the body or may involve different user-controlled
+        # settings, hardware and pulleys so as to provide an overall workout in one
+        # machine. Commonly found in a gym, fitness center, fitness room, or health club.
+        # Corresponds to the JSON property `weightMachine`
+        # @return [Boolean]
+        attr_accessor :weight_machine
+        alias_method :weight_machine?, :weight_machine
+      
+        # Weight machine exception.
+        # Corresponds to the JSON property `weightMachineException`
+        # @return [String]
+        attr_accessor :weight_machine_exception
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @doctor_on_call = args[:doctor_on_call] if args.key?(:doctor_on_call)
+          @doctor_on_call_exception = args[:doctor_on_call_exception] if args.key?(:doctor_on_call_exception)
+          @elliptical_machine = args[:elliptical_machine] if args.key?(:elliptical_machine)
+          @elliptical_machine_exception = args[:elliptical_machine_exception] if args.key?(:elliptical_machine_exception)
+          @fitness_center = args[:fitness_center] if args.key?(:fitness_center)
+          @fitness_center_exception = args[:fitness_center_exception] if args.key?(:fitness_center_exception)
+          @free_fitness_center = args[:free_fitness_center] if args.key?(:free_fitness_center)
+          @free_fitness_center_exception = args[:free_fitness_center_exception] if args.key?(:free_fitness_center_exception)
+          @free_weights = args[:free_weights] if args.key?(:free_weights)
+          @free_weights_exception = args[:free_weights_exception] if args.key?(:free_weights_exception)
+          @massage = args[:massage] if args.key?(:massage)
+          @massage_exception = args[:massage_exception] if args.key?(:massage_exception)
+          @salon = args[:salon] if args.key?(:salon)
+          @salon_exception = args[:salon_exception] if args.key?(:salon_exception)
+          @sauna = args[:sauna] if args.key?(:sauna)
+          @sauna_exception = args[:sauna_exception] if args.key?(:sauna_exception)
+          @spa = args[:spa] if args.key?(:spa)
+          @spa_exception = args[:spa_exception] if args.key?(:spa_exception)
+          @treadmill = args[:treadmill] if args.key?(:treadmill)
+          @treadmill_exception = args[:treadmill_exception] if args.key?(:treadmill_exception)
+          @weight_machine = args[:weight_machine] if args.key?(:weight_machine)
+          @weight_machine_exception = args[:weight_machine_exception] if args.key?(:weight_machine_exception)
+        end
+      end
+    end
+  end
+end