nextbillionai 0.1.0.pre.alpha.4

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

@@ -0,0 +1,114 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Fleetify
+      class Routes
+        sig { returns(Nextbillionai::Resources::Fleetify::Routes::Steps) }
+        attr_reader :steps
+
+        # Dispatch a new route
+        sig do
+          params(
+            key: String,
+            driver_email: String,
+            steps:
+              T::Array[
+                Nextbillionai::Fleetify::Routes::RouteStepsRequest::OrHash
+              ],
+            distance: Integer,
+            document_template_id: String,
+            ro_request_id: String,
+            routing:
+              Nextbillionai::Fleetify::RouteCreateParams::Routing::OrHash,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Models::Fleetify::RouteCreateResponse)
+        end
+        def create(
+          # Query param: A key is a unique identifier that is required to authenticate a
+          # request to the API.
+          key:,
+          # Body param: Specify the e-mail address of the driver who should receive the
+          # route. The e-mail address must be registered in
+          # [NextBillion.ai Cloud Console](https://console.nextbillion.ai/).
+          driver_email:,
+          # Body param: An array of objects to collect the details about the intermediate
+          # steps in the route to be dispatched. Each object corresponds to a single step.
+          # The array must begin with a start-type step and end with an end-type step, to
+          # form a valid route.
+          steps:,
+          # Body param: Specify the total distance, in meters, for an informative display in
+          # Driver's app. The distance specified here has no effect on the actual route that
+          # the service generates.
+          distance: nil,
+          # Body param: Specify the ID of the document template that should be used to
+          # collect proof of completion for all steps in the route. In order to complete
+          # each route step, the driver will need to submit a form generated by the rules
+          # defined in the given document template. Use the
+          # [Documents API](https://docs.nextbillion.ai/docs/dispatches/documents-api) to
+          # create, read and manage document templates.
+          #
+          # Please note that the document template ID assigned to a route does not apply to
+          # following step types - start, end, break, layover.
+          document_template_id: nil,
+          # Body param: Specify the Route Optimization request ID. When this ID is provided,
+          # all other fields will be ignored (including the required fields) and the route
+          # optimization result will be used to form the routes and corresponding steps.
+          #
+          # Please note that:
+          #
+          # - The driver's email ID must be provided in input vehicle.metadata as user_email
+          #   such that the route optimization result must contain a valid driver email,
+          #   step's arrival time, etc., to make a successful dispatch.
+          # - Document Template for collecting proof of delivery or completion can not be
+          #   specified when using this field to dispatch a route.
+          # - In case of an error at any part among the routes, the API will immediately
+          #   return the error with the index of the specific route or route step.
+          # - On a successful dispatch, the API returns the last route, if there are many,
+          #   in the response payload.
+          ro_request_id: nil,
+          # Body param: The routing object allows defining the routing characteristics that
+          # should be used to generate a route when the Driver uses the in-app navigation.
+          # Only car mode is supported currently.
+          routing: nil,
+          request_options: {}
+        )
+        end
+
+        # Re-dispatch route
+        sig do
+          params(
+            route_id: String,
+            key: String,
+            operations:
+              T::Array[
+                Nextbillionai::Fleetify::RouteRedispatchParams::Operation::OrHash
+              ],
+            distance: Float,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Models::Fleetify::RouteRedispatchResponse)
+        end
+        def redispatch(
+          # 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 collection of objects with details of the steps to be modified.
+          # Each object corresponds to a single step.
+          operations:,
+          # Body param: Specify the distance of the route.
+          distance: 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/fleetify.rbi

@@ -0,0 +1,18 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Fleetify
+      sig { returns(Nextbillionai::Resources::Fleetify::Routes) }
+      attr_reader :routes
+
+      sig { returns(Nextbillionai::Resources::Fleetify::DocumentTemplates) }
+      attr_reader :document_templates
+
+      # @api private
+      sig { params(client: Nextbillionai::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/nextbillionai/resources/geocode.rbi

@@ -0,0 +1,164 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Geocode
+      # Geocode
+      sig do
+        params(
+          key: String,
+          q: String,
+          at: String,
+          in_: String,
+          lang: String,
+          limit: Integer,
+          request_options: Nextbillionai::RequestOptions::OrHash
+        ).returns(Nextbillionai::Models::GeocodeRetrieveResponse)
+      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
+
+      # Batch Geocode
+      sig do
+        params(
+          key: String,
+          body: T::Array[Nextbillionai::GeocodeBatchCreateParams::Body::OrHash],
+          request_options: Nextbillionai::RequestOptions::OrHash
+        ).returns(Nextbillionai::Models::GeocodeBatchCreateResponse)
+      end
+      def batch_create(
+        # Query param: A key is a unique identifier that is required to authenticate a
+        # request to the API.
+        key:,
+        # Body param:
+        body:,
+        request_options: {}
+      )
+      end
+
+      # Structured Geocode
+      sig do
+        params(
+          country_code: String,
+          key: String,
+          at: String,
+          city: String,
+          county: String,
+          house_number: String,
+          in_: String,
+          limit: Integer,
+          postal_code: String,
+          state: String,
+          street: String,
+          request_options: Nextbillionai::RequestOptions::OrHash
+        ).returns(Nextbillionai::Models::GeocodeStructuredRetrieveResponse)
+      end
+      def structured_retrieve(
+        # Specify a valid
+        # [ISO 3166-1 alpha-3](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-3) country
+        # code in which the place being searched should be located. Please note that this
+        # is a case-sensitive field and the country code should be in all uppercase.
+        country_code:,
+        # A key is a unique identifier that is required to authenticate a request to the
+        # API.
+        key:,
+        # 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,
+        # Specify the city in which the place being searched should be located.
+        city: nil,
+        # Specify the county division of the state in which the place being searched
+        # should be located.
+        county: nil,
+        # Specify the house number of the place being searched.
+        house_number: 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 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,
+        # Sets the maximum number of results to be returned.
+        limit: nil,
+        # Specify the postal code in which the place being searched should be located.
+        postal_code: nil,
+        # Specify the state division of the country in which the place being searched
+        # should be located.
+        state: nil,
+        # Specify the name of the street in which the place being searched should be
+        # located.
+        street: 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/geofence/batch.rbi

@@ -0,0 +1,70 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Geofence
+      class Batch
+        # Batch Creation of Geofence
+        sig do
+          params(
+            key: String,
+            geofences: T::Array[Nextbillionai::GeofenceEntityCreate::OrHash],
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Models::Geofence::BatchCreateResponse)
+        end
+        def create(
+          # Query param: A key is a unique identifier that is required to authenticate a
+          # request to the API.
+          key:,
+          # Body param: An array of objects to collect the details of the multiple geofences
+          # that need to be created.
+          geofences: nil,
+          request_options: {}
+        )
+        end
+
+        # Batch Query of Geofence
+        sig do
+          params(
+            ids: String,
+            key: String,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Models::Geofence::BatchListResponse)
+        end
+        def list(
+          # Comma(,) separated list of IDs of the geofences to be searched.
+          ids:,
+          # A key is a unique identifier that is required to authenticate a request to the
+          # API.
+          key:,
+          request_options: {}
+        )
+        end
+
+        # Delete Batch Geofence
+        sig do
+          params(
+            key: String,
+            ids: T::Array[String],
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Skynet::SimpleResp)
+        end
+        def delete(
+          # Query param: A key is a unique identifier that is required to authenticate a
+          # request to the API.
+          key:,
+          # Body param: An array IDs of the geofence to be deleted. These are the IDs that
+          # were generated/provided at the time of creating the respective geofences.
+          ids: 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/geofence/console.rbi

@@ -0,0 +1,89 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Geofence
+      class Console
+        # preview geofence geojson
+        sig do
+          params(
+            type: Nextbillionai::GeofenceEntityCreate::Type::OrSymbol,
+            circle: Nextbillionai::GeofenceEntityCreate::Circle::OrHash,
+            custom_id: String,
+            isochrone: Nextbillionai::GeofenceEntityCreate::Isochrone::OrHash,
+            meta_data: T.anything,
+            name: String,
+            polygon: Nextbillionai::GeofenceEntityCreate::Polygon::OrHash,
+            tags: T::Array[String],
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Models::Geofence::ConsolePreviewResponse)
+        end
+        def preview(
+          # Specify the type of the geofence that is being created.
+          type:,
+          # Provide the details to create a circular geofence. Please note that this object
+          # is mandatory when type is circle. When the type is not circle, the properties of
+          # this object will be ignored while creating the geofence.
+          circle: nil,
+          # Set an unique ID for the new geofence. 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 geofence can not be changed once it is created.
+          custom_id: nil,
+          # Provide the details to create an isochrone based geofence. Use this object when
+          # type is isochrone. When the type is not isochrone, the properties of this object
+          # will be ignored while creating the geofence.
+          isochrone: nil,
+          # Metadata of the geofence. Use this field to define custom attributes that
+          # provide more context and information about the geofence being created like
+          # country, group ID etc.
+          #
+          # The data being added should be in valid JSON object format (i.e. key and value
+          # pairs). Max size allowed for the object is 65kb.
+          meta_data: nil,
+          # Name of the geofence. Use this field to assign a meaningful, custom name to the
+          # geofence being created.
+          name: nil,
+          # Provide the details to create a custom polygon type of geofence. Please note
+          # that this object is mandatory when type is polygon. When the type is not
+          # polygon, the properties of this object will be ignored while creating the
+          # geofence.
+          #
+          # Self-intersecting polygons or polygons containing other polygons are invalid and
+          # will be removed while processing the request.
+          #
+          # Area of the polygon should be less than 2000 km<sup>2</sup>.
+          polygon: nil,
+          # An array of strings to associate multiple tags to the geofence. tags can be used
+          # to search or filter geofences (using Get Geofence List method).
+          #
+          # Create valid tags using a string consisting of alphanumeric characters (A-Z,
+          # a-z, 0-9) along with the underscore ('\_') and hyphen ('-') symbols.
+          tags: nil,
+          request_options: {}
+        )
+        end
+
+        # Console Geofence Search API
+        sig do
+          params(
+            query: String,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Models::Geofence::ConsoleSearchResponse)
+        end
+        def search(
+          # string to be searched, will used to match name or id of geofence.
+          query:,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Nextbillionai::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end