nextbillionai 0.1.0.pre.alpha.4

data/rbi/nextbillionai/resources/discover.rbi

@@ -0,0 +1,75 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Discover
+      # Discover matching places
+      sig do
+        params(
+          key: String,
+          q: String,
+          at: String,
+          in_: String,
+          lang: String,
+          limit: Integer,
+          request_options: Nextbillionai::RequestOptions::OrHash
+        ).returns(Nextbillionai::Models::DiscoverRetrieveResponse)
+      end
+      def retrieve(
+        # A key is a unique identifier that is required to authenticate a request to the
+        # API.
+        key:,
+        # Specify the free-text search query.
+        #
+        # Please note that whitespace, urls, email addresses, or other out-of-scope
+        # queries will yield no results.
+        q:,
+        # Specify the center of the search context expressed as coordinates.
+        #
+        # Please note that one of "at", "in=circle" or "in=bbox" should be provided for
+        # relevant results.
+        at: nil,
+        # Search within a geographic area. This is a hard filter. Results will be returned
+        # if they are located within the specified area.
+        #
+        # A geographic area can be
+        #
+        # - a country (or multiple countries), provided as comma-separated
+        #   [ISO 3166-1 alpha-3](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-3) country
+        #   codes
+        #
+        #   The country codes are to be provided in all uppercase.
+        #
+        #   Format: countryCode:{countryCode}[,{countryCode}]
+        #
+        # - a circular area, provided as latitude, longitude, and radius (an integer with
+        #   meters as unit)
+        #
+        #   Format: circle:{latitude},{longitude};r={radius}
+        #
+        # - a bounding box, provided as _west longitude_, _south latitude_, _east
+        #   longitude_, _north latitude_
+        #
+        #   Format: bbox:{west longitude},{south latitude},{east longitude},{north
+        #   latitude}
+        #
+        # Please provide one of 'at', 'in=circle' or 'in=bbox' input for a relevant
+        # result.
+        in_: nil,
+        # Select the language to be used for result rendering from a list of
+        # [BCP 47](https://en.wikipedia.org/wiki/IETF_language_tag) compliant language
+        # codes.
+        lang: nil,
+        # Sets the maximum number of results to be returned.
+        limit: nil,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Nextbillionai::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/nextbillionai/resources/distance_matrix/json.rbi

@@ -0,0 +1,129 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class DistanceMatrix
+      class Json
+        # asfd
+        sig do
+          params(request_options: Nextbillionai::RequestOptions::OrHash).void
+        end
+        def create(request_options: {})
+        end
+
+        # 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).
+        sig do
+          params(
+            destinations: String,
+            key: String,
+            origins: String,
+            approaches:
+              Nextbillionai::DistanceMatrix::JsonRetrieveParams::Approaches::OrSymbol,
+            avoid:
+              Nextbillionai::DistanceMatrix::JsonRetrieveParams::Avoid::OrSymbol,
+            bearings: String,
+            mode:
+              Nextbillionai::DistanceMatrix::JsonRetrieveParams::Mode::OrSymbol,
+            route_failed_prompt: T::Boolean,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Models::DistanceMatrix::JsonRetrieveResponse)
+        end
+        def retrieve(
+          # "destinations" are the ending coordinates of your route. Ensure that
+          # "destinations" are routable land locations. Multiple "destinations" should be
+          # separated by a pipe symbol "|".
+          destinations:,
+          # A key is a unique identifier that is required to authenticate a request to the
+          # API.
+          key:,
+          # "origins" are the starting point of your route. Ensure that "origins" are
+          # routable land locations. Multiple "origins" should be separated by a pipe symbol
+          # "|".
+          origins:,
+          # A semicolon-separated list indicating the side of the road from which the route
+          # will approach "destinations". When set to "unrestricted" a route can arrive at a
+          # destination from either side of the road. When set to "curb" the route will
+          # arrive at a destination on the driving side of the region. Please note the
+          # number of values provided must be equal to the number of "destinations".
+          # However, you can skip a coordinate and show its position in the list with the
+          # ";" separator. The values provided for the "approaches" parameter are effective
+          # for the "destinations" value at the same index. Example: "curb;;curb" will apply
+          # curbside restriction on the "destinations" points provided at the first and
+          # third index.
+          approaches: nil,
+          # Setting this will ensure the route avoids ferries, tolls, highways or nothing.
+          # Multiple values should be separated by a pipe (|). If "none" is provided along
+          # with other values, an error is returned as a valid route is not feasible. Please
+          # note that when this parameter is not provided in the input, ferries are set to
+          # be avoided by default. When this parameter is provided, only the mentioned
+          # objects are avoided.
+          avoid: nil,
+          # Limits the search to segments with given bearing in degrees towards true north
+          # in clockwise direction. Each "bearing" should be in the format of
+          # "degree,range", where the "degree" should be a value between \[0, 360\] and
+          # "range" should be a value between \[0, 180\]. Please note that the number of
+          # "bearings" should be equal to the sum of the number of points in "origins" and
+          # "destinations". If a route can approach a destination from any direction, the
+          # bearing for that point can be specified as "0,180".
+          bearings: nil,
+          # Set which driving mode the service should use to determine the "distance" and
+          # "duration" values. For example, if you use "car", the API will return the
+          # duration and distance of a route that a car can take. Using "truck" will return
+          # the same for a route a truck can use, taking into account appropriate truck
+          # routing restrictions.
+          #
+          # When "mode=truck", following are the default dimensions that are used:
+          #
+          # \- truck_height = 214 centimeters
+          #
+          # \- truck_width = 183 centimeters
+          #
+          # \- truck_length = 519 centimeters
+          #
+          # \- truck_weight = 5000 kg
+          #
+          # Please use the Distance Matrix Flexible version if you want to use custom truck
+          # dimensions.
+          #
+          # Note: Only the "car" profile is enabled by default. Please note that customized
+          # profiles (including "truck") might not be available for all regions. Please
+          # contact your [NextBillion.ai](http://NextBillion.ai) account manager, sales
+          # representative or reach out at
+          # [support@nextbillion.ai](mailto:support@nextbillion.ai) in case you need
+          # additional profiles.
+          mode: nil,
+          # A prompt to modify the response in case no feasible route is available for a
+          # given pair of origin and destination. When set to "true", a value of "-1" is
+          # returned for those pairs in which:
+          #
+          # \- Either origin or the destination can not be snapped to a nearest road. Please
+          # note that if all the origins and destinations in a request can't be snapped to
+          # their nearest roads, a 4xx error is returned instead, as the entire request
+          # failed.
+          #
+          # \- Both origin and destination can be snapped to the nearest road, but the
+          # service can't find a valid route between them. However, a value of "0" is
+          # returned if both the origin and destination are snapped to the same location.
+          #
+          # "false" is the default value. In this case, a "0" value is returned for all the
+          # above cases. A 4xx error is returned, in this case as well, when all origins and
+          # destinations in the request can't be snapped to their nearest road.
+          route_failed_prompt: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Nextbillionai::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/nextbillionai/resources/distance_matrix.rbi

@@ -0,0 +1,15 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class DistanceMatrix
+      sig { returns(Nextbillionai::Resources::DistanceMatrix::Json) }
+      attr_reader :json
+
+      # @api private
+      sig { params(client: Nextbillionai::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/nextbillionai/resources/fleetify/document_templates.rbi

@@ -0,0 +1,130 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Fleetify
+      class DocumentTemplates
+        # Create Document template
+        sig do
+          params(
+            key: String,
+            content:
+              T::Array[
+                Nextbillionai::Fleetify::DocumentTemplateContentRequest::OrHash
+              ],
+            name: String,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(
+            Nextbillionai::Models::Fleetify::DocumentTemplateCreateResponse
+          )
+        end
+        def create(
+          # Query param: A key is a unique identifier that is required to authenticate a
+          # request to the API.
+          key:,
+          # Body param: A form field that drivers must complete when executing a route step.
+          # Defines the data structure and validation rules for collecting required
+          # information during route execution.
+          content:,
+          # Body param: Specify a name for the document template to be created.
+          name:,
+          request_options: {}
+        )
+        end
+
+        # Retrieve template by ID
+        sig do
+          params(
+            id: String,
+            key: String,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(
+            Nextbillionai::Models::Fleetify::DocumentTemplateRetrieveResponse
+          )
+        end
+        def retrieve(
+          # Specify the unique identifier of the document template.
+          id,
+          # A key is a unique identifier that is required to authenticate a request to the
+          # API.
+          key:,
+          request_options: {}
+        )
+        end
+
+        # Update a document template
+        sig do
+          params(
+            id: String,
+            key: String,
+            content:
+              T::Array[
+                Nextbillionai::Fleetify::DocumentTemplateContentRequest::OrHash
+              ],
+            name: String,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(
+            Nextbillionai::Models::Fleetify::DocumentTemplateUpdateResponse
+          )
+        end
+        def update(
+          # Path param: Specify the unique identifier of the document template.
+          id,
+          # Query param: A key is a unique identifier that is required to authenticate a
+          # request to the API.
+          key:,
+          # Body param: An object to collect the details of form fields to be updated - data
+          # structures, validation rules. Please note that the details provided here will
+          # overwrite any existing document fields in the given template.
+          content: nil,
+          # Body param: Specify the document template name to be updated.
+          name: nil,
+          request_options: {}
+        )
+        end
+
+        # Get all document templates
+        sig do
+          params(
+            key: String,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(
+            Nextbillionai::Models::Fleetify::DocumentTemplateListResponse
+          )
+        end
+        def list(
+          # A key is a unique identifier that is required to authenticate a request to the
+          # API.
+          key:,
+          request_options: {}
+        )
+        end
+
+        # Delete a document template
+        sig do
+          params(
+            id: String,
+            key: String,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(
+            Nextbillionai::Models::Fleetify::DocumentTemplateDeleteResponse
+          )
+        end
+        def delete(
+          # Specify the unique identifier of the document template.
+          id,
+          # A key is a unique identifier that is required to authenticate a request to the
+          # API.
+          key:,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Nextbillionai::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/nextbillionai/resources/fleetify/routes/steps.rbi

@@ -0,0 +1,270 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Fleetify
+      class Routes
+        class Steps
+          # Insert a new step
+          sig do
+            params(
+              route_id: String,
+              key: String,
+              arrival: Integer,
+              location: T::Array[Float],
+              position: Integer,
+              type:
+                Nextbillionai::Fleetify::Routes::StepCreateParams::Type::OrSymbol,
+              address: String,
+              completion_mode:
+                Nextbillionai::Fleetify::Routes::RouteStepCompletionMode::OrSymbol,
+              document_template_id: String,
+              duration: Integer,
+              geofence_config:
+                Nextbillionai::Fleetify::Routes::RouteStepGeofenceConfig::OrHash,
+              meta:
+                Nextbillionai::Fleetify::Routes::StepCreateParams::Meta::OrHash,
+              request_options: Nextbillionai::RequestOptions::OrHash
+            ).returns(
+              Nextbillionai::Models::Fleetify::Routes::StepCreateResponse
+            )
+          end
+          def create(
+            # Path param: Provide the ID of a previously dispatched route which needs to be
+            # modified. Both the id and short_id of the route are a valid input.
+            route_id,
+            # Query param: A key is a unique identifier that is required to authenticate a
+            # request to the API.
+            key:,
+            # Body param: Specify the scheduled arrival time of the driver, as an UNIX
+            # timestamp in seconds, at the step. Please note that:
+            #
+            # - Arrival time for each step should be equal to or greater than the previous
+            #   step.
+            # - Past times can not be provided.
+            # - The time provided is used only for informative display on the driver app and
+            #   it does not impact or get affected by the route generated.
+            arrival:,
+            # Body param: Specify the location coordinates where the steps should be performed
+            # in [latitude, longitude].
+            location:,
+            # Body param: Indicates the index at which to insert the step, starting from 0 up
+            # to the total number of steps in the route.
+            position:,
+            # Body param: Specify the step type. It can belong to one of the following: start,
+            # job , pickup, delivery, end. A duration is mandatory when the step type is
+            # either layover or a break.
+            type:,
+            # Body param: Specify the postal address for the step.
+            address: nil,
+            # Body param: Specify the mode of completion to be used for the step. Currently,
+            # following values are allowed:
+            #
+            # - manual: Steps must be marked as completed manually through the Driver App.
+            # - geofence: Steps are marked as completed automatically based on the entry
+            #   conditions and geofence specified.
+            # - geofence_manual_fallback: Steps will be marked as completed automatically
+            #   based on geofence and entry condition configurations but there will also be a
+            #   provision for manually updating the status in case, geofence detection fails.
+            completion_mode: nil,
+            # Body param: Specify the ID of the document template to be used for collecting
+            # proof of completion for the step. If not specified, the document template
+            # specified at the route level will be used for the step. Use the
+            # [Documents API](https://docs.nextbillion.ai/docs/dispatches/documents-api) to
+            # create, read and manage the document templates.
+            #
+            # Please note that the document template ID can not be assigned to following step
+            # types - start, end, break, layover.
+            document_template_id: nil,
+            # Body param: Specify the duration of the layover or break type steps, in seconds.
+            # Please note it is mandatory when step type is either "layover" or "break".
+            duration: nil,
+            # Body param: Specify the configurations of the geofence which will be used to
+            # detect presence of the driver and complete the tasks automatically. Please note
+            # that this attribute is required when completion_mode is either "geofence" or
+            # "geofence_manual_fallback".
+            geofence_config: nil,
+            # Body param: An object to specify any additional details about the task to be
+            # associated with the step in the response. The information provided here will be
+            # available on the Driver's app under step details. This attribute can be used to
+            # provide context about or instructions to the driver for performing the task
+            meta: nil,
+            request_options: {}
+          )
+          end
+
+          # Update a step
+          sig do
+            params(
+              step_id: String,
+              route_id: String,
+              key: String,
+              arrival: Integer,
+              position: Integer,
+              address: String,
+              completion_mode:
+                Nextbillionai::Fleetify::Routes::RouteStepCompletionMode::OrSymbol,
+              document_template_id: String,
+              duration: Integer,
+              geofence_config:
+                Nextbillionai::Fleetify::Routes::RouteStepGeofenceConfig::OrHash,
+              location: T::Array[Float],
+              meta:
+                Nextbillionai::Fleetify::Routes::StepUpdateParams::Meta::OrHash,
+              type:
+                Nextbillionai::Fleetify::Routes::StepUpdateParams::Type::OrSymbol,
+              request_options: Nextbillionai::RequestOptions::OrHash
+            ).returns(
+              Nextbillionai::Models::Fleetify::Routes::StepUpdateResponse
+            )
+          end
+          def update(
+            # Path param: Provide the step ID from a previously dispatched route that you want
+            # to update. Both the steps.id and steps.short_id can be used as a valid input for
+            # this parameter.
+            step_id,
+            # Path param: Provide the ID of a previously dispatched route which needs to be
+            # modified. Both the id and short_id of the route are a valid input.
+            route_id:,
+            # Query param: A key is a unique identifier that is required to authenticate a
+            # request to the API.
+            key:,
+            # Body param: Specify the scheduled arrival time of the driver, as an UNIX
+            # timestamp in seconds, at the step. Please note that:
+            #
+            # - Arrival time for each step should be equal to or greater than the previous
+            #   step.
+            # - Past times can not be provided.
+            # - The time provided is used only for informative display on the driver app and
+            #   it does not impact or get affected by the route generated.
+            arrival:,
+            # Body param: Specify the new position of the step. Provide a position different
+            # from the current position of the step to update sequence in which the step get
+            # completed.
+            position:,
+            # Body param: Specify the postal address for the step.
+            address: nil,
+            # Body param: Specify the mode of completion to be used for the step. Currently,
+            # following values are allowed:
+            #
+            # - manual: Steps must be marked as completed manually through the Driver App.
+            # - geofence: Steps are marked as completed automatically based on the entry
+            #   conditions and geofence specified.
+            # - geofence_manual_fallback: Steps will be marked as completed automatically
+            #   based on geofence and entry condition configurations but there will also be a
+            #   provision for manually updating the status in case, geofence detection fails.
+            completion_mode: nil,
+            # Body param: Update the ID of the document template to be used for collecting
+            # proof of completion for the step. If an empty string "" is provided, the current
+            # document template associated to the step will be removed.
+            document_template_id: nil,
+            # Body param: Specify the duration of the layover or break type steps, in seconds.
+            # Please note it is mandatory when step type is either "layover" or "break".
+            duration: nil,
+            # Body param: Specify the configurations of the geofence which will be used to
+            # detect presence of the driver and complete the tasks automatically. Please note
+            # that this attribute is required when completion_mode is either "geofence" or
+            # "geofence_manual_fallback".
+            geofence_config: nil,
+            # Body param: Specify the location coordinates where the steps should be performed
+            # in [latitude, longitude].
+            location: nil,
+            # Body param: An object to specify any additional details about the task to be
+            # associated with the step in the response. The information provided here will be
+            # available on the Driver's app under step details. This attribute can be used to
+            # provide context about or instructions to the driver for performing the task
+            meta: nil,
+            # Body param: Specify the step type. It can belong to one of the following: start,
+            # job , pickup, delivery, end. A duration is mandatory when the step type is
+            # either layover or a break.
+            type: nil,
+            request_options: {}
+          )
+          end
+
+          # Delete a step
+          sig do
+            params(
+              step_id: String,
+              route_id: String,
+              key: String,
+              request_options: Nextbillionai::RequestOptions::OrHash
+            ).returns(
+              Nextbillionai::Models::Fleetify::Routes::StepDeleteResponse
+            )
+          end
+          def delete(
+            # Path param: Provide the step ID from a previously dispatched route that you want
+            # to update. Both the steps.id and steps.short_id can be used as a valid input for
+            # this parameter.
+            step_id,
+            # Path param: Provide the ID of a previously dispatched route which needs to be
+            # modified. Both the id and short_id of the route are a valid input.
+            route_id:,
+            # Query param: A key is a unique identifier that is required to authenticate a
+            # request to the API.
+            key:,
+            request_options: {}
+          )
+          end
+
+          # Complete a route step with document submission, or update the document of a
+          # completed route step.
+          #
+          # When all steps are completed, the encapsulating route’s status will change to
+          # completed automatically.
+          #
+          # Either Session Token must be provided to authenticate the request.
+          sig do
+            params(
+              step_id: String,
+              route_id: String,
+              key: String,
+              document: T.anything,
+              mode: String,
+              status: String,
+              request_options: Nextbillionai::RequestOptions::OrHash
+            ).void
+          end
+          def complete(
+            # Path param: Provide the step ID from a previously dispatched route that you want
+            # to update. Both the steps.id and steps.short_id can be used as a valid input for
+            # this parameter.
+            step_id,
+            # Path param: Provide the ID of a previously dispatched route which needs to be
+            # modified. Both the id and short_id of the route are a valid input.
+            route_id:,
+            # Query param: A key is a unique identifier that is required to authenticate a
+            # request to the API.
+            key:,
+            # Body param: A key-value map storing form submission data, where keys correspond
+            # to field labels and values can be of any type depend on the type of according
+            # document item.
+            document: nil,
+            # Body param: Sets the status of the route step. Currently only completed is
+            # supported.
+            #
+            # Note: once marked completed, a step cannot transition to other statuses. You can
+            # only update the document afterwards.
+            mode: nil,
+            # Body param: Sets the status of the route step. Currently only completed is
+            # supported.
+            #
+            # Note: once marked completed, a step cannot transition to other statuses. You can
+            # only update the document afterwards.
+            status: nil,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig do
+            params(client: Nextbillionai::Client).returns(T.attached_class)
+          end
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end