google-maps-platform-sdk 1.0.0

data/lib/google_maps_platform/apis/roads_api.rb

@@ -0,0 +1,81 @@
+# google_maps_platform
+#
+# This file was automatically generated by APIMATIC
+# v3.0 ( https://www.apimatic.io ).
+
+module GoogleMapsPlatform
+  # RoadsApi
+  class RoadsApi < BaseApi
+    # 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/apis/street_view_api.rb

@@ -0,0 +1,198 @@
+# google_maps_platform
+#
+# This file was automatically generated by APIMATIC
+# v3.0 ( https://www.apimatic.io ).
+
+module GoogleMapsPlatform
+  # StreetViewApi
+  class StreetViewApi < BaseApi
+    # 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/apis/time_zone_api.rb

@@ -0,0 +1,65 @@
+# google_maps_platform
+#
+# This file was automatically generated by APIMATIC
+# v3.0 ( https://www.apimatic.io ).
+
+module GoogleMapsPlatform
+  # TimeZoneApi
+  class TimeZoneApi < BaseApi
+    # 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/client.rb

@@ -0,0 +1,123 @@
+# google_maps_platform
+#
+# This file was automatically generated by APIMATIC
+# v3.0 ( https://www.apimatic.io ).
+
+module GoogleMapsPlatform
+  #  google_maps_platform client class.
+  class Client
+    include CoreLibrary
+    attr_reader :config, :auth_managers
+
+    def user_agent_detail
+      config.user_agent_detail
+    end
+
+    # Access to geolocation_api controller.
+    # @return [GeolocationApi] Returns the controller instance.
+    def geolocation_api
+      @geolocation_api ||= GeolocationApi.new @global_configuration
+    end
+
+    # Access to directions_api controller.
+    # @return [DirectionsApi] Returns the controller instance.
+    def directions_api
+      @directions_api ||= DirectionsApi.new @global_configuration
+    end
+
+    # Access to elevation_api controller.
+    # @return [ElevationApi] Returns the controller instance.
+    def elevation_api
+      @elevation_api ||= ElevationApi.new @global_configuration
+    end
+
+    # Access to geocoding_api controller.
+    # @return [GeocodingApi] Returns the controller instance.
+    def geocoding_api
+      @geocoding_api ||= GeocodingApi.new @global_configuration
+    end
+
+    # Access to time_zone_api controller.
+    # @return [TimeZoneApi] Returns the controller instance.
+    def time_zone_api
+      @time_zone_api ||= TimeZoneApi.new @global_configuration
+    end
+
+    # Access to roads_api controller.
+    # @return [RoadsApi] Returns the controller instance.
+    def roads_api
+      @roads_api ||= RoadsApi.new @global_configuration
+    end
+
+    # Access to distance_matrix_api controller.
+    # @return [DistanceMatrixApi] Returns the controller instance.
+    def distance_matrix_api
+      @distance_matrix_api ||= DistanceMatrixApi.new @global_configuration
+    end
+
+    # Access to places_api controller.
+    # @return [PlacesApi] Returns the controller instance.
+    def places_api
+      @places_api ||= PlacesApi.new @global_configuration
+    end
+
+    # Access to street_view_api controller.
+    # @return [StreetViewApi] Returns the controller instance.
+    def street_view_api
+      @street_view_api ||= StreetViewApi.new @global_configuration
+    end
+
+    def initialize(
+      connection: nil, adapter: :net_http_persistent, timeout: 30,
+      max_retries: 0, retry_interval: 1, backoff_factor: 2,
+      retry_statuses: [408, 413, 429, 500, 502, 503, 504, 521, 522, 524],
+      retry_methods: %i[get put], http_callback: nil, proxy_settings: nil,
+      logging_configuration: nil, environment: Environment::PRODUCTION,
+      custom_query_authentication_credentials: nil, config: nil
+    )
+      @config = if config.nil?
+                  Configuration.new(
+                    connection: connection, adapter: adapter, timeout: timeout,
+                    max_retries: max_retries, retry_interval: retry_interval,
+                    backoff_factor: backoff_factor,
+                    retry_statuses: retry_statuses,
+                    retry_methods: retry_methods, http_callback: http_callback,
+                    proxy_settings: proxy_settings,
+                    logging_configuration: logging_configuration,
+                    environment: environment,
+                    custom_query_authentication_credentials: custom_query_authentication_credentials
+                  )
+                else
+                  config
+                end
+      user_agent_params = BaseApi.user_agent_parameters
+
+      @global_configuration = GlobalConfiguration.new(client_configuration: @config)
+                                                 .base_uri_executor(@config.method(:get_base_uri))
+                                                 .global_errors(BaseApi::GLOBAL_ERRORS)
+                                                 .user_agent(BaseApi.user_agent,
+                                                             agent_parameters: user_agent_params)
+
+      initialize_auth_managers(@global_configuration)
+      @global_configuration = @global_configuration.auth_managers(@auth_managers)
+    end
+
+    # Initializes the auth managers hash used for authenticating API calls.
+    # @param [GlobalConfiguration] global_config The global configuration of the SDK)
+    def initialize_auth_managers(global_config)
+      @auth_managers = {}
+      http_client_config = global_config.client_configuration
+      %w[ApiKeyAuth].each { |auth| @auth_managers[auth] = nil }
+      @auth_managers['ApiKeyAuth'] = CustomQueryAuthentication.new(
+        http_client_config.custom_query_authentication_credentials
+      )
+    end
+
+    # Creates a client directly from environment variables.
+    def self.from_env(**overrides)
+      default_config = Configuration.build_default_config_from_env
+      new_config = default_config.clone_with(**overrides)
+      new(config: new_config)
+    end
+  end
+end

