nextbillionai 0.1.0.pre.alpha.4

data/lib/nextbillionai/request_options.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  # or override those provided at the client level.
+  #
+  # When making a request, you can pass an actual {RequestOptions} instance, or
+  # simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < Nextbillionai::Internal::Type::BaseModel
+    # @api private
+    #
+    # @param opts [Nextbillionai::RequestOptions, Hash{Symbol=>Object}]
+    #
+    # @raise [ArgumentError]
+    def self.validate!(opts)
+      case opts
+      in Nextbillionai::RequestOptions | Hash
+        opts.to_h.each_key do |k|
+          unless fields.include?(k)
+            raise ArgumentError.new("Request `opts` keys must be one of #{fields.keys}, got #{k.inspect}")
+          end
+        end
+      else
+        raise ArgumentError.new("Request `opts` must be a Hash or RequestOptions, got #{opts.inspect}")
+      end
+    end
+
+    # @!attribute idempotency_key
+    #   Idempotency key to send with request and all associated retries. Will only be
+    #   sent for write requests.
+    #
+    #   @return [String, nil]
+    optional :idempotency_key, String
+
+    # @!attribute extra_query
+    #   Extra query params to send with the request. These are `.merge`’d into any
+    #   `query` given at the client level.
+    #
+    #   @return [Hash{String=>Array<String>, String, nil}, nil]
+    optional :extra_query,
+             Nextbillionai::Internal::Type::HashOf[Nextbillionai::Internal::Type::ArrayOf[String]]
+
+    # @!attribute extra_headers
+    #   Extra headers to send with the request. These are `.merged`’d into any
+    #   `extra_headers` given at the client level.
+    #
+    #   @return [Hash{String=>String, nil}, nil]
+    optional :extra_headers, Nextbillionai::Internal::Type::HashOf[String, nil?: true]
+
+    # @!attribute extra_body
+    #   Extra data to send with the request. These are deep merged into any data
+    #   generated as part of the normal request.
+    #
+    #   @return [Object, nil]
+    optional :extra_body, Nextbillionai::Internal::Type::HashOf[Nextbillionai::Internal::Type::Unknown]
+
+    # @!attribute max_retries
+    #   Maximum number of retries to attempt after a failed initial request.
+    #
+    #   @return [Integer, nil]
+    optional :max_retries, Integer
+
+    # @!attribute timeout
+    #   Request timeout in seconds.
+    #
+    #   @return [Float, nil]
+    optional :timeout, Float
+
+    # @!method initialize(values = {})
+    #   Returns a new instance of RequestOptions.
+    #
+    #   @param values [Hash{Symbol=>Object}]
+
+    define_sorbet_constant!(:OrHash) do
+      T.type_alias { T.any(Nextbillionai::RequestOptions, Nextbillionai::Internal::AnyHash) }
+    end
+  end
+end

