google-maps-platform-sdk 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ad09d10352ee3d9940a0c508939350da344142ed26ad26df0dbaf08bf28da98c
+  data.tar.gz: c0ed41a4f1f36b6975fe444fc0a50a33717e65c6eeb803fb09943ec782f6e18e
+SHA512:
+  metadata.gz: 0b7e11145415b5671aea38b5be2ff41526fddd18f97ddd15c008c186cf6b730d8f9e7d5cc22a6f515488e3e3a7045290cea366dfe3610ca065cc46ed23de02f8
+  data.tar.gz: f81232f8077101c1c1ee22a03a0cc641de54a11ec405215aceefd221cc75e5311ccbe66c8e2e4c2b6b269ca3e48c2f6d2a671b86bf2f0491252a482cb6822e2b

data/LICENSE

@@ -0,0 +1,28 @@
+License: 
+========
+The MIT License (MIT)
+http://opensource.org/licenses/MIT
+
+Copyright (c) 2014 - 2026 APIMATIC Limited
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+Trade Mark:
+==========
+APIMATIC is a trade mark for APIMATIC Limited

data/README.md

@@ -0,0 +1,169 @@
+
+# Getting Started with Google Maps Platform
+
+## Introduction
+
+API Specification for Google Maps Platform
+
+## Install the Package
+
+Install the gem from the command line:
+
+```bash
+gem install google-maps-platform-sdk -v 1.0.0
+```
+
+Or add the gem to your Gemfile and run `bundle`:
+
+```ruby
+gem 'google-maps-platform-sdk', '1.0.0'
+```
+
+For additional gem details, see the [RubyGems page for the google-maps-platform-sdk gem](https://rubygems.org/gems/google-maps-platform-sdk/versions/1.0.0).
+
+## IRB Console Usage
+
+You can explore the SDK interactively using IRB in two ways
+
+### 1. Use IRB with Installed Gem
+
+Open your system terminal (Command Prompt, Git Bash or macOS Terminal) and type the following command to start the irb console.
+
+```bash
+irb
+```
+
+Now you can load the SDK in the IRB
+
+```ruby
+require 'google_maps_platform'
+include GoogleMapsPlatform
+```
+
+### 2. Use IRB within SDK
+
+Open your system terminal (Command Prompt, Git Bash or macOS Terminal) and navigate to the root folder of SDK.
+
+```
+cd path/to/google_maps_platform
+```
+
+Now you can start the preconfigured irb console by running the following command
+
+```bash
+ruby bin/console
+```
+
+**_Note:_** This automatically loads the SDK from lib/
+
+## Initialize the API Client
+
+**_Note:_** Documentation for the client can be found [here.](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/client.md)
+
+The following parameters are configurable for the API Client:
+
+| Parameter | Type | Description |
+|  --- | --- | --- |
+| environment | [`Environment`](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/README.md#environments) | The API environment. <br> **Default: `Environment.PRODUCTION`** |
+| connection | `Faraday::Connection` | The Faraday connection object passed by the SDK user for making requests |
+| adapter | `Faraday::Adapter` | The Faraday adapter object passed by the SDK user for performing http requests |
+| timeout | `Float` | The value to use for connection timeout. <br> **Default: 30** |
+| max_retries | `Integer` | The number of times to retry an endpoint call if it fails. <br> **Default: 0** |
+| retry_interval | `Float` | Pause in seconds between retries. <br> **Default: 1** |
+| backoff_factor | `Float` | The amount to multiply each successive retry's interval amount by in order to provide backoff. <br> **Default: 2** |
+| retry_statuses | `Array` | A list of HTTP statuses to retry. <br> **Default: [408, 413, 429, 500, 502, 503, 504, 521, 522, 524]** |
+| retry_methods | `Array` | A list of HTTP methods to retry. <br> **Default: %i[get put]** |
+| http_callback | `HttpCallBack` | The Http CallBack allows defining callables for pre and post API calls. |
+| proxy_settings | [`ProxySettings`](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/proxy-settings.md) | Optional proxy configuration to route HTTP requests through a proxy server. |
+| logging_configuration | [`LoggingConfiguration`](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/logging-configuration.md) | The SDK logging configuration for API calls |
+| custom_query_authentication_credentials | [`CustomQueryAuthenticationCredentials`](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/auth/custom-query-parameter.md) | The credential object for Custom Query Parameter |
+
+The API client can be initialized as follows:
+
+### Code-Based Client Initialization
+
+```ruby
+require 'google_maps_platform'
+include GoogleMapsPlatform
+
+client = Client.new(
+  custom_query_authentication_credentials: CustomQueryAuthenticationCredentials.new(
+    key: 'key'
+  ),
+  environment: Environment::PRODUCTION,
+  logging_configuration: LoggingConfiguration.new(
+    log_level: Logger::INFO,
+    request_logging_config: RequestLoggingConfiguration.new(
+      log_body: true
+    ),
+    response_logging_config: ResponseLoggingConfiguration.new(
+      log_headers: true
+    )
+  )
+)
+```
+
+### Environment-Based Client Initialization
+
+```ruby
+require 'google_maps_platform'
+include GoogleMapsPlatform
+
+# Create client from environment
+client = Client.from_env
+```
+
+See the [`Environment-Based Client Initialization`](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/environment-based-client-initialization.md) section for details.
+
+## Environments
+
+The SDK can be configured to use a different environment for making API calls. Available environments are:
+
+### Fields
+
+| Name | Description |
+|  --- | --- |
+| PRODUCTION | **Default** |
+| ENVIRONMENT2 | - |
+| ENVIRONMENT3 | - |
+
+## Authorization
+
+This API uses the following authentication schemes.
+
+* [`ApiKeyAuth (Custom Query Parameter)`](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/auth/custom-query-parameter.md)
+
+## List of APIs
+
+* [Geolocation API](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/controllers/geolocation-api.md)
+* [Directions API](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/controllers/directions-api.md)
+* [Elevation API](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/controllers/elevation-api.md)
+* [Geocoding API](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/controllers/geocoding-api.md)
+* [Time Zone API](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/controllers/time-zone-api.md)
+* [Roads API](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/controllers/roads-api.md)
+* [Distance Matrix API](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/controllers/distance-matrix-api.md)
+* [Places API](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/controllers/places-api.md)
+* [Street View API](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/controllers/street-view-api.md)
+
+## SDK Infrastructure
+
+### Configuration
+
+* [ProxySettings](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/proxy-settings.md)
+* [Environment-Based Client Initialization](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/environment-based-client-initialization.md)
+* [AbstractLogger](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/abstract-logger.md)
+* [LoggingConfiguration](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/logging-configuration.md)
+* [RequestLoggingConfiguration](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/request-logging-configuration.md)
+* [ResponseLoggingConfiguration](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/response-logging-configuration.md)
+
+### HTTP
+
+* [HttpResponse](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/http-response.md)
+* [HttpRequest](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/http-request.md)
+
+### Utilities
+
+* [ApiResponse](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/api-response.md)
+* [ApiHelper](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/api-helper.md)
+* [DateTimeHelper](https://www.github.com/sdks-io/google-maps-platform-ruby-sdk/tree/1.0.0/doc/date-time-helper.md)
+

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+# Load the lib folder into Ruby's load path
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+
+# Require the gem
+require 'google_maps_platform'
+
+puts 'GoogleMapsPlatform SDK loaded!'
+puts 'You can now create a client with: client = GoogleMapsPlatform::Client.new'
+puts 'Or use from_env: client = GoogleMapsPlatform::Client.from_env'
+
+# Start an interactive IRB session
+require 'irb'
+IRB.start

data/lib/google_maps_platform/api_helper.rb

@@ -0,0 +1,10 @@
+# google_maps_platform
+#
+# This file was automatically generated by APIMATIC
+# v3.0 ( https://www.apimatic.io ).
+
+module GoogleMapsPlatform
+  # API utility class
+  class APIHelper < CoreLibrary::ApiHelper
+  end
+end

data/lib/google_maps_platform/apis/base_api.rb

@@ -0,0 +1,67 @@
+# google_maps_platform
+#
+# This file was automatically generated by APIMATIC
+# v3.0 ( https://www.apimatic.io ).
+
+module GoogleMapsPlatform
+  # BaseApi.
+  class BaseApi
+    include CoreLibrary
+    attr_accessor :config, :http_call_back
+
+    def self.user_agent
+      'Ruby-SDK/1.0.0 (OS: {os-info}, Engine: {engine}/{engine-version})'
+    end
+
+    def self.user_agent_parameters
+      {
+        '{engine}' => { 'value' => RUBY_ENGINE, 'encode' => false },
+        '{engine-version}' => { 'value' => RUBY_ENGINE_VERSION, 'encode' => false },
+        '{os-info}' => { 'value' => RUBY_PLATFORM, 'encode' => false }
+      }
+    end
+
+    GLOBAL_ERRORS = {
+      'default' => ErrorCase.new
+                            .error_message('HTTP response not OK.')
+                            .exception_type(APIException)
+    }.freeze
+
+    # Initialization constructor.
+    # @param [GlobalConfiguration] global_configuration The instance of GlobalConfiguration.
+    def initialize(global_configuration)
+      @global_configuration = global_configuration
+      @config = @global_configuration.client_configuration
+      @http_call_back = @config.http_callback
+      @api_call = ApiCall.new(@global_configuration)
+    end
+
+    # Creates a new instance of the request builder.
+    # @param [String] http_method The HTTP method to use in the request.
+    # @param [String] path The endpoint path to use in the request.
+    # @param [String] server The server to extract the base uri for the request.
+    # @return [RequestBuilder] The instance of RequestBuilder.
+    def new_request_builder(http_method, path, server)
+      RequestBuilder.new
+                    .http_method(http_method)
+                    .path(path)
+                    .server(server)
+    end
+
+    # Creates a new instance of the response handler.
+    # @return [ResponseHandler] The instance of ResponseHandler.
+    def new_response_handler
+      ResponseHandler.new
+    end
+
+    # Creates a new instance of the parameter.
+    # @param [String|optional] key The key of the parameter.
+    # @param [Object] value The value of the parameter.
+    # @return [Parameter] The instance of Parameter.
+    def new_parameter(value, key: nil)
+      Parameter.new
+               .key(key)
+               .value(value)
+    end
+  end
+end

data/lib/google_maps_platform/apis/directions_api.rb

@@ -0,0 +1,341 @@
+# google_maps_platform
+#
+# This file was automatically generated by APIMATIC
+# v3.0 ( https://www.apimatic.io ).
+
+module GoogleMapsPlatform
+  # DirectionsApi
+  class DirectionsApi < BaseApi
+    # The Directions API is a web service that uses an HTTP request to return
+    # JSON or XML-formatted directions between locations. You can receive
+    # directions for several modes of transportation, such as transit, driving,
+    # walking, or cycling.
+    # @param [String] destination Required parameter: The place ID, address, or
+    # textual latitude/longitude value to which you wish to calculate
+    # directions. The options for the destination parameter are the same as for
+    # the origin parameter.
+    # @param [String] origin Required parameter: The place ID, address, or
+    # textual latitude/longitude value from which you wish to calculate
+    # directions. * Place IDs must be prefixed with `place_id:`. You can
+    # retrieve place IDs from the Geocoding API and the Places API (including
+    # Place Autocomplete). For an example using place IDs from Place
+    # Autocomplete, see [Place Autocomplete and
+    # Directions](https://developers.google.com/maps/documentation/javascript/ex
+    # amples/places-autocomplete-directions). For more about place IDs, see the
+    # [Place ID
+    # overview](https://developers.google.com/maps/documentation/places/web-serv
+    # ice/place-id).      ```   origin=place_id:ChIJ3S-JXmauEmsRUcIaWtf4MzE
+    # ```    * If you pass an address, the Directions service geocodes the
+    # string and converts it to a latitude/longitude coordinate to calculate
+    # directions. This coordinate may be different from that returned by the
+    # Geocoding API, for example a building entrance rather than its center.
+    #  ```   origin=24+Sussex+Drive+Ottawa+ON   ```      Using place IDs is
+    # preferred over using addresses or latitude/longitude coordinates. Using
+    # coordinates will always result in the point being snapped to the road
+    # nearest to those coordinates - which may not be an access point to the
+    # property, or even a road that will quickly or safely lead to the
+    # destination. * If you pass coordinates, the point will snap to the nearest
+    # road. Passing a place ID is preferred. If you do pass coordinates, ensure
+    # that no space exists between the latitude and longitude values.      ```
+    # origin=41.43206,-81.38992   ```  * Plus codes must be formatted as a
+    # global code or a compound code. Format plus codes as shown here (plus
+    # signs are url-escaped to `%2B` and spaces are url-escaped to `%20`).
+    # * **Global code** is a 4 character area code and 6 character or longer
+    # local code (849VCWC8+R9 is `849VCWC8%2BR9`).    * **Compound code** is a 6
+    # character or longer local code with an explicit location (CWC8+R9 Mountain
+    # View, CA, USA is `CWC8%2BR9%20Mountain%20View%20CA%20USA`).  <div
+    # class="note">Note: For efficiency and accuracy, use place ID's when
+    # possible. These ID's are uniquely explicit like a lat/lng value pair and
+    # provide geocoding benefits for routing such as access points and traffic
+    # variables. Unlike an address, ID's do not require the service to perform a
+    # search or an intermediate request for place details; therefore,
+    # performance is better.</div>
+    # @param [Float] arrival_time Optional parameter: Specifies the desired time
+    # of arrival for transit directions, in seconds since midnight, January 1,
+    # 1970 UTC. You can specify either `departure_time` or `arrival_time`, but
+    # not both. Note that `arrival_time` must be specified as an integer.
+    # @param [Float] departure_time Optional parameter: Specifies the desired
+    # time of departure. You can specify the time as an integer in seconds since
+    # midnight, January 1, 1970 UTC. If a `departure_time` later than
+    # 9999-12-31T23:59:59.999999999Z is specified, the API will fall back the
+    # `departure_time` to 9999-12-31T23:59:59.999999999Z. Alternatively, you can
+    # specify a value of now, which sets the departure time to the current time
+    # (correct to the nearest second). The departure time may be specified in
+    # two cases: * For requests where the travel mode is transit: You can
+    # optionally specify one of `departure_time` or `arrival_time`. If neither
+    # time is specified, the `departure_time` defaults to now (that is, the
+    # departure time defaults to the current time). * For requests where the
+    # travel mode is driving: You can specify the `departure_time` to receive a
+    # route and trip duration (response field: duration_in_traffic) that take
+    # traffic conditions into account. The `departure_time` must be set to the
+    # current time or some time in the future. It cannot be in the past.  <div
+    # class="note">Note: If departure time is not specified, choice of route and
+    # duration are based on road network and average time-independent traffic
+    # conditions. Results for a given request may vary over time due to changes
+    # in the road network, updated average traffic conditions, and the
+    # distributed nature of the service. Results may also vary between
+    # nearly-equivalent routes at any time or frequency.</div> <div
+    # class="note">Note: Distance Matrix requests specifying `departure_time`
+    # when `mode=driving` are limited to a maximum of 100 elements per request.
+    # The number of origins times the number of destinations defines the number
+    # of elements.</div>
+    # @param [TrueClass | FalseClass] alternatives Optional parameter: If set to
+    # `true`, specifies that the Directions service may provide more than one
+    # route alternative in the response. Note that providing route alternatives
+    # may increase the response time from the server. This is only available for
+    # requests without intermediate waypoints. For more information, see the
+    # [guide to
+    # waypoints](https://developers.google.com/maps/documentation/directions/get
+    # -directions#Waypoints).
+    # @param [String] avoid Optional parameter: Indicates that the calculated
+    # route(s) should avoid the indicated features. This parameter supports the
+    # following arguments: * `tolls` indicates that the calculated route should
+    # avoid toll roads/bridges. * `highways` indicates that the calculated route
+    # should avoid highways. * `ferries` indicates that the calculated route
+    # should avoid ferries. * `indoor` indicates that the calculated route
+    # should avoid indoor steps for walking and transit directions.  It's
+    # possible to request a route that avoids any combination of tolls, highways
+    # and ferries by passing multiple restrictions to the avoid parameter. For
+    # example:   ``` avoid=tolls|highways|ferries. ```
+    # @param [Units] units Optional parameter: Specifies the unit system to use
+    # when displaying results.  Directions results contain text within distance
+    # fields that may be displayed to the user to indicate the distance of a
+    # particular "step" of the route. By default, this text uses the unit system
+    # of the origin's country or region.  For example, a route from "Chicago,
+    # IL" to "Toronto, ONT" will display results in miles, while the reverse
+    # route will display results in kilometers. You may override this unit
+    # system by setting one explicitly within the request's units parameter,
+    # passing one of the following values:  * `metric` specifies usage of the
+    # metric system. Textual distances are returned using kilometers and meters.
+    # * `imperial` specifies usage of the Imperial (English) system. Textual
+    # distances are returned using miles and feet.  <div class="note">Note: this
+    # unit system setting only affects the text displayed within distance
+    # fields. The distance fields also contain values which are always expressed
+    # in meters.</div>
+    # @param [String] waypoints Optional parameter: <div
+    # class="caution">Caution: Requests using more than 10 waypoints (between 11
+    # and 25), or waypoint optimization, are billed at a higher rate. <a
+    # href="https://developers.google.com/maps/billing-and-pricing/pricing#direc
+    # tions-advanced">Learn more about billing</a> for Google Maps Platform
+    # products.</div>  Specifies an array of intermediate locations to include
+    # along the route between the origin and destination points as pass through
+    # or stopover locations. Waypoints alter a route by directing it through the
+    # specified location(s). The API supports waypoints for these travel modes:
+    # driving, walking and bicycling; not transit.   You can supply one or more
+    # locations separated by the pipe character (`|` or `%7C`), in the form of a
+    # place ID, an address, or latitude/longitude coordinates. By default, the
+    # Directions service calculates a route using the waypoints in the order
+    # they are given. The precedence for parsing the value of the waypoint is
+    # place ID, latitude/longitude coordinates, then address. * If you pass a
+    # place ID, you must prefix it with `place_id:`. You can retrieve place IDs
+    # from the Geocoding API and the Places API (including Place Autocomplete).
+    # For an example using place IDs from Place Autocomplete, see [Place
+    # Autocomplete and
+    # Directions](/maps/documentation/javascript/examples/places-autocomplete-di
+    # rections). For more about place IDs, see the [Place ID
+    # overview](/maps/documentation/places/web-service/place-id).   <div
+    # class="note">For efficiency and accuracy, use place ID's when possible.
+    # These ID's are uniquely explicit like a lat/lng value pair and provide
+    # geocoding benefits for routing such as access points and traffic
+    # variables. Unlike an address, ID's do not require the service to perform a
+    # search or an intermediate request for place details; therefore,
+    # performance is better.</div> * If you pass latitude/longitude coordinates,
+    # the values go directly to the front-end server to calculate directions
+    # without geocoding. The points are snapped to roads and might not provide
+    # the accuracy your app needs. Use coordinates when you are confident the
+    # values truly specify the points your app needs for routing without regard
+    # to possible access points or additional geocoding details. Ensure that a
+    # comma (`%2C`) and not a space (`%20`) separates the latitude and longitude
+    # values. * If you pass an address, the Directions service will geocode the
+    # string and convert it into latitude/longitude coordinates to calculate
+    # directions. If the address value is ambiguous, the value might evoke a
+    # search to disambiguate from similar addresses. For example, "1st Street"
+    # could be a complete value or a partial value for "1st street NE" or "1st
+    # St SE". This result may be different from that returned by the Geocoding
+    # API. You can avoid possible misinterpretations using place IDs. *
+    # Alternatively, you can supply an encoded set of points using the [Encoded
+    # Polyline
+    # Algorithm](https://developers.google.com/maps/documentation/utilities/poly
+    # linealgorithm). You will find an encoded set is useful for a large number
+    # of waypoints, because the URL is significantly shorter. All web services
+    # have a URL limit of 8192 characters.   * Encoded polylines must be
+    # prefixed with `enc:` and followed by a colon (`:`). For example:
+    # `waypoints=enc:gfo}EtohhU:`.   * You can also include multiple encoded
+    # polylines, separated by the pipe character (`|`). For example,
+    # `waypoints=via:enc:wc~oAwquwMdlTxiKtqLyiK:|enc:c~vnAamswMvlTor@tjGi}L:|
+    # via:enc:udymA{~bxM:`  ##### Influence routes with stopover and pass
+    # through points  For each waypoint in the request, the directions response
+    # appends an entry to the `legs` array to provide the details for stopovers
+    # on that leg of the journey.  If you'd like to influence the route using
+    # waypoints without adding a stopover, add the prefix `via:` to the
+    # waypoint. Waypoints prefixed with `via:` will not add an entry to the
+    # `legs` array, but will route the journey through the waypoint.  The
+    # following URL modifies the previous request such that the journey is
+    # routed through Lexington without stopping:  ```
+    # https://maps.googleapis.com/maps/api/directions/json?
+    # origin=Boston,MA&destination=Concord,MA
+    # &waypoints=Charlestown,MA|via:Lexington,MA   ```  The `via:` prefix is
+    # most effective when creating routes in response to the user dragging the
+    # waypoints on the map. Doing so allows the user to see how the final route
+    # may look in real-time and helps ensure that waypoints are placed in
+    # locations that are accessible to the Directions API.  <div
+    # class="caution">Caution: Using the `via:` prefix to avoid stopovers
+    # results in directions that are strict in their interpretation of the
+    # waypoint. This interpretation may result in severe detours on the route or
+    # `ZERO_RESULTS` in the response status code if the Directions API is unable
+    # to create directions through that point.</div>   ##### Optimize your
+    # waypoints  By default, the Directions service calculates a route through
+    # the provided waypoints in their given order. Optionally, you may pass
+    # `optimize:true` as the first argument within the waypoints parameter to
+    # allow the Directions service to optimize the provided route by rearranging
+    # the waypoints in a more efficient order. (This optimization is an
+    # application of the traveling salesperson problem.) Travel time is the
+    # primary factor which is optimized, but other factors such as distance,
+    # number of turns and many more may be taken into account when deciding
+    # which route is the most efficient. All waypoints must be stopovers for the
+    # Directions service to optimize their route.  If you instruct the
+    # Directions service to optimize the order of its waypoints, their order
+    # will be returned in the `waypoint_order` field within the routes object.
+    # The `waypoint_order` field returns values which are zero-based.  The
+    # following example calculates a road journey from Adelaide, South Australia
+    # to each of South Australia's main wine regions using route optimization.
+    # ``` https://maps.googleapis.com/maps/api/directions/json?
+    # origin=Adelaide,SA&destination=Adelaide,SA
+    # &waypoints=optimize:true|Barossa+Valley,SA|Clare,SA|Connawarra,SA|McLaren+
+    # Vale,SA ```  Inspection of the calculated route will indicate that
+    # calculation uses waypoints in the following waypoint order:  ```
+    # "waypoint_order": [ 3, 2, 0, 1 ] ```  <div class="caution">Caution:
+    # Requests using waypoint optimization are billed at a higher rate. <a
+    # href="https://developers.google.com/maps/billing-and-pricing/pricing#direc
+    # tions-advanced">Learn more about how Google Maps Platform products are
+    # billed.</a></div>
+    # @param [Language] language Optional parameter: The language in which to
+    # return results.  * See the [list of supported
+    # languages](https://developers.google.com/maps/faq#languagesupport). Google
+    # often updates the supported languages, so this list may not be exhaustive.
+    # * If `language` is not supplied, the API attempts to use the preferred
+    # language as specified in the `Accept-Language` header. * The API does its
+    # best to provide a street address that is readable for both the user and
+    # locals. To achieve that goal, it returns street addresses in the local
+    # language, transliterated to a script readable by the user if necessary,
+    # observing the preferred language. All other addresses are returned in the
+    # preferred language. Address components are all returned in the same
+    # language, which is chosen from the first component. * If a name is not
+    # available in the preferred language, the API uses the closest match. * The
+    # preferred language has a small influence on the set of results that the
+    # API chooses to return, and the order in which they are returned. The
+    # geocoder interprets abbreviations differently depending on language, such
+    # as the abbreviations for street types, or synonyms that may be valid in
+    # one language but not in another. For example, _utca_ and _tér_ are
+    # synonyms for street in Hungarian.
+    # @param [Mode] mode Optional parameter: For the calculation of distances
+    # and directions, you may specify the transportation mode to use. By
+    # default, `DRIVING` mode is used. By default, directions are calculated as
+    # driving directions. The following travel modes are supported:  * `driving`
+    # (default) indicates standard driving directions or distance using the road
+    # network. * `walking` requests walking directions or distance via
+    # pedestrian paths & sidewalks (where available). * `bicycling` requests
+    # bicycling directions or distance via bicycle paths & preferred streets
+    # (where available). * `transit` requests directions or distance via public
+    # transit routes (where available). Transit trips are available for up to 7
+    # days in the past or 100 days in the future. If you set the mode to
+    # transit, you can optionally specify either a `departure_time` or an
+    # `arrival_time`. If neither time is specified, the `departure_time`
+    # defaults to now (that is, the departure time defaults to the current
+    # time). You can also optionally include a `transit_mode` and/or a
+    # `transit_routing_preference`.   <div class="note">Note: Both walking and
+    # bicycling directions may sometimes not include clear pedestrian or
+    # bicycling paths, so these directions will return warnings in the returned
+    # result which you must display to the user.</div>
+    # @param [Region] region Optional parameter: The region code, specified as a
+    # [ccTLD ("top-level
+    # domain")](https://en.wikipedia.org/wiki/List_of_Internet_top-level_domains
+    # #Country_code_top-level_domains) two-character value. Most ccTLD codes are
+    # identical to ISO 3166-1 codes, with some notable exceptions. For example,
+    # the United Kingdom's ccTLD is "uk" (.co.uk) while its ISO 3166-1 code is
+    # "gb" (technically for the entity of "The United Kingdom of Great Britain
+    # and Northern Ireland").
+    # @param [TrafficModel] traffic_model Optional parameter: Specifies the
+    # assumptions to use when calculating time in traffic. This setting affects
+    # the value returned in the duration_in_traffic field in the response, which
+    # contains the predicted time in traffic based on historical averages. The
+    # `traffic_model` parameter may only be specified for driving directions
+    # where the request includes a `departure_time`. The available values for
+    # this parameter are: * `best_guess` (default) indicates that the returned
+    # duration_in_traffic should be the best estimate of travel time given what
+    # is known about both historical traffic conditions and live traffic. Live
+    # traffic becomes more important the closer the `departure_time` is to now.
+    # * `pessimistic` indicates that the returned duration_in_traffic should be
+    # longer than the actual travel time on most days, though occasional days
+    # with particularly bad traffic conditions may exceed this value. *
+    # `optimistic` indicates that the returned duration_in_traffic should be
+    # shorter than the actual travel time on most days, though occasional days
+    # with particularly good traffic conditions may be faster than this value.
+    # The default value of `best_guess` will give the most useful predictions
+    # for the vast majority of use cases. It is possible the `best_guess` travel
+    # time prediction may be shorter than `optimistic`, or alternatively, longer
+    # than `pessimistic`, due to the way the `best_guess` prediction model
+    # integrates live traffic information.
+    # @param [String] transit_mode Optional parameter: Specifies one or more
+    # preferred modes of transit. This parameter may only be specified for
+    # transit directions. The parameter supports the following arguments: *
+    # `bus` indicates that the calculated route should prefer travel by bus. *
+    # `subway` indicates that the calculated route should prefer travel by
+    # subway. * `train` indicates that the calculated route should prefer travel
+    # by train. * `tram` indicates that the calculated route should prefer
+    # travel by tram and light rail. * `rail` indicates that the calculated
+    # route should prefer travel by train, tram, light rail, and subway. This is
+    # equivalent to `transit_mode=train|tram|subway`.
+    # @param [TransitRoutingPreference] transit_routing_preference Optional
+    # parameter: Specifies preferences for transit routes. Using this parameter,
+    # you can bias the options returned, rather than accepting the default best
+    # route chosen by the API. This parameter may only be specified for transit
+    # directions. The parameter supports the following arguments: *
+    # `less_walking` indicates that the calculated route should prefer limited
+    # amounts of walking. * `fewer_transfers` indicates that the calculated
+    # route should prefer a limited number of transfers.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def directions(destination,
+                   origin,
+                   arrival_time: nil,
+                   departure_time: nil,
+                   alternatives: nil,
+                   avoid: nil,
+                   units: nil,
+                   waypoints: nil,
+                   language: Language::EN,
+                   mode: nil,
+                   region: Region::EN,
+                   traffic_model: TrafficModel::BEST_GUESS,
+                   transit_mode: nil,
+                   transit_routing_preference: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/maps/api/directions/json',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(destination, key: 'destination')
+                                 .is_required(true))
+                   .query_param(new_parameter(origin, key: 'origin')
+                                 .is_required(true))
+                   .query_param(new_parameter(arrival_time, key: 'arrival_time'))
+                   .query_param(new_parameter(departure_time, key: 'departure_time'))
+                   .query_param(new_parameter(alternatives, key: 'alternatives'))
+                   .query_param(new_parameter(avoid, key: 'avoid'))
+                   .query_param(new_parameter(units, key: 'units'))
+                   .query_param(new_parameter(waypoints, key: 'waypoints'))
+                   .query_param(new_parameter(language, key: 'language'))
+                   .query_param(new_parameter(mode, key: 'mode'))
+                   .query_param(new_parameter(region, key: 'region'))
+                   .query_param(new_parameter(traffic_model, key: 'traffic_model'))
+                   .query_param(new_parameter(transit_mode, key: 'transit_mode'))
+                   .query_param(new_parameter(transit_routing_preference, key: 'transit_routing_preference'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('ApiKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(DirectionsResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+  end
+end