nextbillionai 0.1.0.pre.alpha.4

data/lib/nextbillionai/resources/multigeocode/place.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Multigeocode
+      class Place
+        # Some parameter documentations has been truncated, see
+        # {Nextbillionai::Models::Multigeocode::PlaceCreateParams} for more details.
+        #
+        # The "Add Place" method allows users to create custom places
+        #
+        # Add place method provides the flexibility to create custom places in a way that
+        # suits your business needs. The newly created place and its attributes can be
+        # added to custom (proprietary) dataset - to the effect of building your own
+        # places dataset (s) - or, to a default dataset. Overcome inaccurate ‘POI’ details
+        # from default search provider by creating custom, highly accurate ‘POIs’.
+        #
+        # @overload create(key:, place:, data_source: nil, force: nil, score: nil, request_options: {})
+        #
+        # @param key [String] Query param: A key is a unique identifier that is required to authenticate a req
+        #
+        # @param place [Array<Nextbillionai::Models::Multigeocode::PlaceCreateParams::Place>] Body param: This parameter represents the place details, including geographical
+        #
+        # @param data_source [Nextbillionai::Models::Multigeocode::PlaceCreateParams::DataSource] Body param: It contains information about the dataset that returns the specific
+        #
+        # @param force [Boolean] Body param: When 2 places are located within 100 meters of each other and have m
+        #
+        # @param score [Integer] Body param: Search score of the place. This is calculated based on how ‘richly’
+        #
+        # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Nextbillionai::Models::Multigeocode::PlaceCreateResponse]
+        #
+        # @see Nextbillionai::Models::Multigeocode::PlaceCreateParams
+        def create(params)
+          parsed, options = Nextbillionai::Multigeocode::PlaceCreateParams.dump_request(params)
+          query_params = [:key]
+          @client.request(
+            method: :post,
+            path: "multigeocode/place",
+            query: parsed.slice(*query_params),
+            body: parsed.except(*query_params),
+            model: Nextbillionai::Models::Multigeocode::PlaceCreateResponse,
+            options: options
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Nextbillionai::Models::Multigeocode::PlaceRetrieveParams} for more details.
+        #
+        # Use this method to get the details of previously created custom places using its
+        # NextBillion ID.
+        #
+        # @overload retrieve(doc_id, key:, request_options: {})
+        #
+        # @param doc_id [String] Unique NextBillion ID of the location to be looked up.
+        #
+        # @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 [Nextbillionai::Models::Multigeocode::PlaceRetrieveResponse]
+        #
+        # @see Nextbillionai::Models::Multigeocode::PlaceRetrieveParams
+        def retrieve(doc_id, params)
+          parsed, options = Nextbillionai::Multigeocode::PlaceRetrieveParams.dump_request(params)
+          @client.request(
+            method: :get,
+            path: ["multigeocode/place/%1$s", doc_id],
+            query: parsed,
+            model: Nextbillionai::Models::Multigeocode::PlaceRetrieveResponse,
+            options: options
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Nextbillionai::Models::Multigeocode::PlaceUpdateParams} for more details.
+        #
+        # The "Update Place" method allows businesses to update the attributes of an
+        # existing place.
+        #
+        # This method allows you to update the attributes of custom places. In effect,
+        # updating a place replaces the current information in search results with the
+        # updated information associated with the specific docID. Use this method to
+        # enhance the accuracy/usability of your search results with respect to the
+        # default dataset to suit your business needs.
+        #
+        # If you want to prioritize a particular result in your search results, update the
+        # ‘score’ of that specific place.
+        # Alternatively, you can block places which are no longer needed by setting their
+        # status: ‘disable’.
+        #
+        # @overload update(doc_id, key:, data_source: nil, place: nil, score: nil, request_options: {})
+        #
+        # @param doc_id [String] Path param: Unique NextBillion ID of the location to be updated.
+        #
+        # @param key [String] Query param: A key is a unique identifier that is required to authenticate a req
+        #
+        # @param data_source [Nextbillionai::Models::Multigeocode::PlaceUpdateParams::DataSource] Body param: dataSource values can be updated to enhance or prioritize the search
+        #
+        # @param place [Array<Nextbillionai::Models::Multigeocode::PlaceItem>] Body param: This parameter represents the place details, including geographical
+        #
+        # @param score [Integer] Body param: Search score of the place. This is calculated based on how ‘richly’
+        #
+        # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Nextbillionai::Models::Multigeocode::PlaceUpdateResponse]
+        #
+        # @see Nextbillionai::Models::Multigeocode::PlaceUpdateParams
+        def update(doc_id, params)
+          parsed, options = Nextbillionai::Multigeocode::PlaceUpdateParams.dump_request(params)
+          query_params = [:key]
+          @client.request(
+            method: :put,
+            path: ["multigeocode/place/%1$s", doc_id],
+            query: parsed.slice(*query_params),
+            body: parsed.except(*query_params),
+            model: Nextbillionai::Models::Multigeocode::PlaceUpdateResponse,
+            options: options
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Nextbillionai::Models::Multigeocode::PlaceDeleteParams} for more details.
+        #
+        # The "Delete Place" method enables businesses to delete a previously created
+        # place
+        #
+        # Use this method to delete a previously created place. Please note that the place
+        # associated with the specified docID only would be deleted. As a result, once a
+        # place is deleted, the search API can still return valid results from the default
+        # datasets or others, if present.
+        #
+        # @overload delete(doc_id, key:, request_options: {})
+        #
+        # @param doc_id [String] Unique NextBillion ID of the location to be deleted
+        #
+        # @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 [Nextbillionai::Models::Multigeocode::PlaceDeleteResponse]
+        #
+        # @see Nextbillionai::Models::Multigeocode::PlaceDeleteParams
+        def delete(doc_id, params)
+          parsed, options = Nextbillionai::Multigeocode::PlaceDeleteParams.dump_request(params)
+          @client.request(
+            method: :delete,
+            path: ["multigeocode/place/%1$s", doc_id],
+            query: parsed,
+            model: Nextbillionai::Models::Multigeocode::PlaceDeleteResponse,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Nextbillionai::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/multigeocode.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Multigeocode
+      # @return [Nextbillionai::Resources::Multigeocode::Place]
+      attr_reader :place
+
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::MultigeocodeSearchParams} for more details.
+      #
+      # The method enables searching for known places from multiple data sources
+      #
+      # Use this method to find known places in default or your own custom (proprietary)
+      # dataset and get a combined search result. It accepts free-form, partially
+      # correct or even incomplete search texts. Results would be ranked based on the
+      # search score of a place.
+      #
+      # @overload search(key:, at:, query:, city: nil, country: nil, district: nil, limit: nil, radius: nil, state: nil, street: nil, sub_district: nil, request_options: {})
+      #
+      # @param key [String] Query param: A key is a unique identifier that is required to authenticate a req
+      #
+      # @param at [Nextbillionai::Models::MultigeocodeSearchParams::At] Body param: Specify the center of the search context expressed as coordinates.
+      #
+      # @param query [String] Body param: A free-form, complete or incomplete string to be searched. It allows
+      #
+      # @param city [String] Body param: Specifies the primary city of the place.
+      #
+      # @param country [String] Body param: Country of the search context provided as comma-separated [ISO 3166-
+      #
+      # @param district [String] Body param: Specifies the district of the search place.
+      #
+      # @param limit [Integer] Body param: Sets the maximum number of results to be returned.
+      #
+      # @param radius [String] Body param: Filters the results to places within the specified radius from the '
+      #
+      # @param state [String] Body param: Specifies the state of the search place.
+      #
+      # @param street [String] Body param: Specifies the street name of the search place.
+      #
+      # @param sub_district [String] Body param: Specifies the subDistrict of the search place.
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Nextbillionai::Models::MultigeocodeSearchResponse]
+      #
+      # @see Nextbillionai::Models::MultigeocodeSearchParams
+      def search(params)
+        parsed, options = Nextbillionai::MultigeocodeSearchParams.dump_request(params)
+        query_params = [:key]
+        @client.request(
+          method: :post,
+          path: "multigeocode/search",
+          query: parsed.slice(*query_params),
+          body: parsed.except(*query_params),
+          model: Nextbillionai::Models::MultigeocodeSearchResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Nextbillionai::Client]
+      def initialize(client:)
+        @client = client
+        @place = Nextbillionai::Resources::Multigeocode::Place.new(client: client)
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/navigation.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Navigation
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::NavigationRetrieveRouteParams} for more details.
+      #
+      # Nextbillion.ai’s Navigation API is a service that computes a route between 2
+      # places, and also returns detailed turn by turn instructions for the route.
+      #
+      # The Navigation API can be used as an input into your Navigation app.
+      # Alternatively, you can directly use Nextbillion.ai’s Navigation SDK for a
+      # complete turn by turn navigation experience.
+      #
+      # @overload retrieve_route(key:, altcount: nil, alternatives: nil, approaches: nil, avoid: nil, bearings: nil, destination: nil, geometry: nil, lang: nil, mode: nil, origin: nil, original_shape: nil, original_shape_type: nil, overview: nil, waypoints: nil, request_options: {})
+      #
+      # @param key [String] A key is a unique identifier that is required to authenticate a request to the A
+      #
+      # @param altcount [Integer] Sets the number of alternative routes to return. It is effective only when "alte
+      #
+      # @param alternatives [Boolean] When "true" the API will return alternate routes. The "alternatives" is effectiv
+      #
+      # @param approaches [Symbol, Nextbillionai::Models::NavigationRetrieveRouteParams::Approaches] A semicolon-separated list indicating the side of the road from which to approac
+      #
+      # @param avoid [Symbol, Nextbillionai::Models::NavigationRetrieveRouteParams::Avoid] Setting this will ensure the route avoids ferries, tolls, highways or nothing. M
+      #
+      # @param bearings [String] Limits the search to road segments with given bearing, in degrees, towards true
+      #
+      # @param destination [String] "destination" is the ending point of your route. Ensure that the "destination" i
+      #
+      # @param geometry [Symbol, Nextbillionai::Models::NavigationRetrieveRouteParams::Geometry] Sets the output format of the route geometry in the response. On providing “poly
+      #
+      # @param lang [String] Select the language to be used for result rendering from a list of [BCP 47](http
+      #
+      # @param mode [Symbol, Nextbillionai::Models::NavigationRetrieveRouteParams::Mode] Set which driving mode the service should use to determine a route. For example,
+      #
+      # @param origin [String] "origin" is the starting point of your route. Ensure that "origin" is a routable
+      #
+      # @param original_shape [String] Takes a route geometry as input and returns the navigation information for that
+      #
+      # @param original_shape_type [Symbol, Nextbillionai::Models::NavigationRetrieveRouteParams::OriginalShapeType] Specify the encoding format of route geometry provided in the request using "ori
+      #
+      # @param overview [Symbol, Nextbillionai::Models::NavigationRetrieveRouteParams::Overview] Specify the verbosity of route geometry. When set to "full", the most detailed g
+      #
+      # @param waypoints [String] "waypoints" are coordinates along the route between the "origin" and "destinatio
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Nextbillionai::Models::NavigationRetrieveRouteResponse]
+      #
+      # @see Nextbillionai::Models::NavigationRetrieveRouteParams
+      def retrieve_route(params)
+        parsed, options = Nextbillionai::NavigationRetrieveRouteParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "navigation/json",
+          query: parsed,
+          model: Nextbillionai::Models::NavigationRetrieveRouteResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Nextbillionai::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/optimization/driver_assignment.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Optimization
+      class DriverAssignment
+        # Some parameter documentations has been truncated, see
+        # {Nextbillionai::Models::Optimization::DriverAssignmentAssignParams} for more
+        # details.
+        #
+        # Assigns available drivers (vehicles) to open orders based on specified criteria
+        # and constraints.
+        #
+        # @overload assign(key:, filter:, orders:, vehicles:, options: nil, request_options: {})
+        #
+        # @param key [String] Query param: A key is a unique identifier that is required to authenticate a req
+        #
+        # @param filter [Nextbillionai::Models::Optimization::DriverAssignmentAssignParams::Filter] Body param: Specify the filtering criterion for the vehicles with respect to eac
+        #
+        # @param orders [Array<Nextbillionai::Models::Optimization::DriverAssignmentAssignParams::Order>] Body param: Collects the details of open orders to be fulfilled. Each object rep
+        #
+        # @param vehicles [Array<Nextbillionai::Models::Optimization::Vehicle>] Body param: Collects the details of vehicles available to fulfill the orders. Ea
+        #
+        # @param options [Nextbillionai::Models::Optimization::DriverAssignmentAssignParams::Options] Body param: Configure the assignment constraints and response settings.
+        #
+        # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Nextbillionai::Models::Optimization::DriverAssignmentAssignResponse]
+        #
+        # @see Nextbillionai::Models::Optimization::DriverAssignmentAssignParams
+        def assign(params)
+          parsed, options = Nextbillionai::Optimization::DriverAssignmentAssignParams.dump_request(params)
+          query_params = [:key]
+          @client.request(
+            method: :post,
+            path: "optimization/driver-assignment/v1",
+            query: parsed.slice(*query_params),
+            body: parsed.except(*query_params),
+            model: Nextbillionai::Models::Optimization::DriverAssignmentAssignResponse,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Nextbillionai::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/optimization/v2.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Optimization
+      class V2
+        # Some parameter documentations has been truncated, see
+        # {Nextbillionai::Models::Optimization::V2RetrieveResultParams} for more details.
+        #
+        # Flexible GET
+        #
+        # @overload retrieve_result(id:, key:, request_options: {})
+        #
+        # @param id [String] The unique ID that was returned on successful submission of the Optimization POS
+        #
+        # @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 [Nextbillionai::Models::Optimization::V2RetrieveResultResponse]
+        #
+        # @see Nextbillionai::Models::Optimization::V2RetrieveResultParams
+        def retrieve_result(params)
+          parsed, options = Nextbillionai::Optimization::V2RetrieveResultParams.dump_request(params)
+          @client.request(
+            method: :get,
+            path: "optimization/v2/result",
+            query: parsed,
+            model: Nextbillionai::Models::Optimization::V2RetrieveResultResponse,
+            options: options
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Nextbillionai::Models::Optimization::V2SubmitParams} for more details.
+        #
+        # Flexible POST
+        #
+        # @overload submit(key:, locations:, vehicles:, cost_matrix: nil, depots: nil, description: nil, distance_matrix: nil, duration_matrix: nil, existing_solution_id: nil, jobs: nil, options: nil, relations: nil, shipments: nil, solution: nil, unassigned: nil, zones: nil, request_options: {})
+        #
+        # @param key [String] Query param: A key is a unique identifier that is required to authenticate a req
+        #
+        # @param locations [Nextbillionai::Models::Optimization::V2SubmitParams::Locations] Body param: The locations object is used to define all the locations that will b
+        #
+        # @param vehicles [Array<Nextbillionai::Models::Optimization::Vehicle>] Body param: The vehicles attribute describes the characteristics and constraints
+        #
+        # @param cost_matrix [Array<Array<Integer>>] Body param: An array of arrays to denote the user-defined costs of traveling bet
+        #
+        # @param depots [Array<Nextbillionai::Models::Optimization::V2SubmitParams::Depot>] Body param: depots object is used to collect the details of a depot. Depots can
+        #
+        # @param description [String] Body param: Define the optimization job using any custom message. This descripti
+        #
+        # @param distance_matrix [Array<Array<Integer>>] Body param: An array of arrays to denote the user-defined distances, in meters,
+        #
+        # @param duration_matrix [Array<Array<Integer>>] Body param: An array of arrays to denote the user-defined durations, in seconds,
+        #
+        # @param existing_solution_id [String] Body param: The previous optimization request id used to retrieve solution for r
+        #
+        # @param jobs [Array<Nextbillionai::Models::Optimization::Job>] Body param: jobs object is used to collect the details of a particular job or ta
+        #
+        # @param options [Nextbillionai::Models::Optimization::V2SubmitParams::Options] Body param: It represents the set of options that can be used to configure optim
+        #
+        # @param relations [Array<Nextbillionai::Models::Optimization::V2SubmitParams::Relation>] Body param: relations attribute is an array of individual relation objects. type
+        #
+        # @param shipments [Array<Nextbillionai::Models::Optimization::Shipment>] Body param: The shipments object is used to collect the details of shipments tha
+        #
+        # @param solution [Array<Nextbillionai::Models::Optimization::V2SubmitParams::Solution>] Body param: This attribute is related to the re-optimization feature. It allows
+        #
+        # @param unassigned [Nextbillionai::Models::Optimization::V2SubmitParams::Unassigned] Body param: unassigned attribute is related to the re-optimization feature. This
+        #
+        # @param zones [Array<Nextbillionai::Models::Optimization::V2SubmitParams::Zone>] Body param: An array of objects to specify geometry of all the zones involved. E
+        #
+        # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Nextbillionai::Models::PostResponse]
+        #
+        # @see Nextbillionai::Models::Optimization::V2SubmitParams
+        def submit(params)
+          parsed, options = Nextbillionai::Optimization::V2SubmitParams.dump_request(params)
+          query_params = [:key]
+          @client.request(
+            method: :post,
+            path: "optimization/v2",
+            query: parsed.slice(*query_params),
+            body: parsed.except(*query_params),
+            model: Nextbillionai::PostResponse,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Nextbillionai::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/optimization.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Optimization
+      # @return [Nextbillionai::Resources::Optimization::DriverAssignment]
+      attr_reader :driver_assignment
+
+      # @return [Nextbillionai::Resources::Optimization::V2]
+      attr_reader :v2
+
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::OptimizationComputeParams} for more details.
+      #
+      # Nextbillion.ai Optimization API computes and returns an optimized route between
+      # an origin and destination which have multiple stop points in between. With
+      # NextBillion.ai's Route Optimization API you get.
+      #
+      # Optimized routing between way points
+      #
+      # Highly accurate ETAs with customized routes
+      #
+      # Roundtrip optimization with customized destinations
+      #
+      # A list of all parameters is specified in the next section.
+      #
+      # @overload compute(coordinates:, key:, approaches: nil, destination: nil, geometries: nil, mode: nil, roundtrip: nil, source: nil, with_geometry: nil, request_options: {})
+      #
+      # @param coordinates [String] This is a pipe-separated list of coordinates.
+      #
+      # @param key [String] A key is a unique identifier that is required to authenticate a request to the A
+      #
+      # @param approaches [Symbol, Nextbillionai::Models::OptimizationComputeParams::Approaches] A semicolon-separated list indicating the side of the road from which to approac
+      #
+      # @param destination [Symbol, Nextbillionai::Models::OptimizationComputeParams::Destination] Specify the destination coordinate of the returned route. If the input is last,
+      #
+      # @param geometries [Symbol, Nextbillionai::Models::OptimizationComputeParams::Geometries] Sets the output format of the route geometry in the response.
+      #
+      # @param mode [Symbol, Nextbillionai::Models::OptimizationComputeParams::Mode] Set which driving mode the service should use to determine a route. For example,
+      #
+      # @param roundtrip [Boolean] Indicates whether the returned route is a roundtrip.
+      #
+      # @param source [Symbol, Nextbillionai::Models::OptimizationComputeParams::Source] The coordinate at which to start the returned route. If this is not configured,
+      #
+      # @param with_geometry [Boolean] Indicates whether the return geometry should be computed or not.
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Nextbillionai::Models::OptimizationComputeResponse]
+      #
+      # @see Nextbillionai::Models::OptimizationComputeParams
+      def compute(params)
+        parsed, options = Nextbillionai::OptimizationComputeParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "optimization/json",
+          query: parsed,
+          model: Nextbillionai::Models::OptimizationComputeResponse,
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::OptimizationReOptimizeParams} for more details.
+      #
+      # Re-optimization
+      #
+      # @overload re_optimize(key:, existing_request_id:, job_changes: nil, locations: nil, shipment_changes: nil, vehicle_changes: nil, request_options: {})
+      #
+      # @param key [String] Query param: A key is a unique identifier that is required to authenticate a req
+      #
+      # @param existing_request_id [String] Body param: Specify the unique request ID that needs to be re-optimized.
+      #
+      # @param job_changes [Nextbillionai::Models::OptimizationReOptimizeParams::JobChanges] Body param: This section gathers information on modifications to the number of j
+      #
+      # @param locations [Array<String>] Body param: Provide the list of locations to be used during re-optimization proc
+      #
+      # @param shipment_changes [Nextbillionai::Models::OptimizationReOptimizeParams::ShipmentChanges] Body param: This section gathers information on modifications to the number of s
+      #
+      # @param vehicle_changes [Nextbillionai::Models::OptimizationReOptimizeParams::VehicleChanges] Body param: This section gathers information on modifications to the number of v
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Nextbillionai::Models::PostResponse]
+      #
+      # @see Nextbillionai::Models::OptimizationReOptimizeParams
+      def re_optimize(params)
+        parsed, options = Nextbillionai::OptimizationReOptimizeParams.dump_request(params)
+        query_params = [:key]
+        @client.request(
+          method: :post,
+          path: "optimization/re_optimization",
+          query: parsed.slice(*query_params),
+          body: parsed.except(*query_params),
+          model: Nextbillionai::PostResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Nextbillionai::Client]
+      def initialize(client:)
+        @client = client
+        @driver_assignment = Nextbillionai::Resources::Optimization::DriverAssignment.new(client: client)
+        @v2 = Nextbillionai::Resources::Optimization::V2.new(client: client)
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/postalcode.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Postalcode
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::PostalcodeRetrieveCoordinatesParams} for more details.
+      #
+      # Retrieve coordinates by postal code
+      #
+      # @overload retrieve_coordinates(key:, at: nil, country: nil, format_: nil, postalcode: nil, request_options: {})
+      #
+      # @param key [String] Query param: A key is a unique identifier that is required to authenticate a req
+      #
+      # @param at [Nextbillionai::Models::PostalcodeRetrieveCoordinatesParams::At] Body param: Location coordinates that you want to get the postal code of. If not
+      #
+      # @param country [String] Body param: Country containing the postal code or the location. It is mandatory
+      #
+      # @param format_ [Symbol, Nextbillionai::Models::PostalcodeRetrieveCoordinatesParams::Format] Body param: Specify the format in which the boundary details of the post code wi
+      #
+      # @param postalcode [String] Body param: Provide the postal code for which the information is needed. At leas
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Nextbillionai::Models::PostalcodeRetrieveCoordinatesResponse]
+      #
+      # @see Nextbillionai::Models::PostalcodeRetrieveCoordinatesParams
+      def retrieve_coordinates(params)
+        parsed, options = Nextbillionai::PostalcodeRetrieveCoordinatesParams.dump_request(params)
+        query_params = [:key]
+        @client.request(
+          method: :post,
+          path: "postalcode",
+          query: parsed.slice(*query_params),
+          body: parsed.except(*query_params),
+          model: Nextbillionai::Models::PostalcodeRetrieveCoordinatesResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Nextbillionai::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end