data/lib/nextbillionai/resources/areas.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Areas
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::AreaListParams} for more details.
+      #
+      # Get available areas
+      #
+      # @overload list(key:, request_options: {})
+      #
+      # @param key [String] A key is a unique identifier that is required to authenticate a request to the A
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Array<Nextbillionai::Models::AreaListResponseItem>]
+      #
+      # @see Nextbillionai::Models::AreaListParams
+      def list(params)
+        parsed, options = Nextbillionai::AreaListParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "areas",
+          query: parsed,
+          model: Nextbillionai::Internal::Type::ArrayOf[Nextbillionai::Models::AreaListResponseItem],
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Nextbillionai::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/autocomplete.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Autocomplete
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::AutocompleteSuggestParams} for more details.
+      #
+      # Autocomplete
+      #
+      # @overload suggest(key:, q:, at: nil, in_: nil, lang: nil, limit: nil, request_options: {})
+      #
+      # @param key [String] A key is a unique identifier that is required to authenticate a request to the A
+      #
+      # @param q [String] Specify the free-text search query.
+      #
+      # @param at [String] Specify the center of the search context expressed as coordinates.
+      #
+      # @param in_ [String] Search within a geographic area. This is a hard filter. Results will be returned
+      #
+      # @param lang [String] Select the language to be used for result rendering from a list of [BCP 47](http
+      #
+      # @param limit [Integer] Sets the maximum number of results to be returned.
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Nextbillionai::Models::AutocompleteSuggestResponse]
+      #
+      # @see Nextbillionai::Models::AutocompleteSuggestParams
+      def suggest(params)
+        parsed, options = Nextbillionai::AutocompleteSuggestParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "autocomplete",
+          query: parsed.transform_keys(in_: "in"),
+          model: Nextbillionai::Models::AutocompleteSuggestResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Nextbillionai::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/autosuggest.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Autosuggest
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::AutosuggestSuggestParams} for more details.
+      #
+      # Autosuggest
+      #
+      # @overload suggest(key:, q:, at: nil, in_: nil, lang: nil, limit: nil, request_options: {})
+      #
+      # @param key [String] A key is a unique identifier that is required to authenticate a request to the A
+      #
+      # @param q [String] Specify the free-text search query.
+      #
+      # @param at [String] Specify the center of the search context expressed as coordinates.
+      #
+      # @param in_ [String] Search within a geographic area. This is a hard filter. Results will be returned
+      #
+      # @param lang [String] Select the language to be used for result rendering from a list of [BCP 47](http
+      #
+      # @param limit [Integer] Sets the maximum number of results to be returned.
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Nextbillionai::Models::AutosuggestSuggestResponse]
+      #
+      # @see Nextbillionai::Models::AutosuggestSuggestParams
+      def suggest(params)
+        parsed, options = Nextbillionai::AutosuggestSuggestParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "autosuggest",
+          query: parsed.transform_keys(in_: "in"),
+          model: Nextbillionai::Models::AutosuggestSuggestResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Nextbillionai::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/batch.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Batch
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::BatchCreateParams} for more details.
+      #
+      # Create Batch Routing
+      #
+      # @overload create(key:, requests: nil, request_options: {})
+      #
+      # @param key [String] Query param: A key is a unique identifier that is required to authenticate a req
+      #
+      # @param requests [Array<Nextbillionai::Models::BatchCreateParams::Request>] Body param: An array of objects to collect the details of individual routing que
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Nextbillionai::Models::BatchCreateResponse]
+      #
+      # @see Nextbillionai::Models::BatchCreateParams
+      def create(params)
+        parsed, options = Nextbillionai::BatchCreateParams.dump_request(params)
+        query_params = [:key]
+        @client.request(
+          method: :post,
+          path: "batch",
+          query: parsed.slice(*query_params),
+          body: parsed.except(*query_params),
+          model: Nextbillionai::Models::BatchCreateResponse,
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::BatchRetrieveParams} for more details.
+      #
+      # Get Batch Result
+      #
+      # @overload retrieve(key:, track_id:, request_options: {})
+      #
+      # @param key [String] A key is a unique identifier that is required to authenticate a request to the A
+      #
+      # @param track_id [String] Specify the track ID of the batch that was returned in the response after submit
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Nextbillionai::Models::BatchRetrieveResponse]
+      #
+      # @see Nextbillionai::Models::BatchRetrieveParams
+      def retrieve(params)
+        parsed, options = Nextbillionai::BatchRetrieveParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "batch",
+          query: parsed,
+          model: Nextbillionai::Models::BatchRetrieveResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Nextbillionai::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/browse.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Browse
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::BrowseSearchParams} for more details.
+      #
+      # Browse a search area using a free text query
+      #
+      # @overload search(key:, at: nil, categories: nil, in_: nil, lang: nil, limit: nil, request_options: {})
+      #
+      # @param key [String] A key is a unique identifier that is required to authenticate a request to the A
+      #
+      # @param at [String] Specify the center of the search context expressed as coordinates.
+      #
+      # @param categories [String] This is a category filter consisting of a comma-separated list of categories. Pl
+      #
+      # @param in_ [String] Search within a geographic area. This is a hard filter. Results will be returned
+      #
+      # @param lang [String] Select the language to be used for result rendering from a list of [BCP 47](http
+      #
+      # @param limit [Integer] Sets the maximum number of results to be returned.
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Nextbillionai::Models::BrowseSearchResponse]
+      #
+      # @see Nextbillionai::Models::BrowseSearchParams
+      def search(params)
+        parsed, options = Nextbillionai::BrowseSearchParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "browse",
+          query: parsed.transform_keys(in_: "in"),
+          model: Nextbillionai::Models::BrowseSearchResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Nextbillionai::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/directions.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Directions
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::DirectionComputeRouteParams} for more details.
+      #
+      # Directions API is a service that computes a route with given coordinates.
+      #
+      # @overload compute_route(destination:, origin:, altcount: nil, alternatives: nil, approaches: nil, avoid: nil, bearings: nil, cross_border: nil, departure_time: nil, drive_time_limits: nil, emission_class: nil, exclude: nil, geometry: nil, hazmat_type: nil, mode: nil, option: nil, overview: nil, rest_times: nil, road_info: nil, route_type: nil, steps: nil, truck_axle_load: nil, truck_size: nil, truck_weight: nil, turn_angle_range: nil, waypoints: nil, request_options: {})
+      #
+      # @param destination [String]
+      #
+      # @param origin [String]
+      #
+      # @param altcount [Integer] Sets the number of alternative routes to return. It is effective only when alter
+      #
+      # @param alternatives [Boolean] When true the API will return alternate routes.
+      #
+      # @param approaches [String] A semicolon-separated list indicating the side of the road from which to approac
+      #
+      # @param avoid [Symbol, Nextbillionai::Models::DirectionComputeRouteParams::Avoid] When option=fast (by default):
+      #
+      # @param bearings [String] Limits the search to road segments with given bearing, in degrees, towards true
+      #
+      # @param cross_border [Boolean] Requires option=flexible.
+      #
+      # @param departure_time [Integer] Requires option=flexible.
+      #
+      # @param drive_time_limits [String] Requires option=flexible.
+      #
+      # @param emission_class [Symbol, Nextbillionai::Models::DirectionComputeRouteParams::EmissionClass] Requires option=flexible.
+      #
+      # @param exclude [Symbol, Nextbillionai::Models::DirectionComputeRouteParams::Exclude] Requires option=flexible.
+      #
+      # @param geometry [Symbol, Nextbillionai::Models::DirectionComputeRouteParams::Geometry] Sets the output format of the route geometry in the response.
+      #
+      # @param hazmat_type [Symbol, Nextbillionai::Models::DirectionComputeRouteParams::HazmatType] Requires option=flexible.
+      #
+      # @param mode [Symbol, Nextbillionai::Models::DirectionComputeRouteParams::Mode] Set the driving mode the service should use to determine a route. In "car" mode,
+      #
+      # @param option [Symbol, Nextbillionai::Models::DirectionComputeRouteParams::Option] The option parameter specifies the version of the directions service to use. Set
+      #
+      # @param overview [Symbol, Nextbillionai::Models::DirectionComputeRouteParams::Overview] Specify the verbosity of route geometry.
+      #
+      # @param rest_times [String] Requires option=flexible.
+      #
+      # @param road_info [Symbol, Nextbillionai::Models::DirectionComputeRouteParams::RoadInfo] Requires option=flexible.
+      #
+      # @param route_type [Symbol, Nextbillionai::Models::DirectionComputeRouteParams::RouteType] Requires option=flexible.
+      #
+      # @param steps [Boolean] Set this to true to receive additional details about the routes and each of its
+      #
+      # @param truck_axle_load [Float] Requires option=flexible.
+      #
+      # @param truck_size [String] Requires option=flexible.
+      #
+      # @param truck_weight [Integer] Requires option=flexible.
+      #
+      # @param turn_angle_range [Integer] Requires option=flexible.
+      #
+      # @param waypoints [String] Pipe-separated list of coordinate pairs
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Nextbillionai::Models::DirectionComputeRouteResponse]
+      #
+      # @see Nextbillionai::Models::DirectionComputeRouteParams
+      def compute_route(params)
+        parsed, options = Nextbillionai::DirectionComputeRouteParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "directions/json",
+          body: parsed,
+          model: Nextbillionai::Models::DirectionComputeRouteResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Nextbillionai::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/discover.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Discover
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::DiscoverRetrieveParams} for more details.
+      #
+      # Discover matching places
+      #
+      # @overload retrieve(key:, q:, at: nil, in_: nil, lang: nil, limit: nil, request_options: {})
+      #
+      # @param key [String] A key is a unique identifier that is required to authenticate a request to the A
+      #
+      # @param q [String] Specify the free-text search query.
+      #
+      # @param at [String] Specify the center of the search context expressed as coordinates.
+      #
+      # @param in_ [String] Search within a geographic area. This is a hard filter. Results will be returned
+      #
+      # @param lang [String] Select the language to be used for result rendering from a list of [BCP 47](http
+      #
+      # @param limit [Integer] Sets the maximum number of results to be returned.
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Nextbillionai::Models::DiscoverRetrieveResponse]
+      #
+      # @see Nextbillionai::Models::DiscoverRetrieveParams
+      def retrieve(params)
+        parsed, options = Nextbillionai::DiscoverRetrieveParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "discover",
+          query: parsed.transform_keys(in_: "in"),
+          model: Nextbillionai::Models::DiscoverRetrieveResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Nextbillionai::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/distance_matrix/json.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class DistanceMatrix
+      class Json
+        # asfd
+        #
+        # @overload create(request_options: {})
+        #
+        # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [nil]
+        #
+        # @see Nextbillionai::Models::DistanceMatrix::JsonCreateParams
+        def create(params = {})
+          @client.request(
+            method: :post,
+            path: "distancematrix/json",
+            model: NilClass,
+            options: params[:request_options]
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Nextbillionai::Models::DistanceMatrix::JsonRetrieveParams} for more details.
+        #
+        # Nextbillion.ai Distance Matrix API computes distances and ETAs between a set of
+        # origins and destinations — could be for one-to-many or many-to-many scenarios.
+        # The API call returns a matrix of ETAs and distances for each origin and
+        # destination pair. For example, If the set is Origins {A,B} and Destinations
+        # {C,D,E} we can get the following set of results with distance (meters) and time
+        # (seconds) for each. The GET method can only handle up to 100 locations (1
+        # location is either 1 origin or 1 destination).
+        #
+        # @overload retrieve(destinations:, key:, origins:, approaches: nil, avoid: nil, bearings: nil, mode: nil, route_failed_prompt: nil, request_options: {})
+        #
+        # @param destinations [String] "destinations" are the ending coordinates of your route. Ensure that "destinatio
+        #
+        # @param key [String] A key is a unique identifier that is required to authenticate a request to the A
+        #
+        # @param origins [String] "origins" are the starting point of your route. Ensure that "origins" are routab
+        #
+        # @param approaches [Symbol, Nextbillionai::Models::DistanceMatrix::JsonRetrieveParams::Approaches] A semicolon-separated list indicating the side of the road from which the route
+        #
+        # @param avoid [Symbol, Nextbillionai::Models::DistanceMatrix::JsonRetrieveParams::Avoid] Setting this will ensure the route avoids ferries, tolls, highways or nothing. M
+        #
+        # @param bearings [String] Limits the search to segments with given bearing in degrees towards true north i
+        #
+        # @param mode [Symbol, Nextbillionai::Models::DistanceMatrix::JsonRetrieveParams::Mode] Set which driving mode the service should use to determine the "distance" and "d
+        #
+        # @param route_failed_prompt [Boolean] A prompt to modify the response in case no feasible route is available for a giv
+        #
+        # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Nextbillionai::Models::DistanceMatrix::JsonRetrieveResponse]
+        #
+        # @see Nextbillionai::Models::DistanceMatrix::JsonRetrieveParams
+        def retrieve(params)
+          parsed, options = Nextbillionai::DistanceMatrix::JsonRetrieveParams.dump_request(params)
+          @client.request(
+            method: :get,
+            path: "distancematrix/json",
+            query: parsed,
+            model: Nextbillionai::Models::DistanceMatrix::JsonRetrieveResponse,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Nextbillionai::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/distance_matrix.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class DistanceMatrix
+      # @return [Nextbillionai::Resources::DistanceMatrix::Json]
+      attr_reader :json
+
+      # @api private
+      #
+      # @param client [Nextbillionai::Client]
+      def initialize(client:)
+        @client = client
+        @json = Nextbillionai::Resources::DistanceMatrix::Json.new(client: client)
+      end
+    end
+  end
+end