data/lib/google_maps_platform/configuration.rb

@@ -0,0 +1,181 @@
+# google_maps_platform
+#
+# This file was automatically generated by APIMATIC
+# v3.0 ( https://www.apimatic.io ).
+
+module GoogleMapsPlatform
+  # An enum for SDK environments.
+  class Environment
+    ENVIRONMENT = [
+      PRODUCTION = 'production'.freeze,
+      ENVIRONMENT2 = 'environment2'.freeze,
+      ENVIRONMENT3 = 'environment3'.freeze
+    ].freeze
+
+    # Converts a string or symbol into a valid Environment constant.
+    def self.from_value(value, default_value = PRODUCTION)
+      return default_value if value.nil?
+
+      str = value.to_s.strip.downcase
+      case str
+      when 'production' then PRODUCTION
+      when 'environment2' then ENVIRONMENT2
+      when 'environment3' then ENVIRONMENT3
+
+      else
+        warn "[Environment] Unknown environment '#{value}', falling back to #{default_value} "
+        default_value
+      end
+    end
+  end
+
+  # An enum for API servers.
+  class Server
+    SERVER = [
+      DEFAULT = 'default'.freeze
+    ].freeze
+
+    # Converts a string or symbol into a valid Server constant.
+    def self.from_value(value, default_value = DEFAULT)
+      return default_value if value.nil?
+
+      default_value
+    end
+  end
+
+  # All configuration including auth info and base URI for the API access
+  # are configured in this class.
+  class Configuration < CoreLibrary::HttpClientConfiguration
+    # The attribute readers for properties.
+    attr_reader :environment, :custom_query_authentication_credentials
+
+    class << self
+      attr_reader :environments
+    end
+
+    def initialize(
+      connection: nil, adapter: :net_http_persistent, timeout: 30,
+      max_retries: 0, retry_interval: 1, backoff_factor: 2,
+      retry_statuses: [408, 413, 429, 500, 502, 503, 504, 521, 522, 524],
+      retry_methods: %i[get put], http_callback: nil, proxy_settings: nil,
+      logging_configuration: nil, environment: Environment::PRODUCTION,
+      custom_query_authentication_credentials: nil
+    )
+      super connection: connection, adapter: adapter, timeout: timeout,
+            max_retries: max_retries, retry_interval: retry_interval,
+            backoff_factor: backoff_factor, retry_statuses: retry_statuses,
+            retry_methods: retry_methods, http_callback: http_callback,
+            proxy_settings: proxy_settings,
+            logging_configuration: logging_configuration
+
+      # Current API environment
+      @environment = String(environment)
+
+      # The object holding Custom Query Parameter credentials
+      @custom_query_authentication_credentials = custom_query_authentication_credentials
+
+      # Initializing Custom Query Parameter credentials with the provided auth parameters
+      @custom_query_authentication_credentials = custom_query_authentication_credentials
+
+      # The Http Client to use for making requests.
+      set_http_client CoreLibrary::FaradayClient.new(self)
+    end
+
+    def clone_with(connection: nil, adapter: nil, timeout: nil,
+                   max_retries: nil, retry_interval: nil, backoff_factor: nil,
+                   retry_statuses: nil, retry_methods: nil, http_callback: nil,
+                   proxy_settings: nil, logging_configuration: nil,
+                   environment: nil,
+                   custom_query_authentication_credentials: nil)
+      connection ||= self.connection
+      adapter ||= self.adapter
+      timeout ||= self.timeout
+      max_retries ||= self.max_retries
+      retry_interval ||= self.retry_interval
+      backoff_factor ||= self.backoff_factor
+      retry_statuses ||= self.retry_statuses
+      retry_methods ||= self.retry_methods
+      http_callback ||= self.http_callback
+      proxy_settings ||= self.proxy_settings
+      logging_configuration ||= self.logging_configuration
+      environment ||= self.environment
+      custom_query_authentication_credentials ||= self.custom_query_authentication_credentials
+
+      Configuration.new(
+        connection: connection, adapter: adapter, timeout: timeout,
+        max_retries: max_retries, retry_interval: retry_interval,
+        backoff_factor: backoff_factor, retry_statuses: retry_statuses,
+        retry_methods: retry_methods, http_callback: http_callback,
+        proxy_settings: proxy_settings,
+        logging_configuration: logging_configuration, environment: environment,
+        custom_query_authentication_credentials: custom_query_authentication_credentials
+      )
+    end
+
+
+    # All the environments the SDK can run in.
+    ENVIRONMENTS = {
+      Environment::PRODUCTION => {
+        Server::DEFAULT => 'https://www.googleapis.com'
+      },
+      Environment::ENVIRONMENT2 => {
+        Server::DEFAULT => 'https://maps.googleapis.com'
+      },
+      Environment::ENVIRONMENT3 => {
+        Server::DEFAULT => 'https://roads.googleapis.com'
+      }
+    }.freeze
+
+    # Generates the appropriate base URI for the environment and the server.
+    # @param [Configuration::Server] server The server enum for which the base URI is
+    # required.
+    # @return [String] The base URI.
+    def get_base_uri(server = Server::DEFAULT)
+      ENVIRONMENTS[environment][server].clone
+    end
+
+    # Builds a Configuration instance using environment variables.
+    def self.build_default_config_from_env
+      # === Core environment ===
+      environment = Environment.from_value(ENV.fetch('ENVIRONMENT', 'production'))
+      timeout = (ENV['TIMEOUT'] || 30).to_f
+      max_retries = (ENV['MAX_RETRIES'] || 0).to_i
+      retry_interval = (ENV['RETRY_INTERVAL'] || 1).to_f
+      backoff_factor = (ENV['BACKOFF_FACTOR'] || 2).to_f
+      retry_statuses = ENV.fetch('RETRY_STATUSES',
+                                 '[408, 413, 429, 500, 502, 503, 504, 521, 522, 524]').gsub(/[\[\]]/, '')
+                                          .split(',')
+                                          .map(&:strip)
+                                          .map do |item|
+                                            item.match?(/\A\d+\z/) ? item.to_i : item.downcase
+                                          end
+      retry_methods = ENV.fetch('RETRY_METHODS', '%i[get put]').gsub(/[\[\]]/, '')
+                                          .split(',')
+                                          .map(&:strip)
+                                          .map do |item|
+                                            item.match?(/\A\d+\z/) ? item.to_i : item.downcase
+                                          end
+
+      # === Authentication credentials ===
+      custom_query_authentication_credentials = CustomQueryAuthenticationCredentials.from_env
+
+      # === Proxy settings ===
+      proxy_settings = ProxySettings.from_env
+      # === Logging Configuration ===
+      logging_configuration = LoggingConfiguration.from_env if LoggingConfiguration.any_logging_configured?
+
+      Configuration.new(
+        environment: environment,
+        timeout: timeout,
+        max_retries: max_retries,
+        retry_interval: retry_interval,
+        backoff_factor: backoff_factor,
+        retry_statuses: retry_statuses,
+        retry_methods: retry_methods,
+        custom_query_authentication_credentials: custom_query_authentication_credentials,
+        proxy_settings: proxy_settings,
+        logging_configuration: logging_configuration
+      )
+    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