nextbillionai 0.1.0.pre.alpha.4

data/rbi/nextbillionai/resources/geofence.rbi

@@ -0,0 +1,249 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Geofence
+      sig { returns(Nextbillionai::Resources::Geofence::Console) }
+      attr_reader :console
+
+      sig { returns(Nextbillionai::Resources::Geofence::Batch) }
+      attr_reader :batch
+
+      # Create a geofence
+      sig do
+        params(
+          key: String,
+          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::GeofenceCreateResponse)
+      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 type of the geofence that is being created.
+        type:,
+        # Body param: 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,
+        # Body param: 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,
+        # Body param: 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,
+        # Body param: 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,
+        # Body param: Name of the geofence. Use this field to assign a meaningful, custom
+        # name to the geofence being created.
+        name: nil,
+        # Body param: 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,
+        # Body param: 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
+
+      # Get a Geofence
+      sig do
+        params(
+          id: String,
+          key: String,
+          request_options: Nextbillionai::RequestOptions::OrHash
+        ).returns(Nextbillionai::Models::GeofenceRetrieveResponse)
+      end
+      def retrieve(
+        # ID of the geofence to be fetched. This is the ID that was generated/provided at
+        # the time of creating the geofence.
+        id,
+        # A key is a unique identifier that is required to authenticate a request to the
+        # API.
+        key:,
+        request_options: {}
+      )
+      end
+
+      # Update a Geofence
+      sig do
+        params(
+          id: String,
+          key: String,
+          circle: Nextbillionai::GeofenceUpdateParams::Circle::OrHash,
+          isochrone: Nextbillionai::GeofenceUpdateParams::Isochrone::OrHash,
+          meta_data: T.anything,
+          name: String,
+          polygon: Nextbillionai::GeofenceUpdateParams::Polygon::OrHash,
+          tags: T::Array[String],
+          type: Nextbillionai::GeofenceUpdateParams::Type::OrSymbol,
+          request_options: Nextbillionai::RequestOptions::OrHash
+        ).returns(Nextbillionai::Skynet::SimpleResp)
+      end
+      def update(
+        # Path param: ID of the geofence to be updated. This is the ID that was
+        # generated/provided at the time of creating the geofence.
+        id,
+        # Query param: A key is a unique identifier that is required to authenticate a
+        # request to the API.
+        key:,
+        # Body param: Use this object to update details of a circular geofence. Please
+        # note that this object is mandatory only when type is circle. When the type is
+        # not circle, the properties of this object will be ignored while creating the
+        # geofence.
+        circle: nil,
+        # Body param: Use this object to update details of an isochrone based geofence.
+        # Please note that this object is mandatory only when type is isochrone. When the
+        # type is not isochrone, the properties of this object will be ignored while
+        # creating the geofence.
+        isochrone: nil,
+        # Body param: Updated the meta_data associated with a geofence. Use this field to
+        # define custom attributes that provide more context and information about the
+        # geofence being updated 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,
+        # Body param: Use this parameter to update the name of a geofence. Users can
+        # assign meaningful custom names to their geofences.
+        name: nil,
+        # Body param: Use this object to update details of a custom polygon geofence.
+        # Please note that this object is mandatory only 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,
+        # Body param: Use this parameter to add/modify one or multiple tags of a geofence.
+        # tags can be used to search or filter geofences (using Get Geofence List method).
+        #
+        # Valid values for updating tags consist of alphanumeric characters (A-Z, a-z,
+        # 0-9) along with the underscore ('\_') and hyphen ('-') symbols.
+        tags: nil,
+        # Body param: Use this parameter to update the type of a geofence. Please note
+        # that you will need to provide required details for creating a geofence of the
+        # new type. Check other parameters of this method to know more.
+        type: nil,
+        request_options: {}
+      )
+      end
+
+      # Get Geofence List
+      sig do
+        params(
+          key: String,
+          pn: Integer,
+          ps: Integer,
+          tags: String,
+          request_options: Nextbillionai::RequestOptions::OrHash
+        ).returns(Nextbillionai::Models::GeofenceListResponse)
+      end
+      def list(
+        # A key is a unique identifier that is required to authenticate a request to the
+        # API.
+        key:,
+        # 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,
+        # Comma (,) separated list of tags which will be used to filter the geofences.
+        #
+        # Please note only the geofences which have all the tags added to this parameter
+        # will be included in the result. This parameter can accept a string with a
+        # maximum length of 256 characters.
+        tags: nil,
+        request_options: {}
+      )
+      end
+
+      # Delete a Geofence
+      sig do
+        params(
+          id: String,
+          key: String,
+          request_options: Nextbillionai::RequestOptions::OrHash
+        ).returns(Nextbillionai::Skynet::SimpleResp)
+      end
+      def delete(
+        # ID of the geofence to be deleted. This is the ID that was generated/provided at
+        # the time of creating the geofence.
+        id,
+        # A key is a unique identifier that is required to authenticate a request to the
+        # API.
+        key:,
+        request_options: {}
+      )
+      end
+
+      # Geofence Contains
+      sig do
+        params(
+          key: String,
+          locations: String,
+          geofences: String,
+          verbose: String,
+          request_options: Nextbillionai::RequestOptions::OrHash
+        ).returns(Nextbillionai::Models::GeofenceContainsResponse)
+      end
+      def contains(
+        # A key is a unique identifier that is required to authenticate a request to the
+        # API.
+        key:,
+        # Pipe (|) separated coordinates, in [latitude,longitude] format, of the locations
+        # to be searched against the geofences.
+        locations:,
+        # A , separated list geofence IDs against which the locations will be searched. If
+        # not provided, then the 'locations' will be searched against all your existing
+        # geofences.
+        #
+        # Maximum length of the string can be 256 characters.
+        geofences: nil,
+        # When true, an array with detailed information of geofences is returned. When
+        # false, an array containing only the IDs of the geofences is returned.
+        verbose: 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/isochrone.rbi

@@ -0,0 +1,89 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Isochrone
+      # The NextBillion.ai Isochrone API computes areas that are reachable within a
+      # specified amount of time from a location, and returns the reachable regions as
+      # contours of polygons or lines that you can display on a map.
+      sig do
+        params(
+          contours_meters: Integer,
+          contours_minutes: Integer,
+          coordinates: String,
+          key: String,
+          contours_colors: String,
+          denoise: Float,
+          departure_time: Integer,
+          generalize: Float,
+          mode: Nextbillionai::IsochroneComputeParams::Mode::OrSymbol,
+          polygons: T::Boolean,
+          request_options: Nextbillionai::RequestOptions::OrHash
+        ).returns(Nextbillionai::Models::IsochroneComputeResponse)
+      end
+      def compute(
+        # The distances, in meters, to use for each isochrone contour. You can specify up
+        # to four contours. Distances must be in increasing order. The maximum distance
+        # that can be specified is 60000 meters (60 km).
+        contours_meters:,
+        # The times, in minutes, to use for each isochrone contour. You can specify up to
+        # four contours. Times must be in increasing order. The maximum time that can be
+        # specified is 40 minutes.
+        contours_minutes:,
+        # The coordinates of the location which acts as the starting point for which the
+        # isochrone lines need to be determined.
+        coordinates:,
+        # A key is a unique identifier that is required to authenticate a request to the
+        # API.
+        key:,
+        # The hex code of the color to fill isochrone contour. When requesting multiple
+        # contours, it is recommended to provide color codes for each of the requested
+        # contours, separated by a ",". If no colors are specified, the Isochrone API will
+        # assign a random color scheme to the output.
+        contours_colors: nil,
+        # A floating point value from 0.0 to 1.0 can be used to remove smaller contours.
+        # The default is 1.0. A value of 1.0 will only return the largest contour for a
+        # given value. A value of 0.5 drops any contours that are less than half the area
+        # of the largest contour in the set of contours for that same value.
+        denoise: nil,
+        # Use this parameter to set a departure time, expressed as UNIX epoch timestamp in
+        # seconds, for calculating the isochrone contour. The response will consider the
+        # typical traffic conditions at the given time and return a contour which can be
+        # reached under those traffic conditions. Please note that if no input is provided
+        # for this parameter then the traffic conditions at the time of making the request
+        # are considered.
+        departure_time: nil,
+        # A positive floating point value, in meters, used as the tolerance for
+        # Douglas-Peucker generalization. There is no upper bound. If no value is
+        # specified in the request, the Isochrone API will choose the most optimized
+        # generalization to use for the request. Note that the generalization of contours
+        # can lead to self-intersections, as well as intersections of adjacent contours.
+        generalize: nil,
+        # Set which driving mode the service should use to determine the contour. For
+        # example, if you use "car", the API will return an isochrone contour that a car
+        # can reach within the specified time or after driving the specified distance.
+        # Using "truck" will return a contour that a truck can reach after 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,
+        # Specify whether to return the contours as GeoJSON polygons (true) or linestrings
+        # (false, default). When polygons=true, any contour that forms a ring is returned
+        # as a polygon.
+        polygons: 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/lookup.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Lookup
+      # Lookup By ID
+      sig do
+        params(
+          id: String,
+          key: String,
+          request_options: Nextbillionai::RequestOptions::OrHash
+        ).returns(Nextbillionai::Models::LookupByIDResponse)
+      end
+      def by_id(
+        # Specify the unique identifier of a specific POI, Street, Geography, Point
+        # Address or other entities to retrieve its details.
+        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

data/rbi/nextbillionai/resources/map.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Map
+      # Road Segments
+      sig do
+        params(request_options: Nextbillionai::RequestOptions::OrHash).void
+      end
+      def create_segment(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/mdm.rbi

@@ -0,0 +1,182 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Mdm
+      # Create a massive distance matrix task
+      sig do
+        params(
+          key: String,
+          option:
+            Nextbillionai::MdmCreateDistanceMatrixParams::Option::OrSymbol,
+          origins: String,
+          spliter:
+            Nextbillionai::MdmCreateDistanceMatrixParams::Spliter::OrSymbol,
+          area: Nextbillionai::MdmCreateDistanceMatrixParams::Area::OrSymbol,
+          avoid: Nextbillionai::MdmCreateDistanceMatrixParams::Avoid::OrSymbol,
+          cross_border: T::Boolean,
+          departure_time: Integer,
+          destinations: String,
+          destinations_approach:
+            Nextbillionai::MdmCreateDistanceMatrixParams::DestinationsApproach::OrSymbol,
+          hazmat_type:
+            Nextbillionai::MdmCreateDistanceMatrixParams::HazmatType::OrSymbol,
+          mode: Nextbillionai::MdmCreateDistanceMatrixParams::Mode::OrSymbol,
+          origins_approach:
+            Nextbillionai::MdmCreateDistanceMatrixParams::OriginsApproach::OrSymbol,
+          route_type:
+            Nextbillionai::MdmCreateDistanceMatrixParams::RouteType::OrSymbol,
+          truck_axle_load: Float,
+          truck_size: String,
+          truck_weight: Integer,
+          request_options: Nextbillionai::RequestOptions::OrHash
+        ).returns(Nextbillionai::Models::MdmCreateDistanceMatrixResponse)
+      end
+      def create_distance_matrix(
+        # Query param: A key is a unique identifier that is required to authenticate a
+        # request to the API.
+        key:,
+        # Query param: Use this option to switch to truck-specific routing or time based
+        # routing or if you want to choose between the fastest and shortest route types.
+        option:,
+        # Body param: origins are the starting point of your route. Ensure that origins
+        # are routable land locations. Multiple origins should be separated by a pipe
+        # symbol (|).
+        #
+        # **Format:** latitude_1,longitude_1|latitude_2,longitude_2|…
+        origins:,
+        # Query param: Specify a spliter to split the matrix by. It accepts 2 values:
+        #
+        # - od_number_spliter:
+        #
+        # - straight_distance_spliter:
+        #
+        # Please note it is an internal, debug field only.
+        #
+        # _debug field. choose specific spliter to split matrix._
+        spliter: nil,
+        # Body param: Provide the country that the coordinates belong to.
+        #
+        # _the input coordinates area._
+        area: nil,
+        # Body param: Setting this will ensure the route avoids the object(s) specified as
+        # input. 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.
+        #
+        # - **Note:**
+        #
+        #   - This parameter is effective only when route_type=fastest.
+        #   - When this parameter is not provided in the input, ferries are set to be
+        #     avoided by default. When avoid input is provided, only the mentioned objects
+        #     are avoided.
+        #   - When using avoid=bbox users also need to specify the boundaries of the
+        #     bounding box to be avoid. Multiple bounding boxes can be specified
+        #     simultaneously. Please note that bounding box is a hard filter and if it
+        #     blocks all possible routes between given locations, a 4xx error is returned.
+        #
+        #     - **Format:** bbox: min_latitude,min_longtitude,max_latitude,max_longitude.
+        #     - **Example:** avoid=bbox: 34.0635,-118.2547, 34.0679,-118.2478 | bbox:
+        #       34.0521,-118.2342, 34.0478,-118.2437
+        #
+        #   - When using avoid=sharp_turn, default range of permissible turn angles is
+        #     \[120,240\].
+        avoid: nil,
+        # Body param: Specify if crossing an international border is expected for
+        # operations near border areas. When set to false, the API will prohibit routes
+        # going back & forth between countries. Consequently, routes within the same
+        # country will be preferred if they are feasible for the given set of destination
+        # or waypoints . When set to true, the routes will be allowed to go back & forth
+        # between countries as needed.
+        #
+        # This feature is available in North America region only. Please get in touch with
+        # [support@nextbillion.ai](mailto:support@nextbillion.ai) to enquire/enable other
+        # areas.
+        cross_border: nil,
+        # Body param: This is a number in UNIX epoch timestamp in seconds format that can
+        # be used to provide the departure time. The response will return the distance and
+        # duration of the route based on typical traffic for at the given start time.If no
+        # input is provided for this parameter then the traffic conditions at the time of
+        # making the request are considered.
+        #
+        # Please note that when route_type is set to shortest then the departure_time will
+        # be ineffective as the service will return the result for the shortest path
+        # possible irrespective of the traffic conditions.
+        departure_time: nil,
+        # Body param: destinations are the ending coordinates of your route. Ensure that
+        # destinations are routable land locations. Multiple destinations should be
+        # separated by a pipe symbol (|).
+        #
+        # In case destinations are not provided or if it is left empty, then the input
+        # value of origins will be copied to destinations to create the OD matrix pairs.
+        #
+        # **Format:** latitude_1,longitude_1|latitude_2,longitude_2|…
+        destinations: nil,
+        # Body param: Specify the side of the road from which to approach destinations
+        # points. Please note that the given approach will be applied to all the
+        # destinations.
+        destinations_approach: nil,
+        # Body param: Specify the type of hazardous material being carried and the service
+        # will avoid roads which are not suitable for the type of goods specified.
+        # Multiple values can be separated using a pipe operator | .
+        #
+        # Please note that this parameter is effective only when mode=truck.
+        hazmat_type: nil,
+        # Body param: 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.
+        mode: nil,
+        # Body param: Specify the side of the road from which to approach origins points.
+        # Please note that the given approach will be applied to all the points provided
+        # as origins.
+        origins_approach: nil,
+        # Body param: Set the route type that needs to be returned. Please note that
+        # route_type is effective only when option=flexible.
+        route_type: nil,
+        # Body param: Specify the total load per axle (including the weight of trailers
+        # and shipped goods) of the truck, in tonnes. When used, the service will return
+        # routes which are legally allowed to carry the load specified per axle.
+        #
+        # Please note this parameter is effective only when mode=truck.
+        truck_axle_load: nil,
+        # Body param: This defines the dimensions of a truck in centimeters (cm) in the
+        # format of "height,width,length". This parameter is effective only when
+        # mode=truck and option=flexible. Maximum dimensions are as follows:
+        #
+        # Height = 1000 cm Width = 5000 cm Length = 5000 cm
+        truck_size: nil,
+        # Body param: This parameter defines the weight of the truck including trailers
+        # and shipped goods in kilograms (kg). This parameter is effective only when
+        # mode=truck and option=flexible.
+        truck_weight: nil,
+        request_options: {}
+      )
+      end
+
+      # Get massive distance matrix task status
+      sig do
+        params(
+          id: String,
+          key: String,
+          request_options: Nextbillionai::RequestOptions::OrHash
+        ).returns(Nextbillionai::Models::MdmGetDistanceMatrixStatusResponse)
+      end
+      def get_distance_matrix_status(
+        # Provide the unique ID that was returned on successful submission of the
+        # Asynchronous Distance Matrix POST request.
+        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