nextbillionai 0.1.0.pre.alpha.4

data/rbi/nextbillionai/resources/skynet/search.rbi

@@ -0,0 +1,191 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Skynet
+      class Search
+        sig { returns(Nextbillionai::Resources::Skynet::Search::Polygon) }
+        attr_reader :polygon
+
+        # Around Search
+        sig do
+          params(
+            center: String,
+            key: String,
+            radius: Float,
+            filter: String,
+            include_all_of_attributes: String,
+            include_any_of_attributes: String,
+            max_search_limit: T::Boolean,
+            pn: Integer,
+            ps: Integer,
+            sort_by:
+              Nextbillionai::Skynet::SearchAroundParams::SortBy::OrSymbol,
+            sort_destination: String,
+            sort_driving_mode:
+              Nextbillionai::Skynet::SearchAroundParams::SortDrivingMode::OrSymbol,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Skynet::SearchResponse)
+        end
+        def around(
+          # Location coordinates of the point which would act as the center of the circular
+          # area to be searched.
+          center:,
+          # A key is a unique identifier that is required to authenticate a request to the
+          # API.
+          key:,
+          # Radius, in meters, of the circular area to be searched.
+          radius:,
+          # **tags parameter will be deprecated soon! Please use the
+          # include_any_of_attributes or include_all_of_attributes parameters to match
+          # assets based on their labels or markers.**
+          #
+          # Use this parameter to filter the assets found inside the specified area by their
+          # tags. Multiple tags can be separated using commas (,).
+          #
+          # Please note the tags are case sensitive.
+          filter: nil,
+          # Use this parameter to filter the assets found inside the specified area by their
+          # attributes. Only the assets having all the attributes that are added to this
+          # parameter, will be returned in the search results. Multiple attributes can be
+          # separated using pipes (|).
+          #
+          # Please note the attributes are case sensitive. Also, this parameter can not be
+          # used in conjunction with include_any_of_attributes parameter.
+          include_all_of_attributes: nil,
+          # Use this parameter to filter the assets found inside the specified area by their
+          # attributes. Assets having at least one of the attributes added to this
+          # parameter, will be returned in the search results. Multiple attributes can be
+          # separated using pipes (|).
+          #
+          # Please note the attributes are case sensitive. Also, this parameter can not be
+          # used in conjunction with include_all_of_attributes parameter.
+          include_any_of_attributes: nil,
+          # When true, the maximum limit is 20Km for around search API and 48000 Km2 for
+          # other search methods.
+          max_search_limit: nil,
+          # Denotes page number. Use this along with the ps parameter to implement
+          # pagination for your searched results. This parameter does not have a maximum
+          # limit but would return an empty response in case a higher value is provided when
+          # the result-set itself is smaller.
+          pn: nil,
+          # Denotes number of search results per page. Use this along with the pn parameter
+          # to implement pagination for your searched results.
+          ps: nil,
+          # Specify the metric to sort the assets returned in the search result. The valid
+          # values are:
+          #
+          # - **distance** : Sorts the assets by driving distance to the given
+          #   sort_destination .
+          # - **duration** : Sorts the assets by travel time to the given sort_destination .
+          # - **straight_distance** : Sort the assets by straight-line distance to the given
+          #   sort-destination .
+          sort_by: nil,
+          # Specifies the location coordinates of the point which acts as destination for
+          # sorting the assets in the search results. The service will sort each asset based
+          # on the driving distance or travel time to this destination, from its current
+          # location. Use the sort_by parameter to configure the metric that should be used
+          # for sorting the assets. Please note that sort_destination is required when
+          # sort_by is provided.
+          sort_destination: nil,
+          # Specifies the driving mode to be used for determining travel duration or driving
+          # distance for sorting the assets in search result.
+          sort_driving_mode: nil,
+          request_options: {}
+        )
+        end
+
+        # Bound Search
+        sig do
+          params(
+            bound: String,
+            key: String,
+            filter: String,
+            include_all_of_attributes: String,
+            include_any_of_attributes: String,
+            max_search_limit: T::Boolean,
+            pn: Integer,
+            ps: Integer,
+            sort_by: Nextbillionai::Skynet::SearchBoundParams::SortBy::OrSymbol,
+            sort_destination: String,
+            sort_driving_mode:
+              Nextbillionai::Skynet::SearchBoundParams::SortDrivingMode::OrSymbol,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Skynet::SearchResponse)
+        end
+        def bound(
+          # Specify two, pipe (|) delimited location coordinates which would act as corners
+          # of the bounding box area to be searched. The first one should be the southwest
+          # coordinate of the bounds and the second one should be the northeast coordinate
+          # of the bounds.
+          bound:,
+          # A key is a unique identifier that is required to authenticate a request to the
+          # API.
+          key:,
+          # **tags parameter will be deprecated soon! Please use the
+          # include_any_of_attributes or include_all_of_attributes parameters to match
+          # assets based on their labels or markers.**
+          #
+          # Use this parameter to filter the assets found inside the specified area by their
+          # tags. Multiple tags can be separated using commas (,).
+          #
+          # Please note the tags are case sensitive.
+          filter: nil,
+          # Use this parameter to filter the assets found inside the specified area by their
+          # attributes. Only the assets having all the attributes that are added to this
+          # parameter, will be returned in the search results. Multiple attributes can be
+          # separated using pipes (|).
+          #
+          # Please note the attributes are case sensitive. Also, this parameter can not be
+          # used in conjunction with include_any_of_attributes parameter.
+          include_all_of_attributes: nil,
+          # Use this parameter to filter the assets found inside the specified area by their
+          # attributes. Assets having at least one of the attributes added to this
+          # parameter, will be returned in the search results. Multiple attributes can be
+          # separated using pipes (|).
+          #
+          # Please note the attributes are case sensitive. Also, this parameter can not be
+          # used in conjunction with include_all_of_attributes parameter.
+          include_any_of_attributes: nil,
+          # When true, the maximum limit is 20Km for around search API and 48000 Km2 for
+          # other search methods.
+          max_search_limit: nil,
+          # Denotes page number. Use this along with the ps parameter to implement
+          # pagination for your searched results. This parameter does not have a maximum
+          # limit but would return an empty response in case a higher value is provided when
+          # the result-set itself is smaller.
+          pn: nil,
+          # Denotes number of search results per page. Use this along with the pn parameter
+          # to implement pagination for your searched results.
+          ps: nil,
+          # Specify the metric to sort the assets returned in the search result. The valid
+          # values are:
+          #
+          # - **distance** : Sorts the assets by driving distance to the given
+          #   sort_destination .
+          # - **duration** : Sorts the assets by travel time to the given sort_destination .
+          # - **straight_distance** : Sort the assets by straight-line distance to the given
+          #   sort-destination .
+          sort_by: nil,
+          # Specifies the location coordinates of the point which acts as destination for
+          # sorting the assets in the search results. The service will sort each asset based
+          # on the driving distance or travel time to this destination, from its current
+          # location. Use the sort_by parameter to configure the metric that should be used
+          # for sorting the assets. Please note that sort_destination is required when
+          # sort_by is provided.
+          sort_destination: nil,
+          # Specifies the driving mode to be used for determining travel duration or driving
+          # distance for sorting the assets in search result.
+          sort_driving_mode: 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/skynet/trip.rbi

@@ -0,0 +1,210 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Skynet
+      class Trip
+        # Retrieves detailed information about a specific trip.
+        sig do
+          params(
+            id: String,
+            key: String,
+            cluster:
+              Nextbillionai::Skynet::TripRetrieveParams::Cluster::OrSymbol,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Models::Skynet::TripRetrieveResponse)
+        end
+        def retrieve(
+          # Specify the ID of trip that is to be retrieved.
+          id,
+          # A key is a unique identifier that is required to authenticate a request to the
+          # API.
+          key:,
+          # the cluster of the region you want to use
+          cluster: nil,
+          request_options: {}
+        )
+        end
+
+        # Updates the data of a specified trip with the provided data.
+        sig do
+          params(
+            id: String,
+            key: String,
+            asset_id: String,
+            cluster: Nextbillionai::Skynet::TripUpdateParams::Cluster::OrSymbol,
+            attributes: T.anything,
+            description: String,
+            meta_data: T.anything,
+            name: String,
+            stops:
+              T::Array[Nextbillionai::Skynet::TripUpdateParams::Stop::OrHash],
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Skynet::SimpleResp)
+        end
+        def update(
+          # Path param: Specify the ID of the trip to be updated. Please note that a trip
+          # which has ended can not be updated.
+          id,
+          # Query param: A key is a unique identifier that is required to authenticate a
+          # request to the API.
+          key:,
+          # Body param: Use this param to update the ID of the asset which made this trip.
+          # Please be cautious when using this field as providing an ID other than what was
+          # provided at the time of starting the trip, will link a new asset to the trip and
+          # un-link the original asset, even if the trip is still active.
+          asset_id:,
+          # Query param: the cluster of the region you want to use
+          cluster: nil,
+          # Body param: Use this field to update the attributes of the trip. Please note
+          # that when updating the attributes field, previously added information will be
+          # overwritten.
+          attributes: nil,
+          # Body param: Use this parameter to update the custom description of the trip.
+          description: nil,
+          # Body param: Use this JSON object to update additional details about the trip.
+          # This property is used to add any custom information / context about the trip.
+          #
+          # Please note that updating the meta_data field will overwrite the previously
+          # added information.
+          meta_data: nil,
+          # Body param: Use this property to update the name of the trip.
+          name: nil,
+          # Body param: Use this object to update the details of the stops made during the
+          # trip. Each object represents a single stop.
+          #
+          # Please note that when updating this field, the new stops will overwrite any
+          # existing stops configured for the trip.
+          stops: nil,
+          request_options: {}
+        )
+        end
+
+        # Deletes a specified trip from the system.
+        sig do
+          params(
+            id: String,
+            key: String,
+            cluster: Nextbillionai::Skynet::TripDeleteParams::Cluster::OrSymbol,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Skynet::SimpleResp)
+        end
+        def delete(
+          # Specify the ID of the trip to be deleted.
+          id,
+          # A key is a unique identifier that is required to authenticate a request to the
+          # API.
+          key:,
+          # the cluster of the region you want to use
+          cluster: nil,
+          request_options: {}
+        )
+        end
+
+        # End a trip
+        sig do
+          params(
+            key: String,
+            id: String,
+            cluster: Nextbillionai::Skynet::TripEndParams::Cluster::OrSymbol,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Skynet::SimpleResp)
+        end
+        def end_(
+          # Query param: A key is a unique identifier that is required to authenticate a
+          # request to the API.
+          key:,
+          # Body param: Specify the ID of the trip to be ended.
+          id:,
+          # Query param: the cluster of the region you want to use
+          cluster: nil,
+          request_options: {}
+        )
+        end
+
+        # Get summary of an ended trip
+        sig do
+          params(
+            id: String,
+            key: String,
+            cluster:
+              Nextbillionai::Skynet::TripGetSummaryParams::Cluster::OrSymbol,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Models::Skynet::TripGetSummaryResponse)
+        end
+        def get_summary(
+          # Specify the ID of the trip whose summary needs to be generated. Please ensure
+          # the trip is already completed. Trip summary is not available for ongoing trips.
+          id,
+          # A key is a unique identifier that is required to authenticate a request to the
+          # API.
+          key:,
+          # the cluster of the region you want to use
+          cluster: nil,
+          request_options: {}
+        )
+        end
+
+        # Add a new trip to the system with the provided data.
+        sig do
+          params(
+            key: String,
+            asset_id: String,
+            cluster: Nextbillionai::Skynet::TripStartParams::Cluster::OrSymbol,
+            attributes: T.anything,
+            custom_id: String,
+            description: String,
+            meta_data: T.anything,
+            name: String,
+            stops:
+              T::Array[Nextbillionai::Skynet::TripStartParams::Stop::OrHash],
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Models::Skynet::TripStartResponse)
+        end
+        def start(
+          # Query param: A key is a unique identifier that is required to authenticate a
+          # request to the API.
+          key:,
+          # Body param: Specify the ID of the asset which is making this trip. The asset
+          # will be linked to this trip.
+          asset_id:,
+          # Query param: the cluster of the region you want to use
+          cluster: nil,
+          # Body param: attributes can be used to store custom information about a trip in
+          # key:value format. Use attributes to add any useful information or context to
+          # your trips like the driver name, destination etc.
+          #
+          # Please note that the maximum number of key:value pairs that can be added to an
+          # attributes object is 100. Also, the overall size of attributes object should not
+          # exceed 65kb.
+          attributes: nil,
+          # Body param: Set a unique ID for the new trip. If not provided, an ID will be
+          # automatically generated in UUID format. A valid custom_id can contain letters,
+          # numbers, “-”, & “\_” only.
+          #
+          # Please note that the ID of a trip can not be changed once it is created.
+          custom_id: nil,
+          # Body param: Add a custom description for the trip.
+          description: nil,
+          # Body param: An JSON object to collect additional details about the trip. Use
+          # this property to add any custom information / context about the trip. The input
+          # will be passed on to the response as-is and can be used to display useful
+          # information on, for example, a UI app.
+          meta_data: nil,
+          # Body param: Specify a name for the trip.
+          name: nil,
+          # Body param: An array of objects to collect the details about all the stops that
+          # need to be made before the trip ends. Each object represents one stop.
+          stops: 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/skynet.rbi

@@ -0,0 +1,60 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Skynet
+      sig { returns(Nextbillionai::Resources::Skynet::Asset) }
+      attr_reader :asset
+
+      sig { returns(Nextbillionai::Resources::Skynet::Monitor) }
+      attr_reader :monitor
+
+      sig { returns(Nextbillionai::Resources::Skynet::Trip) }
+      attr_reader :trip
+
+      sig { returns(Nextbillionai::Resources::Skynet::NamespacedApikeys) }
+      attr_reader :namespaced_apikeys
+
+      sig { returns(Nextbillionai::Resources::Skynet::Config) }
+      attr_reader :config
+
+      sig { returns(Nextbillionai::Resources::Skynet::Search) }
+      attr_reader :search
+
+      # POST Action
+      sig do
+        params(
+          action: Nextbillionai::SkynetSubscribeParams::Action::OrSymbol,
+          id: String,
+          params: Nextbillionai::SkynetSubscribeParams::Params::OrHash,
+          request_options: Nextbillionai::RequestOptions::OrHash
+        ).returns(Nextbillionai::Models::SkynetSubscribeResponse)
+      end
+      def subscribe(
+        # Specify the behavior that needs to be achieved for the subscription. Following
+        # values are accepted:
+        #
+        # - TRIP_SUBSCRIBE: Enable a trip subscription.
+        # - TRIP_UNSUBSCRIBE: Unsubscribe from a trip
+        # - HEARTBEAT: Enable heartbeat mechanism for a web-socket connection. The action
+        #   message need to be sent at a frequency higher than every 5 mins to keep the
+        #   connection alive. Alternatively, users can chose to respond to the ping frame
+        #   sent by web socket server to keep the connection alive. Refer to
+        #   [connection details](https://188--nbai-docs-stg.netlify.app/docs/tracking/api/live-tracking-api#connect-to-web-socket-server)
+        #   for more details.
+        action:,
+        # Specify a custom ID for the subscription. It can be used to reference a given
+        # subscription in the downstream applications / systems.
+        id: nil,
+        params: 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/snap_to_roads.rbi

@@ -0,0 +1,103 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class SnapToRoads
+      # Nextbillion.ai Snap To Roads API takes a series of locations along a route, and
+      # returns the new locations on this route that are snapped to the best-matched
+      # roads where the trip took place. You can set various parameters, such as
+      # timestamps or radius, to optimize the result.
+      sig do
+        params(
+          key: String,
+          path: String,
+          approaches: Nextbillionai::SnapToRoadSnapParams::Approaches::OrSymbol,
+          avoid: Nextbillionai::SnapToRoadSnapParams::Avoid::OrSymbol,
+          geometry: Nextbillionai::SnapToRoadSnapParams::Geometry::OrSymbol,
+          mode: Nextbillionai::SnapToRoadSnapParams::Mode::OrSymbol,
+          option: Nextbillionai::SnapToRoadSnapParams::Option::OrSymbol,
+          radiuses: String,
+          road_info: Nextbillionai::SnapToRoadSnapParams::RoadInfo::OrSymbol,
+          timestamps: String,
+          tolerate_outlier: T::Boolean,
+          request_options: Nextbillionai::RequestOptions::OrHash
+        ).returns(Nextbillionai::Models::SnapToRoadSnapResponse)
+      end
+      def snap(
+        # A key is a unique identifier that is required to authenticate a request to the
+        # API.
+        key:,
+        # Pipe-separated list of coordinate points along a path which would be snapped to
+        # a road.
+        path:,
+        # A semicolon-separated list indicating the side of the road from which to
+        # approach the locations on the snapped route. When set to "unrestricted" a route
+        # can arrive at the snapped location from either side of the road and when set to
+        # "curb" the route will arrive at the snapped location on the driving side of the
+        # region. Please note the number of values provided must be equal to the number of
+        # coordinate points provided in the "path" parameter. However, you can skip a
+        # coordinate and show its position in the list with the ";" separator.
+        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,
+        # Sets the output format of the route geometry in the response. Only the
+        # "polyline" or "polyline6" encoded "geometry" of the snapped path is returned in
+        # the response depending on the value provided in the input. When "geojson" is
+        # selected as the input value, "polyline6" encoded geometry of the snapped path is
+        # returned along with a "geojson" object.
+        geometry: nil,
+        # Set which driving mode the service should use to determine a route. For example,
+        # if you use "car", the API will return a route that a car can take. Using "truck"
+        # will return a route a truck can use, taking into account appropriate truck
+        # routing restrictions.
+        #
+        # 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,
+        # Include this parameter in the request to return segment-wise speed information
+        # of the route returned in the response.
+        #
+        # Please note that returning speed information is a function of "road_info"
+        # parameter, which is effective only when "option=flexible". However, the
+        # resultant route might not contain all the locations provided in "path" input.
+        option: nil,
+        # Pipe separated radiuses, in meters (m), up to which a coordinate point can be
+        # snapped. Please note, if no valid road is available within the specified radius,
+        # the API would snap the points to nearest, most viable road. When using this
+        # parameter, it is recommended to specify as many radius values as the number of
+        # points in "path" parameter. If the same number of "radiuses" are not provided,
+        # the API will use the default radius value of 25 meters for all locations.
+        radiuses: nil,
+        # Use this parameter to receive segment-wise maximum speed information of the
+        # route in the response. "max_speed" is the only allowed value.
+        road_info: nil,
+        # Pipe-separated UNIX epoch timestamp in seconds for each location. If used, the
+        # number of timestamps must be equal to the number of coordinate points in the
+        # "path" parameter. The "timestamps" must increase monotonically starting from the
+        # first timestamp. This means that each subsequent timestamp should either be more
+        # than or equal to the preceding one.
+        timestamps: nil,
+        # Enable it to ignore locations outside the service boundary. When "true", the
+        # service would ignore "path" coordinates points falling outside the accessible
+        # area, which otherwise would cause an error when this parameter is "false".
+        tolerate_outlier: 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/version.rbi

@@ -0,0 +1,5 @@
+# typed: strong
+
+module Nextbillionai
+  VERSION = T.let(T.unsafe(nil), String)
+end

data/sig/nextbillionai/client.rbs

@@ -0,0 +1,74 @@
+module Nextbillionai
+  class Client < Nextbillionai::Internal::Transport::BaseClient
+    DEFAULT_MAX_RETRIES: 2
+
+    DEFAULT_TIMEOUT_IN_SECONDS: Float
+
+    DEFAULT_INITIAL_RETRY_DELAY: Float
+
+    DEFAULT_MAX_RETRY_DELAY: Float
+
+    attr_reader api_key: String
+
+    attr_reader fleetify: Nextbillionai::Resources::Fleetify
+
+    attr_reader skynet: Nextbillionai::Resources::Skynet
+
+    attr_reader geocode: Nextbillionai::Resources::Geocode
+
+    attr_reader optimization: Nextbillionai::Resources::Optimization
+
+    attr_reader geofence: Nextbillionai::Resources::Geofence
+
+    attr_reader discover: Nextbillionai::Resources::Discover
+
+    attr_reader browse: Nextbillionai::Resources::Browse
+
+    attr_reader mdm: Nextbillionai::Resources::Mdm
+
+    attr_reader isochrone: Nextbillionai::Resources::Isochrone
+
+    attr_reader restrictions: Nextbillionai::Resources::Restrictions
+
+    attr_reader restrictions_items: Nextbillionai::Resources::RestrictionsItems
+
+    attr_reader distance_matrix: Nextbillionai::Resources::DistanceMatrix
+
+    attr_reader autocomplete: Nextbillionai::Resources::Autocomplete
+
+    attr_reader navigation: Nextbillionai::Resources::Navigation
+
+    attr_reader map: Nextbillionai::Resources::Map
+
+    attr_reader autosuggest: Nextbillionai::Resources::Autosuggest
+
+    attr_reader directions: Nextbillionai::Resources::Directions
+
+    attr_reader batch: Nextbillionai::Resources::Batch
+
+    attr_reader multigeocode: Nextbillionai::Resources::Multigeocode
+
+    attr_reader revgeocode: Nextbillionai::Resources::Revgeocode
+
+    attr_reader route_report: Nextbillionai::Resources::RouteReport
+
+    attr_reader snap_to_roads: Nextbillionai::Resources::SnapToRoads
+
+    attr_reader postalcode: Nextbillionai::Resources::Postalcode
+
+    attr_reader lookup: Nextbillionai::Resources::Lookup
+
+    attr_reader areas: Nextbillionai::Resources::Areas
+
+    private def auth_query: -> ::Hash[String, String]
+
+    def initialize: (
+      ?api_key: String?,
+      ?base_url: String?,
+      ?max_retries: Integer,
+      ?timeout: Float,
+      ?initial_retry_delay: Float,
+      ?max_retry_delay: Float
+    ) -> void
+  end
+end