google-maps-api-sdk 1.0.0

data/lib/google_maps_platform/controllers/roads_api_controller.rb

@@ -0,0 +1,81 @@
+# google_maps_platform
+#
+# This file was automatically generated by APIMATIC
+# v3.0 ( https://www.apimatic.io ).
+
+module GoogleMapsPlatform
+  # RoadsApiController
+  class RoadsApiController < BaseController
+    # This service returns the best-fit road geometry for a given set of GPS
+    # coordinates. This service takes up to 100 GPS points collected along a
+    # route, and returns a similar set of data with the points snapped to the
+    # most likely roads the vehicle was traveling along. Optionally, you can
+    # request that the points be interpolated, resulting in a path that smoothly
+    # follows the geometry of the road.
+    # @param [Array[String]] path Required parameter: The path to be snapped.
+    # The path parameter accepts a list of latitude/longitude pairs. Latitude
+    # and longitude values should be separated by commas. Coordinates should be
+    # separated by the pipe character: "|". For example:
+    # `path=60.170880,24.942795|60.170879,24.942796|60.170877,24.942796`. <div
+    # class="note">Note: The snapping algorithm works best for points that are
+    # not too far apart. If you observe odd snapping behavior, try creating
+    # paths that have points closer together. To ensure the best snap-to-road
+    # quality, you should aim to provide paths on which consecutive pairs of
+    # points are within 300m of each other. This will also help in handling any
+    # isolated, long jumps between consecutive points caused by GPS signal loss,
+    # or noise.</div>
+    # @param [TrueClass | FalseClass] interpolate Optional parameter: Whether to
+    # interpolate a path to include all points forming the full road-geometry.
+    # When true, additional interpolated points will also be returned, resulting
+    # in a path that smoothly follows the geometry of the road, even around
+    # corners and through tunnels. Interpolated paths will most likely contain
+    # more points than the original path. Defaults to `false`.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def snap_to_roads(path,
+                      interpolate: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/v1/snaptoroads',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(path, key: 'path')
+                                 .is_required(true))
+                   .query_param(new_parameter(interpolate, key: 'interpolate'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('ApiKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(SnapToRoadsResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # This service returns individual road segments for a given set of GPS
+    # coordinates. This services takes up to 100 GPS points and returns the
+    # closest road segments for each point. The points passed do not need to be
+    # part of a continuous path.
+    # @param [Array[String]] points Required parameter: The points to be
+    # snapped. The points parameter accepts a list of latitude/longitude pairs.
+    # Separate latitude and longitude values with commas. Separate coordinates
+    # with the pipe character: "|". For example:
+    # `points=60.170880,24.942795|60.170879,24.942796|60.170877,24.942796`.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def nearest_roads(points)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/v1/nearestRoads',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(points, key: 'points')
+                                 .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('ApiKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(NearestRoadsResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 '400 BAD REQUEST',
+                                 NearestRoadsErrorResponseException))
+        .execute
+    end
+  end
+end

data/lib/google_maps_platform/controllers/street_view_api_controller.rb

@@ -0,0 +1,198 @@
+# google_maps_platform
+#
+# This file was automatically generated by APIMATIC
+# v3.0 ( https://www.apimatic.io ).
+
+module GoogleMapsPlatform
+  # StreetViewApiController
+  class StreetViewApiController < BaseController
+    # The Street View Static API lets you embed a static (non-interactive)
+    # Street View panorama or thumbnail into your web page, without the use of
+    # JavaScript. The viewport is defined with URL parameters sent through a
+    # standard HTTP request, and is returned as a static image.
+    # @param [String] size Required parameter: Specifies the output size of the
+    # image in pixels. Must not exceed 640 pixels wide or high, anything over
+    # will default to 640 pixels. Size is specified as `{width}x{height}` - for
+    # example, `size=600x400` returns an image 600 pixels wide, and 400 high.
+    # @param [Float] fov Optional parameter: Determines the horizontal field of
+    # view of the image. The field of view is expressed in degrees, with a
+    # maximum allowed value of 120. When dealing with a fixed-size viewport, as
+    # with a Street View image of a set size, field of view in essence
+    # represents zoom, with smaller numbers indicating a higher level of zoom.
+    # Default is 90.
+    # @param [Float] heading Optional parameter: Indicates the compass heading
+    # of the camera. Accepted values are from 0 to 360 (both values indicating
+    # North, with 90 indicating East, and 180 South). If no heading is
+    # specified, a value will be calculated that directs the camera towards the
+    # specified location, from the point at which the closest photograph was
+    # taken.
+    # @param [String] location Optional parameter: The point around which to
+    # retrieve place information. The Street View Static API will snap to the
+    # panorama photographed closest to this location. When an address text
+    # string is provided, the API may use a different camera location to better
+    # display the specified location. When a lat/lng is provided, the API
+    # searches a 50 meter radius for a photograph closest to this location.
+    # Because Street View imagery is periodically refreshed, and photographs may
+    # be taken from slightly different positions each time, it's possible that
+    # your `location` may snap to a different panorama when imagery is
+    # updated.
+    # @param [String] pano Optional parameter: A specific panorama ID. These are
+    # generally stable, though panoramas may change ID over time as imagery is
+    # refreshed.
+    # @param [Float] pitch Optional parameter: Specifies the up or down angle of
+    # the camera relative to the Street View vehicle. This is often, but not
+    # always, flat horizontal. Positive values angle the camera up (with 90
+    # degrees indicating straight up); negative values angle the camera down
+    # (with -90 indicating straight down). Default is 0.
+    # @param [Float] radius Optional parameter: Sets a radius, specified in
+    # meters, in which to search for a panorama, centered on the given latitude
+    # and longitude. Valid values are non-negative integers. Default is 50
+    # meters.
+    # @param [TrueClass | FalseClass] return_error_code Optional parameter:
+    # Indicates whether the API should return a non `200 Ok` HTTP status when no
+    # image is found (`404 NOT FOUND`), or in response to an invalid request
+    # (400 BAD REQUEST). Valid values are `true` and `false`. If set to `true`,
+    # an error message is returned in place of the generic gray image. This
+    # eliminates the need to make a separate call to check for image
+    # availability.
+    # @param [String] signature Optional parameter: A digital signature used to
+    # verify that any site generating requests using your API key is authorized
+    # to do so. Requests that do not include a digital signature might fail. For
+    # more information, see [Get a Key and
+    # Signature](https://developers.google.com/maps/documentation/streetview/get
+    # -api-key).
+    # @param [Source] source Optional parameter: Limits Street View searches to
+    # selected sources. Valid values are: * `default` uses the default sources
+    # for Street View; searches are not limited to specific sources. * `outdoor`
+    # limits searches to outdoor collections. Indoor collections are not
+    # included in search results. Note that outdoor panoramas may not exist for
+    # the specified location. Also note that the search only returns panoramas
+    # where it's possible to determine whether they're indoors or outdoors. For
+    # example, PhotoSpheres are not returned because it's unknown whether they
+    # are indoors or outdoors.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def street_view(size,
+                    fov: nil,
+                    heading: nil,
+                    location: nil,
+                    pano: nil,
+                    pitch: nil,
+                    radius: nil,
+                    return_error_code: nil,
+                    signature: nil,
+                    source: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/maps/api/streetview',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(size, key: 'size')
+                                 .is_required(true))
+                   .query_param(new_parameter(fov, key: 'fov'))
+                   .query_param(new_parameter(heading, key: 'heading'))
+                   .query_param(new_parameter(location, key: 'location'))
+                   .query_param(new_parameter(pano, key: 'pano'))
+                   .query_param(new_parameter(pitch, key: 'pitch'))
+                   .query_param(new_parameter(radius, key: 'radius'))
+                   .query_param(new_parameter(return_error_code, key: 'return_error_code'))
+                   .query_param(new_parameter(signature, key: 'signature'))
+                   .query_param(new_parameter(source, key: 'source'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('ApiKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:dynamic_deserializer))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # The Street View Static API metadata requests provide data about Street
+    # View panoramas. Using the metadata, you can find out if a Street View
+    # image is available at a given location, as well as getting programmatic
+    # access to the latitude and longitude, the panorama ID, the date the photo
+    # was taken, and the copyright information for the image. Accessing this
+    # metadata allows you to customize error behavior in your application.
+    # @param [Float] heading Optional parameter: Indicates the compass heading
+    # of the camera. Accepted values are from 0 to 360 (both values indicating
+    # North, with 90 indicating East, and 180 South). If no heading is
+    # specified, a value will be calculated that directs the camera towards the
+    # specified location, from the point at which the closest photograph was
+    # taken.
+    # @param [String] location Optional parameter: The point around which to
+    # retrieve place information. The Street View Static API will snap to the
+    # panorama photographed closest to this location. When an address text
+    # string is provided, the API may use a different camera location to better
+    # display the specified location. When a lat/lng is provided, the API
+    # searches a 50 meter radius for a photograph closest to this location.
+    # Because Street View imagery is periodically refreshed, and photographs may
+    # be taken from slightly different positions each time, it's possible that
+    # your `location` may snap to a different panorama when imagery is
+    # updated.
+    # @param [String] pano Optional parameter: A specific panorama ID. These are
+    # generally stable, though panoramas may change ID over time as imagery is
+    # refreshed.
+    # @param [Float] pitch Optional parameter: Specifies the up or down angle of
+    # the camera relative to the Street View vehicle. This is often, but not
+    # always, flat horizontal. Positive values angle the camera up (with 90
+    # degrees indicating straight up); negative values angle the camera down
+    # (with -90 indicating straight down). Default is 0.
+    # @param [Float] radius Optional parameter: Sets a radius, specified in
+    # meters, in which to search for a panorama, centered on the given latitude
+    # and longitude. Valid values are non-negative integers. Default is 50
+    # meters.
+    # @param [TrueClass | FalseClass] return_error_code Optional parameter:
+    # Indicates whether the API should return a non `200 Ok` HTTP status when no
+    # image is found (`404 NOT FOUND`), or in response to an invalid request
+    # (400 BAD REQUEST). Valid values are `true` and `false`. If set to `true`,
+    # an error message is returned in place of the generic gray image. This
+    # eliminates the need to make a separate call to check for image
+    # availability.
+    # @param [String] signature Optional parameter: A digital signature used to
+    # verify that any site generating requests using your API key is authorized
+    # to do so. Requests that do not include a digital signature might fail. For
+    # more information, see [Get a Key and
+    # Signature](https://developers.google.com/maps/documentation/streetview/get
+    # -api-key).
+    # @param [String] size Optional parameter: Specifies the output size of the
+    # image in pixels. Size is specified as `{width}x{height}` - for example,
+    # `size=600x400` returns an image 600 pixels wide, and 400 high.
+    # @param [Source] source Optional parameter: Limits Street View searches to
+    # selected sources. Valid values are: * `default` uses the default sources
+    # for Street View; searches are not limited to specific sources. * `outdoor`
+    # limits searches to outdoor collections. Indoor collections are not
+    # included in search results. Note that outdoor panoramas may not exist for
+    # the specified location. Also note that the search only returns panoramas
+    # where it's possible to determine whether they're indoors or outdoors. For
+    # example, PhotoSpheres are not returned because it's unknown whether they
+    # are indoors or outdoors.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def street_view_metadata(heading: nil,
+                             location: nil,
+                             pano: nil,
+                             pitch: nil,
+                             radius: nil,
+                             return_error_code: nil,
+                             signature: nil,
+                             size: nil,
+                             source: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/maps/api/streetview/metadata',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(heading, key: 'heading'))
+                   .query_param(new_parameter(location, key: 'location'))
+                   .query_param(new_parameter(pano, key: 'pano'))
+                   .query_param(new_parameter(pitch, key: 'pitch'))
+                   .query_param(new_parameter(radius, key: 'radius'))
+                   .query_param(new_parameter(return_error_code, key: 'return_error_code'))
+                   .query_param(new_parameter(signature, key: 'signature'))
+                   .query_param(new_parameter(size, key: 'size'))
+                   .query_param(new_parameter(source, key: 'source'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('ApiKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(StreetViewResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+  end
+end

data/lib/google_maps_platform/controllers/time_zone_api_controller.rb

@@ -0,0 +1,65 @@
+# google_maps_platform
+#
+# This file was automatically generated by APIMATIC
+# v3.0 ( https://www.apimatic.io ).
+
+module GoogleMapsPlatform
+  # TimeZoneApiController
+  class TimeZoneApiController < BaseController
+    # The Time Zone API provides a simple interface to request the time zone for
+    # locations on the surface of the earth, as well as the time offset from UTC
+    # for each of those locations. You request the time zone information for a
+    # specific latitude/longitude pair and date. The API returns the name of
+    # that time zone, the time offset from UTC, and the daylight savings offset.
+    # @param [String] location Required parameter: A comma-separated
+    # latitude,longitude tuple, `location=39.6034810,-119.6822510`, representing
+    # the location to look up.
+    # @param [Float] timestamp Required parameter: The desired time as seconds
+    # since midnight, January 1, 1970 UTC. The Time Zone API uses the
+    # `timestamp` to determine whether or not Daylight Savings should be
+    # applied, based on the time zone of the `location`.   Note that the API
+    # does not take historical time zones into account. That is, if you specify
+    # a past timestamp, the API does not take into account the possibility that
+    # the location was previously in a different time zone.
+    # @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.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def timezone(location,
+                 timestamp,
+                 language: Language::EN)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/maps/api/timezone/json',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(location, key: 'location')
+                                 .is_required(true))
+                   .query_param(new_parameter(timestamp, key: 'timestamp')
+                                 .is_required(true))
+                   .query_param(new_parameter(language, key: 'language'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('ApiKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(TimeZoneResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+  end
+end

data/lib/google_maps_platform/exceptions/api_exception.rb

@@ -0,0 +1,21 @@
+# google_maps_platform
+#
+# This file was automatically generated by APIMATIC
+# v3.0 ( https://www.apimatic.io ).
+
+module GoogleMapsPlatform
+  # Class for exceptions when there is a network error, status code error, etc.
+  class APIException < CoreLibrary::ApiException
+    # Provides a human-readable string representation of the object.
+    def to_s
+      class_name = self.class.name.split('::').last
+      "<#{class_name} status_code: #{@response_code}, reason: #{@reason}>"
+    end
+
+    # Provides a debugging-friendly string with detailed object information.
+    def inspect
+      class_name = self.class.name.split('::').last
+      "<#{class_name} status_code: #{@response_code.inspect}, reason: #{@reason.inspect}>"
+    end
+  end
+end

data/lib/google_maps_platform/exceptions/error_response_exception.rb

@@ -0,0 +1,48 @@
+# google_maps_platform
+#
+# This file was automatically generated by APIMATIC
+# v3.0 ( https://www.apimatic.io ).
+
+module GoogleMapsPlatform
+  # In the case of an error, a standard format error response body will be
+  # returned and the HTTP status code will be set to an error status. The
+  # response contains an object with a single error object.
+  class ErrorResponseException < APIException
+    SKIP = Object.new
+    private_constant :SKIP
+
+    # TODO: Write general description for this method
+    # @return [ErrorObject]
+    attr_accessor :error
+
+    # The constructor.
+    # @param [String] reason The reason for raising an exception.
+    # @param [HttpResponse] response The HttpReponse of the API call.
+    def initialize(reason, response)
+      super(reason, response)
+      hash = APIHelper.json_deserialize(@response.raw_body)
+      unbox(hash)
+    end
+
+    # Populates this object by extracting properties from a hash.
+    # @param [Hash] hash The deserialized response sent by the server in the
+    # response body.
+    def unbox(hash)
+      return nil unless hash
+
+      @error = ErrorObject.from_hash(hash['error']) if hash['error']
+    end
+
+    # Provides a human-readable string representation of the object.
+    def to_s
+      class_name = self.class.name.split('::').last
+      "<#{class_name} error: #{@error}>"
+    end
+
+    # Provides a debugging-friendly string with detailed object information.
+    def inspect
+      class_name = self.class.name.split('::').last
+      "<#{class_name} error: #{@error.inspect}>"
+    end
+  end
+end

data/lib/google_maps_platform/exceptions/nearest_roads_error_response_exception.rb

@@ -0,0 +1,46 @@
+# google_maps_platform
+#
+# This file was automatically generated by APIMATIC
+# v3.0 ( https://www.apimatic.io ).
+
+module GoogleMapsPlatform
+  # NearestRoadsErrorResponse class.
+  class NearestRoadsErrorResponseException < APIException
+    SKIP = Object.new
+    private_constant :SKIP
+
+    # TODO: Write general description for this method
+    # @return [NearestRoadsError]
+    attr_accessor :error
+
+    # The constructor.
+    # @param [String] reason The reason for raising an exception.
+    # @param [HttpResponse] response The HttpReponse of the API call.
+    def initialize(reason, response)
+      super(reason, response)
+      hash = APIHelper.json_deserialize(@response.raw_body)
+      unbox(hash)
+    end
+
+    # Populates this object by extracting properties from a hash.
+    # @param [Hash] hash The deserialized response sent by the server in the
+    # response body.
+    def unbox(hash)
+      return nil unless hash
+
+      @error = NearestRoadsError.from_hash(hash['error']) if hash['error']
+    end
+
+    # Provides a human-readable string representation of the object.
+    def to_s
+      class_name = self.class.name.split('::').last
+      "<#{class_name} error: #{@error}>"
+    end
+
+    # Provides a debugging-friendly string with detailed object information.
+    def inspect
+      class_name = self.class.name.split('::').last
+      "<#{class_name} error: #{@error.inspect}>"
+    end
+  end
+end

data/lib/google_maps_platform/http/api_response.rb

@@ -0,0 +1,19 @@
+# google_maps_platform
+#
+# This file was automatically generated by APIMATIC
+# v3.0 ( https://www.apimatic.io ).
+
+module GoogleMapsPlatform
+  # Http response received.
+  class ApiResponse < CoreLibrary::ApiResponse
+    # The constructor
+    # @param [HttpResponse] http_response The original, raw response from the api.
+    # @param [Object] data The data field specified for the response.
+    # @param [Array<String>] errors Any errors returned by the server.
+    def initialize(http_response,
+                   data: nil,
+                   errors: nil)
+      super
+    end
+  end
+end

data/lib/google_maps_platform/http/auth/custom_query_authentication.rb

@@ -0,0 +1,52 @@
+# google_maps_platform
+#
+# This file was automatically generated by APIMATIC
+# v3.0 ( https://www.apimatic.io ).
+
+module GoogleMapsPlatform
+  # Utility class for custom query_parameter authorization.
+  class CustomQueryAuthentication < CoreLibrary::QueryAuth
+    # Display error message on occurrence of authentication failure.
+    # @returns [String] The oAuth error message.
+    def error_message
+      'CustomQueryAuthentication: key is undefined.'
+    end
+
+    # Initialization constructor.
+    def initialize(custom_query_authentication_credentials)
+      auth_params = {}
+      auth_params['key'] = custom_query_authentication_credentials.key unless
+        custom_query_authentication_credentials.nil? || custom_query_authentication_credentials.key.nil?
+
+      super auth_params
+    end
+  end
+
+  # Data class for CustomQueryAuthenticationCredentials.
+  # Data class for CustomQueryAuthenticationCredentials.
+  class CustomQueryAuthenticationCredentials
+    attr_reader :key
+
+    def initialize(key:)
+      raise ArgumentError, 'key cannot be nil' if key.nil?
+
+      @key = key
+    end
+
+    def self.from_env
+      key = ENV['KEY']
+      all_nil = [
+        key
+      ].all?(&:nil?)
+      return nil if all_nil
+
+      new(key: key)
+    end
+
+    def clone_with(key: nil)
+      key ||= self.key
+
+      CustomQueryAuthenticationCredentials.new(key: key)
+    end
+  end
+end

data/lib/google_maps_platform/http/http_call_back.rb

@@ -0,0 +1,10 @@
+# google_maps_platform
+#
+# This file was automatically generated by APIMATIC
+# v3.0 ( https://www.apimatic.io ).
+
+module GoogleMapsPlatform
+  # HttpCallBack allows defining callables for pre and post API calls.
+  class HttpCallBack < CoreLibrary::HttpCallback
+  end
+end

data/lib/google_maps_platform/http/http_method_enum.rb

@@ -0,0 +1,10 @@
+# google_maps_platform
+#
+# This file was automatically generated by APIMATIC
+# v3.0 ( https://www.apimatic.io ).
+
+module GoogleMapsPlatform
+  # HTTP Methods Enumeration.
+  class HttpMethodEnum < CoreLibrary::HttpMethod
+  end
+end

data/lib/google_maps_platform/http/http_request.rb

@@ -0,0 +1,10 @@
+# google_maps_platform
+#
+# This file was automatically generated by APIMATIC
+# v3.0 ( https://www.apimatic.io ).
+
+module GoogleMapsPlatform
+  # Represents a single Http Request.
+  class HttpRequest < CoreLibrary::HttpRequest
+  end
+end

data/lib/google_maps_platform/http/http_response.rb

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

data/lib/google_maps_platform/http/proxy_settings.rb

@@ -0,0 +1,22 @@
+# google_maps_platform
+#
+# This file was automatically generated by APIMATIC
+# v3.0 ( https://www.apimatic.io ).
+
+module GoogleMapsPlatform
+  ##
+  # ProxySettings encapsulates HTTP proxy configuration for Faraday,
+  # including optional basic authentication.
+  #
+  class ProxySettings < CoreLibrary::ProxySettings
+    def self.from_env
+      address = ENV['PROXY_ADDRESS']
+      port = ENV['PROXY_PORT']
+      username = ENV['PROXY_USERNAME']
+      password = ENV['PROXY_PASSWORD']
+      return nil if address.nil? || address.strip.empty?
+
+      new(address: address, port: port, username: username, password: password)
+    end
+  end
+end