google-apis-vectortile_v1 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2a7a42c64cf72434f32d268c12482b47133833e94ed98e432c485d968f25773f
+  data.tar.gz: 98780ebad3a4acd3aa5986595910e8423b7cb78c5bda6bb8154b7185cb8a62b4
+SHA512:
+  metadata.gz: 05bf2d85ed2e0b8e57769388819f5ed51529ffa3f3b76f519a0dfa4870e73442f71dbac3e6c3f624063885db61c5b57e881e4b7a15314a438eeaba2a9e5b379d
+  data.tar.gz: c630fd67d46401c2fbe988e660bbef4114db25227d7215d6dba35502f98d9288d9c1e8d5327d776eab49144a9793f58bad6a43bae337ca14a1709d28a3dd9612

data/.yardopts

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

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Release history for google-apis-vectortile_v1
+
+### v0.1.0 (2021-01-07)
+
+* Regenerated using generator version 0.1.1
+* Regenerated from discovery document revision 20201202
+

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 Semantic Tile API
+
+This is a simple client library for version V1 of the Semantic Tile 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/vectortile.googleapis.com) in the console.
+
+### Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'google-apis-vectortile_v1', '~> 0.1'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+Or install it yourself as:
+
+```
+$ gem install google-apis-vectortile_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/vectortile_v1"
+
+# Create a client object
+client = Google::Apis::VectortileV1::SemanticTileService.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 Vectortile service in particular.)
+
+For reference information on specific calls in the Semantic Tile API, see the {Google::Apis::VectortileV1::SemanticTileService 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-vectortile_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/maps/contact-sales/) 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-vectortile_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/vectortile_v1"

data/lib/google/apis/vectortile_v1.rb

@@ -0,0 +1,33 @@
+# 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/vectortile_v1/service.rb'
+require 'google/apis/vectortile_v1/classes.rb'
+require 'google/apis/vectortile_v1/representations.rb'
+require 'google/apis/vectortile_v1/gem_version.rb'
+
+module Google
+  module Apis
+    # Semantic Tile API
+    #
+    # Serves vector tiles containing geospatial data.
+    #
+    # @see https://developers.google.com/maps/contact-sales/
+    module VectortileV1
+      # Version of the Semantic Tile API this client connects to.
+      # This is NOT the gem version.
+      VERSION = 'V1'
+    end
+  end
+end

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

@@ -0,0 +1,854 @@
+# 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 VectortileV1
+      
+      # Represents an area. Used to represent regions such as water, parks, etc. Next
+      # ID: 10
+      class Area
+        include Google::Apis::Core::Hashable
+      
+        # Metadata necessary to determine the ordering of a particular basemap element
+        # relative to others. To render the basemap correctly, sort by z-plane, then z-
+        # grade, then z-within-grade.
+        # Corresponds to the JSON property `basemapZOrder`
+        # @return [Google::Apis::VectortileV1::BasemapZOrder]
+        attr_accessor :basemap_z_order
+      
+        # True if the polygon is not entirely internal to the feature that it belongs to:
+        # that is, some of the edges are bordering another feature.
+        # Corresponds to the JSON property `hasExternalEdges`
+        # @return [Boolean]
+        attr_accessor :has_external_edges
+        alias_method :has_external_edges?, :has_external_edges
+      
+        # When has_external_edges is true, the polygon has some edges that border
+        # another feature. This field indicates the internal edges that do not border
+        # another feature. Each value is an index into the vertices array, and denotes
+        # the start vertex of the internal edge (the next vertex in the boundary loop is
+        # the end of the edge). If the selected vertex is the last vertex in the
+        # boundary loop, then the edge between that vertex and the starting vertex of
+        # the loop is internal. This field may be used for styling. For example,
+        # building parapets could be placed only on the external edges of a building
+        # polygon, or water could be lighter colored near the external edges of a body
+        # of water. If has_external_edges is false, all edges are internal and this
+        # field will be empty.
+        # Corresponds to the JSON property `internalEdges`
+        # @return [Array<Fixnum>]
+        attr_accessor :internal_edges
+      
+        # Identifies the boundary loops of the polygon. Only set for INDEXED_TRIANGLE
+        # polygons. Each value is an index into the vertices array indicating the
+        # beginning of a loop. For instance, values of [2, 5] would indicate loop_data
+        # contained 3 loops with indices 0-1, 2-4, and 5-end. This may be used in
+        # conjunction with the internal_edges field for styling polygon boundaries. Note
+        # that an edge may be on a polygon boundary but still internal to the feature.
+        # For example, a feature split across multiple tiles will have an internal
+        # polygon boundary edge along the edge of the tile.
+        # Corresponds to the JSON property `loopBreaks`
+        # @return [Array<Fixnum>]
+        attr_accessor :loop_breaks
+      
+        # When the polygon encoding is of type INDEXED_TRIANGLES, this contains the
+        # indices of the triangle vertices in the vertex_offsets field. There are 3
+        # vertex indices per triangle.
+        # Corresponds to the JSON property `triangleIndices`
+        # @return [Array<Fixnum>]
+        attr_accessor :triangle_indices
+      
+        # The polygon encoding type used for this area.
+        # Corresponds to the JSON property `type`
+        # @return [String]
+        attr_accessor :type
+      
+        # 2D vertex list used for lines and areas. Each entry represents an offset from
+        # the previous one in local tile coordinates. The first entry is offset from (0,
+        # 0). For example, the list of vertices [(1,1), (2, 2), (1, 2)] would be encoded
+        # in vertex offsets as [(1, 1), (1, 1), (-1, 0)].
+        # Corresponds to the JSON property `vertexOffsets`
+        # @return [Google::Apis::VectortileV1::Vertex2DList]
+        attr_accessor :vertex_offsets
+      
+        # The z-ordering of this area. Areas with a lower z-order should be rendered
+        # beneath areas with a higher z-order. This z-ordering does not imply anything
+        # about the altitude of the line relative to the ground, but it can be used to
+        # prevent z-fighting during rendering on the client. This z-ordering can only be
+        # used to compare areas, and cannot be compared with the z_order field in the
+        # Line message. The z-order may be negative or zero. Prefer Area.basemap_z_order.
+        # Corresponds to the JSON property `zOrder`
+        # @return [Fixnum]
+        attr_accessor :z_order
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @basemap_z_order = args[:basemap_z_order] if args.key?(:basemap_z_order)
+          @has_external_edges = args[:has_external_edges] if args.key?(:has_external_edges)
+          @internal_edges = args[:internal_edges] if args.key?(:internal_edges)
+          @loop_breaks = args[:loop_breaks] if args.key?(:loop_breaks)
+          @triangle_indices = args[:triangle_indices] if args.key?(:triangle_indices)
+          @type = args[:type] if args.key?(:type)
+          @vertex_offsets = args[:vertex_offsets] if args.key?(:vertex_offsets)
+          @z_order = args[:z_order] if args.key?(:z_order)
+        end
+      end
+      
+      # Metadata necessary to determine the ordering of a particular basemap element
+      # relative to others. To render the basemap correctly, sort by z-plane, then z-
+      # grade, then z-within-grade.
+      class BasemapZOrder
+        include Google::Apis::Core::Hashable
+      
+        # The second most significant component of the ordering of a component to be
+        # rendered onto the basemap.
+        # Corresponds to the JSON property `zGrade`
+        # @return [Fixnum]
+        attr_accessor :z_grade
+      
+        # The most significant component of the ordering of a component to be rendered
+        # onto the basemap.
+        # Corresponds to the JSON property `zPlane`
+        # @return [Fixnum]
+        attr_accessor :z_plane
+      
+        # The least significant component of the ordering of a component to be rendered
+        # onto the basemap.
+        # Corresponds to the JSON property `zWithinGrade`
+        # @return [Fixnum]
+        attr_accessor :z_within_grade
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @z_grade = args[:z_grade] if args.key?(:z_grade)
+          @z_plane = args[:z_plane] if args.key?(:z_plane)
+          @z_within_grade = args[:z_within_grade] if args.key?(:z_within_grade)
+        end
+      end
+      
+      # Represents a height-extruded area: a 3D prism with a constant X-Y plane cross
+      # section. Used to represent extruded buildings. A single building may consist
+      # of several extruded areas. The min_z and max_z fields are scaled to the size
+      # of the tile. An extruded area with a max_z value of 4096 has the same height
+      # as the width of the tile that it is on.
+      class ExtrudedArea
+        include Google::Apis::Core::Hashable
+      
+        # Represents an area. Used to represent regions such as water, parks, etc. Next
+        # ID: 10
+        # Corresponds to the JSON property `area`
+        # @return [Google::Apis::VectortileV1::Area]
+        attr_accessor :area
+      
+        # The z-value in local tile coordinates where the extruded area ends.
+        # Corresponds to the JSON property `maxZ`
+        # @return [Fixnum]
+        attr_accessor :max_z
+      
+        # The z-value in local tile coordinates where the extruded area begins. This is
+        # non-zero for extruded areas that begin off the ground. For example, a building
+        # with a skybridge may have an extruded area component with a non-zero min_z.
+        # Corresponds to the JSON property `minZ`
+        # @return [Fixnum]
+        attr_accessor :min_z
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @area = args[:area] if args.key?(:area)
+          @max_z = args[:max_z] if args.key?(:max_z)
+          @min_z = args[:min_z] if args.key?(:min_z)
+        end
+      end
+      
+      # A feature representing a single geographic entity.
+      class Feature
+        include Google::Apis::Core::Hashable
+      
+        # The localized name of this feature. Currently only returned for roads.
+        # Corresponds to the JSON property `displayName`
+        # @return [String]
+        attr_accessor :display_name
+      
+        # Represents the geometry of a feature, that is, the shape that it has on the
+        # map. The local tile coordinate system has the origin at the north-west (upper-
+        # left) corner of the tile, and is scaled to 4096 units across each edge. The
+        # height (Z) axis has the same scale factor: an extruded area with a max_z value
+        # of 4096 has the same height as the width of the tile that it is on. There is
+        # no clipping boundary, so it is possible that some coordinates will lie outside
+        # the tile boundaries.
+        # Corresponds to the JSON property `geometry`
+        # @return [Google::Apis::VectortileV1::Geometry]
+        attr_accessor :geometry
+      
+        # Place ID of this feature, suitable for use in Places API details requests.
+        # Corresponds to the JSON property `placeId`
+        # @return [String]
+        attr_accessor :place_id
+      
+        # Relations to other features.
+        # Corresponds to the JSON property `relations`
+        # @return [Array<Google::Apis::VectortileV1::Relation>]
+        attr_accessor :relations
+      
+        # Extra metadata relating to segments.
+        # Corresponds to the JSON property `segmentInfo`
+        # @return [Google::Apis::VectortileV1::SegmentInfo]
+        attr_accessor :segment_info
+      
+        # The type of this feature.
+        # Corresponds to the JSON property `type`
+        # @return [String]
+        attr_accessor :type
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @display_name = args[:display_name] if args.key?(:display_name)
+          @geometry = args[:geometry] if args.key?(:geometry)
+          @place_id = args[:place_id] if args.key?(:place_id)
+          @relations = args[:relations] if args.key?(:relations)
+          @segment_info = args[:segment_info] if args.key?(:segment_info)
+          @type = args[:type] if args.key?(:type)
+        end
+      end
+      
+      # A tile containing information about the map features located in the region it
+      # covers.
+      class FeatureTile
+        include Google::Apis::Core::Hashable
+      
+        # Global tile coordinates. Global tile coordinates reference a specific tile on
+        # the map at a specific zoom level. The origin of this coordinate system is
+        # always at the northwest corner of the map, with x values increasing from west
+        # to east and y values increasing from north to south. Tiles are indexed using x,
+        # y coordinates from that origin. The zoom level containing the entire world in
+        # a tile is 0, and it increases as you zoom in. Zoom level n + 1 will contain 4
+        # times as many tiles as zoom level n. The zoom level controls the level of
+        # detail of the data that is returned. In particular, this affects the set of
+        # feature types returned, their density, and geometry simplification. The exact
+        # tile contents may change over time, but care will be taken to keep supporting
+        # the most important use cases. For example, zoom level 15 shows roads for
+        # orientation and planning in the local neighborhood and zoom level 17 shows
+        # buildings to give users on foot a sense of situational awareness.
+        # Corresponds to the JSON property `coordinates`
+        # @return [Google::Apis::VectortileV1::TileCoordinates]
+        attr_accessor :coordinates
+      
+        # Features present on this map tile.
+        # Corresponds to the JSON property `features`
+        # @return [Array<Google::Apis::VectortileV1::Feature>]
+        attr_accessor :features
+      
+        # Resource name of the tile. The tile resource name is prefixed by its
+        # collection ID `tiles/` followed by the resource ID, which encodes the tile's
+        # global x and y coordinates and zoom level as `@,,z`. For example, `tiles/@1,2,
+        # 3z`.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # Data providers for the data contained in this tile.
+        # Corresponds to the JSON property `providers`
+        # @return [Array<Google::Apis::VectortileV1::ProviderInfo>]
+        attr_accessor :providers
+      
+        # Tile response status code to support tile caching.
+        # Corresponds to the JSON property `status`
+        # @return [String]
+        attr_accessor :status
+      
+        # An opaque value, usually less than 30 characters, that contains version info
+        # about this tile and the data that was used to generate it. The client should
+        # store this value in its tile cache and pass it back to the API in the
+        # client_tile_version_id field of subsequent tile requests in order to enable
+        # the API to detect when the new tile would be the same as the one the client
+        # already has in its cache. Also see STATUS_OK_DATA_UNCHANGED.
+        # Corresponds to the JSON property `versionId`
+        # @return [String]
+        attr_accessor :version_id
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @coordinates = args[:coordinates] if args.key?(:coordinates)
+          @features = args[:features] if args.key?(:features)
+          @name = args[:name] if args.key?(:name)
+          @providers = args[:providers] if args.key?(:providers)
+          @status = args[:status] if args.key?(:status)
+          @version_id = args[:version_id] if args.key?(:version_id)
+        end
+      end
+      
+      # A packed representation of a 2D grid of uniformly spaced points containing
+      # elevation data. Each point within the grid represents the altitude in meters
+      # above average sea level at that location within the tile. Elevations provided
+      # are (generally) relative to the EGM96 geoid, however some areas will be
+      # relative to NAVD88. EGM96 and NAVD88 are off by no more than 2 meters. The
+      # grid is oriented north-west to south-east, as illustrated: rows[0].a[0] rows[0]
+      # .a[m] +-----------------+ | | | N | | ^ | | | | | W <-----> E | | | | | v | |
+      # S | | | +-----------------+ rows[n].a[0] rows[n].a[m] Rather than storing the
+      # altitudes directly, we store the diffs between them as integers at some
+      # requested level of precision to take advantage of integer packing. The actual
+      # altitude values a[] can be reconstructed using the scale and each row's
+      # first_altitude and altitude_diff fields.
+      class FirstDerivativeElevationGrid
+        include Google::Apis::Core::Hashable
+      
+        # A multiplier applied to the altitude fields below to extract the actual
+        # altitudes in meters from the elevation grid.
+        # Corresponds to the JSON property `altitudeMultiplier`
+        # @return [Float]
+        attr_accessor :altitude_multiplier
+      
+        # Rows of points containing altitude data making up the elevation grid. Each row
+        # is the same length. Rows are ordered from north to south. E.g: rows[0] is the
+        # north-most row, and rows[n] is the south-most row.
+        # Corresponds to the JSON property `rows`
+        # @return [Array<Google::Apis::VectortileV1::Row>]
+        attr_accessor :rows
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @altitude_multiplier = args[:altitude_multiplier] if args.key?(:altitude_multiplier)
+          @rows = args[:rows] if args.key?(:rows)
+        end
+      end
+      
+      # Represents the geometry of a feature, that is, the shape that it has on the
+      # map. The local tile coordinate system has the origin at the north-west (upper-
+      # left) corner of the tile, and is scaled to 4096 units across each edge. The
+      # height (Z) axis has the same scale factor: an extruded area with a max_z value
+      # of 4096 has the same height as the width of the tile that it is on. There is
+      # no clipping boundary, so it is possible that some coordinates will lie outside
+      # the tile boundaries.
+      class Geometry
+        include Google::Apis::Core::Hashable
+      
+        # The areas present in this geometry.
+        # Corresponds to the JSON property `areas`
+        # @return [Array<Google::Apis::VectortileV1::Area>]
+        attr_accessor :areas
+      
+        # The extruded areas present in this geometry.
+        # Corresponds to the JSON property `extrudedAreas`
+        # @return [Array<Google::Apis::VectortileV1::ExtrudedArea>]
+        attr_accessor :extruded_areas
+      
+        # The lines present in this geometry.
+        # Corresponds to the JSON property `lines`
+        # @return [Array<Google::Apis::VectortileV1::Line>]
+        attr_accessor :lines
+      
+        # The modeled volumes present in this geometry.
+        # Corresponds to the JSON property `modeledVolumes`
+        # @return [Array<Google::Apis::VectortileV1::ModeledVolume>]
+        attr_accessor :modeled_volumes
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @areas = args[:areas] if args.key?(:areas)
+          @extruded_areas = args[:extruded_areas] if args.key?(:extruded_areas)
+          @lines = args[:lines] if args.key?(:lines)
+          @modeled_volumes = args[:modeled_volumes] if args.key?(:modeled_volumes)
+        end
+      end
+      
+      # Represents a 2D polyline. Used to represent segments such as roads, train
+      # tracks, etc.
+      class Line
+        include Google::Apis::Core::Hashable
+      
+        # Metadata necessary to determine the ordering of a particular basemap element
+        # relative to others. To render the basemap correctly, sort by z-plane, then z-
+        # grade, then z-within-grade.
+        # Corresponds to the JSON property `basemapZOrder`
+        # @return [Google::Apis::VectortileV1::BasemapZOrder]
+        attr_accessor :basemap_z_order
+      
+        # 2D vertex list used for lines and areas. Each entry represents an offset from
+        # the previous one in local tile coordinates. The first entry is offset from (0,
+        # 0). For example, the list of vertices [(1,1), (2, 2), (1, 2)] would be encoded
+        # in vertex offsets as [(1, 1), (1, 1), (-1, 0)].
+        # Corresponds to the JSON property `vertexOffsets`
+        # @return [Google::Apis::VectortileV1::Vertex2DList]
+        attr_accessor :vertex_offsets
+      
+        # The z-order of the line. Lines with a lower z-order should be rendered beneath
+        # lines with a higher z-order. This z-ordering does not imply anything about the
+        # altitude of the area relative to the ground, but it can be used to prevent z-
+        # fighting during rendering on the client. In general, larger and more important
+        # road features will have a higher z-order line associated with them. This z-
+        # ordering can only be used to compare lines, and cannot be compared with the
+        # z_order field in the Area message. The z-order may be negative or zero. Prefer
+        # Line.basemap_z_order.
+        # Corresponds to the JSON property `zOrder`
+        # @return [Fixnum]
+        attr_accessor :z_order
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @basemap_z_order = args[:basemap_z_order] if args.key?(:basemap_z_order)
+          @vertex_offsets = args[:vertex_offsets] if args.key?(:vertex_offsets)
+          @z_order = args[:z_order] if args.key?(:z_order)
+        end
+      end
+      
+      # Represents a modeled volume in 3D space. Used to represent 3D buildings.
+      class ModeledVolume
+        include Google::Apis::Core::Hashable
+      
+        # The triangle strips present in this mesh.
+        # Corresponds to the JSON property `strips`
+        # @return [Array<Google::Apis::VectortileV1::TriangleStrip>]
+        attr_accessor :strips
+      
+        # 3D vertex list used for modeled volumes. Each entry represents an offset from
+        # the previous one in local tile coordinates. The first coordinate is offset
+        # from (0, 0, 0).
+        # Corresponds to the JSON property `vertexOffsets`
+        # @return [Google::Apis::VectortileV1::Vertex3DList]
+        attr_accessor :vertex_offsets
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @strips = args[:strips] if args.key?(:strips)
+          @vertex_offsets = args[:vertex_offsets] if args.key?(:vertex_offsets)
+        end
+      end
+      
+      # Information about the data providers that should be included in the
+      # attribution string shown by the client.
+      class ProviderInfo
+        include Google::Apis::Core::Hashable
+      
+        # Attribution string for this provider. This string is not localized.
+        # Corresponds to the JSON property `description`
+        # @return [String]
+        attr_accessor :description
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @description = args[:description] if args.key?(:description)
+        end
+      end
+      
+      # Represents a relation to another feature in the tile. For example, a building
+      # might be occupied by a given POI. The related feature can be retrieved using
+      # the related feature index.
+      class Relation
+        include Google::Apis::Core::Hashable
+      
+        # Zero-based index to look up the related feature from the list of features in
+        # the tile.
+        # Corresponds to the JSON property `relatedFeatureIndex`
+        # @return [Fixnum]
+        attr_accessor :related_feature_index
+      
+        # Relation type between the origin feature to the related feature.
+        # Corresponds to the JSON property `relationType`
+        # @return [String]
+        attr_accessor :relation_type
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @related_feature_index = args[:related_feature_index] if args.key?(:related_feature_index)
+          @relation_type = args[:relation_type] if args.key?(:relation_type)
+        end
+      end
+      
+      # Extra metadata relating to roads.
+      class RoadInfo
+        include Google::Apis::Core::Hashable
+      
+        # Road has signage discouraging or prohibiting use by the general public. E.g.,
+        # roads with signs that say "Private", or "No trespassing."
+        # Corresponds to the JSON property `isPrivate`
+        # @return [Boolean]
+        attr_accessor :is_private
+        alias_method :is_private?, :is_private
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @is_private = args[:is_private] if args.key?(:is_private)
+        end
+      end
+      
+      # A row of altitude points in the elevation grid, ordered from west to east.
+      class Row
+        include Google::Apis::Core::Hashable
+      
+        # The difference between each successive pair of altitudes, from west to east.
+        # The first, westmost point, is just the altitude rather than a diff. The units
+        # are specified by the altitude_multiplier parameter above; the value in meters
+        # is given by altitude_multiplier * altitude_diffs[n]. The altitude row (in
+        # metres above sea level) can be reconstructed with: a[0] = altitude_diffs[0] *
+        # altitude_multiplier when n > 0, a[n] = a[n-1] + altitude_diffs[n-1] *
+        # altitude_multiplier.
+        # Corresponds to the JSON property `altitudeDiffs`
+        # @return [Array<Fixnum>]
+        attr_accessor :altitude_diffs
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @altitude_diffs = args[:altitude_diffs] if args.key?(:altitude_diffs)
+        end
+      end
+      
+      # A packed representation of a 2D grid of uniformly spaced points containing
+      # elevation data. Each point within the grid represents the altitude in meters
+      # above average sea level at that location within the tile. Elevations provided
+      # are (generally) relative to the EGM96 geoid, however some areas will be
+      # relative to NAVD88. EGM96 and NAVD88 are off by no more than 2 meters. The
+      # grid is oriented north-west to south-east, as illustrated: rows[0].a[0] rows[0]
+      # .a[m] +-----------------+ | | | N | | ^ | | | | | W <-----> E | | | | | v | |
+      # S | | | +-----------------+ rows[n].a[0] rows[n].a[m] Rather than storing the
+      # altitudes directly, we store the diffs of the diffs between them as integers
+      # at some requested level of precision to take advantage of integer packing.
+      # Note that the data is packed in such a way that is fast to decode in Unity and
+      # that further optimizes wire size.
+      class SecondDerivativeElevationGrid
+        include Google::Apis::Core::Hashable
+      
+        # A multiplier applied to the elements in the encoded data to extract the actual
+        # altitudes in meters.
+        # Corresponds to the JSON property `altitudeMultiplier`
+        # @return [Float]
+        attr_accessor :altitude_multiplier
+      
+        # The number of columns included in the encoded elevation data (i.e. the
+        # horizontal resolution of the grid).
+        # Corresponds to the JSON property `columnCount`
+        # @return [Fixnum]
+        attr_accessor :column_count
+      
+        # A stream of elements each representing a point on the tile running across each
+        # row from left to right, top to bottom. There will be precisely
+        # horizontal_resolution * vertical_resolution elements in the stream. The
+        # elements are not the heights, rather the second order derivative of the values
+        # one would expect in a stream of height data. Each element is a varint with the
+        # following encoding: -----------------------------------------------------------
+        # -------------| | Head Nibble | ------------------------------------------------
+        # ------------------------| | Bit 0 | Bit 1 | Bits 2-3 | | Terminator| Sign (1=
+        # neg) | Least significant 2 bits of absolute error | ---------------------------
+        # ---------------------------------------------| | Tail Nibble #1 | -------------
+        # -----------------------------------------------------------| | Bit 0 | Bit 1-3
+        # | | Terminator| Least significant 3 bits of absolute error | ------------------
+        # ------------------------------------------------------| | ... | Tail Nibble #n
+        # | ------------------------------------------------------------------------| |
+        # Bit 0 | Bit 1-3 | | Terminator| Least significant 3 bits of absolute error | --
+        # ----------------------------------------------------------------------|
+        # Corresponds to the JSON property `encodedData`
+        # NOTE: Values are automatically base64 encoded/decoded in the client library.
+        # @return [String]
+        attr_accessor :encoded_data
+      
+        # The number of rows included in the encoded elevation data (i.e. the vertical
+        # resolution of the grid).
+        # Corresponds to the JSON property `rowCount`
+        # @return [Fixnum]
+        attr_accessor :row_count
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @altitude_multiplier = args[:altitude_multiplier] if args.key?(:altitude_multiplier)
+          @column_count = args[:column_count] if args.key?(:column_count)
+          @encoded_data = args[:encoded_data] if args.key?(:encoded_data)
+          @row_count = args[:row_count] if args.key?(:row_count)
+        end
+      end
+      
+      # Extra metadata relating to segments.
+      class SegmentInfo
+        include Google::Apis::Core::Hashable
+      
+        # Extra metadata relating to roads.
+        # Corresponds to the JSON property `roadInfo`
+        # @return [Google::Apis::VectortileV1::RoadInfo]
+        attr_accessor :road_info
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @road_info = args[:road_info] if args.key?(:road_info)
+        end
+      end
+      
+      # A tile containing information about the terrain located in the region it
+      # covers.
+      class TerrainTile
+        include Google::Apis::Core::Hashable
+      
+        # Global tile coordinates. Global tile coordinates reference a specific tile on
+        # the map at a specific zoom level. The origin of this coordinate system is
+        # always at the northwest corner of the map, with x values increasing from west
+        # to east and y values increasing from north to south. Tiles are indexed using x,
+        # y coordinates from that origin. The zoom level containing the entire world in
+        # a tile is 0, and it increases as you zoom in. Zoom level n + 1 will contain 4
+        # times as many tiles as zoom level n. The zoom level controls the level of
+        # detail of the data that is returned. In particular, this affects the set of
+        # feature types returned, their density, and geometry simplification. The exact
+        # tile contents may change over time, but care will be taken to keep supporting
+        # the most important use cases. For example, zoom level 15 shows roads for
+        # orientation and planning in the local neighborhood and zoom level 17 shows
+        # buildings to give users on foot a sense of situational awareness.
+        # Corresponds to the JSON property `coordinates`
+        # @return [Google::Apis::VectortileV1::TileCoordinates]
+        attr_accessor :coordinates
+      
+        # A packed representation of a 2D grid of uniformly spaced points containing
+        # elevation data. Each point within the grid represents the altitude in meters
+        # above average sea level at that location within the tile. Elevations provided
+        # are (generally) relative to the EGM96 geoid, however some areas will be
+        # relative to NAVD88. EGM96 and NAVD88 are off by no more than 2 meters. The
+        # grid is oriented north-west to south-east, as illustrated: rows[0].a[0] rows[0]
+        # .a[m] +-----------------+ | | | N | | ^ | | | | | W <-----> E | | | | | v | |
+        # S | | | +-----------------+ rows[n].a[0] rows[n].a[m] Rather than storing the
+        # altitudes directly, we store the diffs between them as integers at some
+        # requested level of precision to take advantage of integer packing. The actual
+        # altitude values a[] can be reconstructed using the scale and each row's
+        # first_altitude and altitude_diff fields.
+        # Corresponds to the JSON property `firstDerivative`
+        # @return [Google::Apis::VectortileV1::FirstDerivativeElevationGrid]
+        attr_accessor :first_derivative
+      
+        # Resource name of the tile. The tile resource name is prefixed by its
+        # collection ID `terrain/` followed by the resource ID, which encodes the tile's
+        # global x and y coordinates and zoom level as `@,,z`. For example, `terrain/@1,
+        # 2,3z`.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # A packed representation of a 2D grid of uniformly spaced points containing
+        # elevation data. Each point within the grid represents the altitude in meters
+        # above average sea level at that location within the tile. Elevations provided
+        # are (generally) relative to the EGM96 geoid, however some areas will be
+        # relative to NAVD88. EGM96 and NAVD88 are off by no more than 2 meters. The
+        # grid is oriented north-west to south-east, as illustrated: rows[0].a[0] rows[0]
+        # .a[m] +-----------------+ | | | N | | ^ | | | | | W <-----> E | | | | | v | |
+        # S | | | +-----------------+ rows[n].a[0] rows[n].a[m] Rather than storing the
+        # altitudes directly, we store the diffs of the diffs between them as integers
+        # at some requested level of precision to take advantage of integer packing.
+        # Note that the data is packed in such a way that is fast to decode in Unity and
+        # that further optimizes wire size.
+        # Corresponds to the JSON property `secondDerivative`
+        # @return [Google::Apis::VectortileV1::SecondDerivativeElevationGrid]
+        attr_accessor :second_derivative
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @coordinates = args[:coordinates] if args.key?(:coordinates)
+          @first_derivative = args[:first_derivative] if args.key?(:first_derivative)
+          @name = args[:name] if args.key?(:name)
+          @second_derivative = args[:second_derivative] if args.key?(:second_derivative)
+        end
+      end
+      
+      # Global tile coordinates. Global tile coordinates reference a specific tile on
+      # the map at a specific zoom level. The origin of this coordinate system is
+      # always at the northwest corner of the map, with x values increasing from west
+      # to east and y values increasing from north to south. Tiles are indexed using x,
+      # y coordinates from that origin. The zoom level containing the entire world in
+      # a tile is 0, and it increases as you zoom in. Zoom level n + 1 will contain 4
+      # times as many tiles as zoom level n. The zoom level controls the level of
+      # detail of the data that is returned. In particular, this affects the set of
+      # feature types returned, their density, and geometry simplification. The exact
+      # tile contents may change over time, but care will be taken to keep supporting
+      # the most important use cases. For example, zoom level 15 shows roads for
+      # orientation and planning in the local neighborhood and zoom level 17 shows
+      # buildings to give users on foot a sense of situational awareness.
+      class TileCoordinates
+        include Google::Apis::Core::Hashable
+      
+        # Required. The x coordinate.
+        # Corresponds to the JSON property `x`
+        # @return [Fixnum]
+        attr_accessor :x
+      
+        # Required. The y coordinate.
+        # Corresponds to the JSON property `y`
+        # @return [Fixnum]
+        attr_accessor :y
+      
+        # Required. The Google Maps API zoom level.
+        # Corresponds to the JSON property `zoom`
+        # @return [Fixnum]
+        attr_accessor :zoom
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @x = args[:x] if args.key?(:x)
+          @y = args[:y] if args.key?(:y)
+          @zoom = args[:zoom] if args.key?(:zoom)
+        end
+      end
+      
+      # Represents a strip of triangles. Each triangle uses the last edge of the
+      # previous one. The following diagram shows an example of a triangle strip, with
+      # each vertex labeled with its index in the vertex_index array. (1)-----(3) / \ /
+      # \ / \ / \ / \ / \ (0)-----(2)-----(4) Vertices may be in either clockwise or
+      # counter-clockwise order.
+      class TriangleStrip
+        include Google::Apis::Core::Hashable
+      
+        # Index into the vertex_offset array representing the next vertex in the
+        # triangle strip.
+        # Corresponds to the JSON property `vertexIndices`
+        # @return [Array<Fixnum>]
+        attr_accessor :vertex_indices
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @vertex_indices = args[:vertex_indices] if args.key?(:vertex_indices)
+        end
+      end
+      
+      # 2D vertex list used for lines and areas. Each entry represents an offset from
+      # the previous one in local tile coordinates. The first entry is offset from (0,
+      # 0). For example, the list of vertices [(1,1), (2, 2), (1, 2)] would be encoded
+      # in vertex offsets as [(1, 1), (1, 1), (-1, 0)].
+      class Vertex2DList
+        include Google::Apis::Core::Hashable
+      
+        # List of x-offsets in local tile coordinates.
+        # Corresponds to the JSON property `xOffsets`
+        # @return [Array<Fixnum>]
+        attr_accessor :x_offsets
+      
+        # List of y-offsets in local tile coordinates.
+        # Corresponds to the JSON property `yOffsets`
+        # @return [Array<Fixnum>]
+        attr_accessor :y_offsets
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @x_offsets = args[:x_offsets] if args.key?(:x_offsets)
+          @y_offsets = args[:y_offsets] if args.key?(:y_offsets)
+        end
+      end
+      
+      # 3D vertex list used for modeled volumes. Each entry represents an offset from
+      # the previous one in local tile coordinates. The first coordinate is offset
+      # from (0, 0, 0).
+      class Vertex3DList
+        include Google::Apis::Core::Hashable
+      
+        # List of x-offsets in local tile coordinates.
+        # Corresponds to the JSON property `xOffsets`
+        # @return [Array<Fixnum>]
+        attr_accessor :x_offsets
+      
+        # List of y-offsets in local tile coordinates.
+        # Corresponds to the JSON property `yOffsets`
+        # @return [Array<Fixnum>]
+        attr_accessor :y_offsets
+      
+        # List of z-offsets in local tile coordinates.
+        # Corresponds to the JSON property `zOffsets`
+        # @return [Array<Fixnum>]
+        attr_accessor :z_offsets
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @x_offsets = args[:x_offsets] if args.key?(:x_offsets)
+          @y_offsets = args[:y_offsets] if args.key?(:y_offsets)
+          @z_offsets = args[:z_offsets] if args.key?(:z_offsets)
+        end
+      end
+    end
+  end
+end