nextbillionai 0.1.0.pre.alpha.4

data/rbi/nextbillionai/resources/multigeocode/place.rbi

@@ -0,0 +1,155 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Multigeocode
+      class Place
+        # The "Add Place" method allows users to create custom places
+        #
+        # Add place method provides the flexibility to create custom places in a way that
+        # suits your business needs. The newly created place and its attributes can be
+        # added to custom (proprietary) dataset - to the effect of building your own
+        # places dataset (s) - or, to a default dataset. Overcome inaccurate ‘POI’ details
+        # from default search provider by creating custom, highly accurate ‘POIs’.
+        sig do
+          params(
+            key: String,
+            place:
+              T::Array[
+                Nextbillionai::Multigeocode::PlaceCreateParams::Place::OrHash
+              ],
+            data_source:
+              Nextbillionai::Multigeocode::PlaceCreateParams::DataSource::OrHash,
+            force: T::Boolean,
+            score: Integer,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Models::Multigeocode::PlaceCreateResponse)
+        end
+        def create(
+          # Query param: A key is a unique identifier that is required to authenticate a
+          # request to the API.
+          key:,
+          # Body param: This parameter represents the place details, including geographical
+          # information, address and other related information.
+          place:,
+          # Body param: It contains information about the dataset that returns the specific
+          # result
+          data_source: nil,
+          # Body param: When 2 places are located within 100 meters of each other and have
+          # more than 90% of matching attributes (at least 11 out of 12 attributes in the
+          # “place” object), they will be considered duplicates and any requests to add such
+          # a new place would be rejected. Set force=true to override this duplicate check.
+          # You can use this to create closely located POIs. For instance, places inside a
+          # mall, university or a government building etc.
+          force: nil,
+          # Body param: Search score of the place. This is calculated based on how ‘richly’
+          # the place is defined. For instance, a place with - street name, city, state and
+          # country attributes set might be ranked lower than a place which has values of -
+          # house, building, street name, city, state and country attributes set. The score
+          # determines the rank of the place among search results. You can also use this
+          # field to set a custom score as per its relevance to rank it among the search
+          # results from multiple data sources.
+          score: nil,
+          request_options: {}
+        )
+        end
+
+        # Use this method to get the details of previously created custom places using its
+        # NextBillion ID.
+        sig do
+          params(
+            doc_id: String,
+            key: String,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Models::Multigeocode::PlaceRetrieveResponse)
+        end
+        def retrieve(
+          # Unique NextBillion ID of the location to be looked up.
+          doc_id,
+          # A key is a unique identifier that is required to authenticate a request to the
+          # API.
+          key:,
+          request_options: {}
+        )
+        end
+
+        # The "Update Place" method allows businesses to update the attributes of an
+        # existing place.
+        #
+        # This method allows you to update the attributes of custom places. In effect,
+        # updating a place replaces the current information in search results with the
+        # updated information associated with the specific docID. Use this method to
+        # enhance the accuracy/usability of your search results with respect to the
+        # default dataset to suit your business needs.
+        #
+        # If you want to prioritize a particular result in your search results, update the
+        # ‘score’ of that specific place.
+        # Alternatively, you can block places which are no longer needed by setting their
+        # status: ‘disable’.
+        sig do
+          params(
+            doc_id: String,
+            key: String,
+            data_source:
+              Nextbillionai::Multigeocode::PlaceUpdateParams::DataSource::OrHash,
+            place: T::Array[Nextbillionai::Multigeocode::PlaceItem::OrHash],
+            score: Integer,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Models::Multigeocode::PlaceUpdateResponse)
+        end
+        def update(
+          # Path param: Unique NextBillion ID of the location to be updated.
+          doc_id,
+          # Query param: A key is a unique identifier that is required to authenticate a
+          # request to the API.
+          key:,
+          # Body param: dataSource values can be updated to enhance or prioritize the search
+          # results to better suit specific business use cases.
+          data_source: nil,
+          # Body param: This parameter represents the place details, including geographical
+          # information, address and other related information.
+          place: nil,
+          # Body param: Search score of the place. This is calculated based on how ‘richly’
+          # the place is defined. For instance, a place with street name, city, state and
+          # country attributes set might be ranked lower than a place which has values of
+          # house, building, street name, city, state and country attributes set. The score
+          # determines the rank of the place among search results. You can also use this
+          # field to set a custom score as per its relevance to rank it among the search
+          # results from multiple data sources.
+          score: nil,
+          request_options: {}
+        )
+        end
+
+        # The "Delete Place" method enables businesses to delete a previously created
+        # place
+        #
+        # Use this method to delete a previously created place. Please note that the place
+        # associated with the specified docID only would be deleted. As a result, once a
+        # place is deleted, the search API can still return valid results from the default
+        # datasets or others, if present.
+        sig do
+          params(
+            doc_id: String,
+            key: String,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Models::Multigeocode::PlaceDeleteResponse)
+        end
+        def delete(
+          # Unique NextBillion ID of the location to be deleted
+          doc_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/multigeocode.rbi

@@ -0,0 +1,73 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Multigeocode
+      sig { returns(Nextbillionai::Resources::Multigeocode::Place) }
+      attr_reader :place
+
+      # The method enables searching for known places from multiple data sources
+      #
+      # Use this method to find known places in default or your own custom (proprietary)
+      # dataset and get a combined search result. It accepts free-form, partially
+      # correct or even incomplete search texts. Results would be ranked based on the
+      # search score of a place.
+      sig do
+        params(
+          key: String,
+          at: Nextbillionai::MultigeocodeSearchParams::At::OrHash,
+          query: String,
+          city: String,
+          country: String,
+          district: String,
+          limit: Integer,
+          radius: String,
+          state: String,
+          street: String,
+          sub_district: String,
+          request_options: Nextbillionai::RequestOptions::OrHash
+        ).returns(Nextbillionai::Models::MultigeocodeSearchResponse)
+      end
+      def search(
+        # Query param: A key is a unique identifier that is required to authenticate a
+        # request to the API.
+        key:,
+        # Body param: Specify the center of the search context expressed as coordinates.
+        at:,
+        # Body param: A free-form, complete or incomplete string to be searched. It allows
+        # searching for places using keywords or names.
+        query:,
+        # Body param: Specifies the primary city of the place.
+        city: nil,
+        # Body param: Country of the search context provided as comma-separated
+        # [ISO 3166-1 alpha-3](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-3) country
+        # codes.
+        # Note: Country codes should be provided in uppercase.
+        country: nil,
+        # Body param: Specifies the district of the search place.
+        district: nil,
+        # Body param: Sets the maximum number of results to be returned.
+        limit: nil,
+        # Body param: Filters the results to places within the specified radius from the
+        # 'at' location.
+        #
+        # Note: Supports 'meter' (m) and 'kilometer' (km) units. If no radius is given,
+        # the search method returns as many results as specified in limit.
+        radius: nil,
+        # Body param: Specifies the state of the search place.
+        state: nil,
+        # Body param: Specifies the street name of the search place.
+        street: nil,
+        # Body param: Specifies the subDistrict of the search place.
+        sub_district: 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/navigation.rbi

@@ -0,0 +1,152 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Navigation
+      # Nextbillion.ai’s Navigation API is a service that computes a route between 2
+      # places, and also returns detailed turn by turn instructions for the route.
+      #
+      # The Navigation API can be used as an input into your Navigation app.
+      # Alternatively, you can directly use Nextbillion.ai’s Navigation SDK for a
+      # complete turn by turn navigation experience.
+      sig do
+        params(
+          key: String,
+          altcount: Integer,
+          alternatives: T::Boolean,
+          approaches:
+            Nextbillionai::NavigationRetrieveRouteParams::Approaches::OrSymbol,
+          avoid: Nextbillionai::NavigationRetrieveRouteParams::Avoid::OrSymbol,
+          bearings: String,
+          destination: String,
+          geometry:
+            Nextbillionai::NavigationRetrieveRouteParams::Geometry::OrSymbol,
+          lang: String,
+          mode: Nextbillionai::NavigationRetrieveRouteParams::Mode::OrSymbol,
+          origin: String,
+          original_shape: String,
+          original_shape_type:
+            Nextbillionai::NavigationRetrieveRouteParams::OriginalShapeType::OrSymbol,
+          overview:
+            Nextbillionai::NavigationRetrieveRouteParams::Overview::OrSymbol,
+          waypoints: String,
+          request_options: Nextbillionai::RequestOptions::OrHash
+        ).returns(Nextbillionai::Models::NavigationRetrieveRouteResponse)
+      end
+      def retrieve_route(
+        # A key is a unique identifier that is required to authenticate a request to the
+        # API.
+        key:,
+        # Sets the number of alternative routes to return. It is effective only when
+        # "alternatives" is "true". Please note that adding alternative route count does
+        # not guarantee matching number of routes to be returned if potential alternative
+        # routes do not exist.
+        altcount: nil,
+        # When "true" the API will return alternate routes. The "alternatives" is
+        # effective only when there are no "waypoints" included in the request. You can
+        # set the number of alternate routes to be returned in the "altcount" property.
+        alternatives: nil,
+        # A semicolon-separated list indicating the side of the road from which to
+        # approach "waypoints" in a requested route. When set to "unrestricted" a route
+        # can arrive at the waypoint from either side of the road and when set to "curb"
+        # the route will arrive at the waypoint on the driving side of the region. Please
+        # note the number of values provided must be one more than the number of
+        # "waypoints". The last value of "approaches" will determine the approach for the
+        # "destination". 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,
+        # Limits the search to road segments with given bearing, in degrees, towards true
+        # north in clockwise direction. Each "bearings" 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 two more than the number of "waypoints". This is to account
+        # for the bearing of "origin" and "destination". If a route can approach a
+        # "waypoint" or the "destination" from any direction, the bearing for that point
+        # can be specified as "0,180".
+        bearings: nil,
+        # "destination" is the ending point of your route. Ensure that the "destination"
+        # is a routable land location. Please note that this parameter is mandatory if the
+        # "original_shape" parameter is not given.
+        destination: nil,
+        # Sets the output format of the route geometry in the response. On providing
+        # “polyline“ and “polyline6“ as input, respective encoded geometry is returned.
+        # However, when “geojson“ is provided as the input value, “polyline“ encoded
+        # geometry is returned in the response along with the geojson details of the
+        # route.
+        geometry: 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,
+        # 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.
+        #
+        # 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 Navigation 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,
+        # "origin" is the starting point of your route. Ensure that "origin" is a routable
+        # land location. Please note that this parameter is mandatory if the geometry
+        # parameter is not given.
+        origin: nil,
+        # Takes a route geometry as input and returns the navigation information for that
+        # route. Accepts "polyline" and "polyline6" encoded geometry as input.
+        # "original_shape_type" becomes mandatory when "original_shape" is used. If this
+        # parameter is provided, the only other parameters which will be considered are
+        # "original_shape_type", "lang", "geometry". The rest of the parameters in the
+        # input request will be ignored. Please note overview verbosity will always be
+        # "full" when using this parameter.
+        original_shape: nil,
+        # Specify the encoding format of route geometry provided in the request using
+        # "original_shape" parameter. Please note that an error is returned when this
+        # parameter is not specified while an input is added to "original_shape"
+        # parameter.
+        original_shape_type: nil,
+        # Specify the verbosity of route geometry. When set to "full", the most detailed
+        # geometry available is returned. When set to "simplified", a simplified version
+        # of the full geometry is returned. No overview geometry is returned when set to
+        # "false".
+        overview: nil,
+        # "waypoints" are coordinates along the route between the "origin" and
+        # "destination". It is a pipe-separated list of coordinate pairs. Please note that
+        # the route returned will arrive at the "waypoints" in the sequence they are
+        # provided in the input request. Please note that the maximum number of waypoints
+        # that can be provided in a single request is 50 when using GET method and 200
+        # with POST method.
+        waypoints: 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/optimization/driver_assignment.rbi

@@ -0,0 +1,54 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Optimization
+      class DriverAssignment
+        # Assigns available drivers (vehicles) to open orders based on specified criteria
+        # and constraints.
+        sig do
+          params(
+            key: String,
+            filter:
+              Nextbillionai::Optimization::DriverAssignmentAssignParams::Filter::OrHash,
+            orders:
+              T::Array[
+                Nextbillionai::Optimization::DriverAssignmentAssignParams::Order::OrHash
+              ],
+            vehicles: T::Array[Nextbillionai::Optimization::Vehicle::OrHash],
+            options:
+              Nextbillionai::Optimization::DriverAssignmentAssignParams::Options::OrHash,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(
+            Nextbillionai::Models::Optimization::DriverAssignmentAssignResponse
+          )
+        end
+        def assign(
+          # Query param: A key is a unique identifier that is required to authenticate a
+          # request to the API.
+          key:,
+          # Body param: Specify the filtering criterion for the vehicles with respect to
+          # each order's location. filter is a mandatory input for all requests.
+          filter:,
+          # Body param: Collects the details of open orders to be fulfilled. Each object
+          # represents one order. All requests must include orders as a mandatory input. A
+          # maximum of 200 orders is allowed per request.
+          orders:,
+          # Body param: Collects the details of vehicles available to fulfill the orders.
+          # Each object represents one vehicle. All requests must include vehicles as a
+          # mandatory input. A maximum of 100 vehicles is allowed per request.
+          vehicles:,
+          # Body param: Configure the assignment constraints and response settings.
+          options: 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/optimization/v2.rbi

@@ -0,0 +1,217 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Optimization
+      class V2
+        # Flexible GET
+        sig do
+          params(
+            id: String,
+            key: String,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(
+            Nextbillionai::Models::Optimization::V2RetrieveResultResponse
+          )
+        end
+        def retrieve_result(
+          # The unique ID that was returned on successful submission of the Optimization
+          # POST request.
+          id:,
+          # A key is a unique identifier that is required to authenticate a request to the
+          # API.
+          key:,
+          request_options: {}
+        )
+        end
+
+        # Flexible POST
+        sig do
+          params(
+            key: String,
+            locations:
+              Nextbillionai::Optimization::V2SubmitParams::Locations::OrHash,
+            vehicles: T::Array[Nextbillionai::Optimization::Vehicle::OrHash],
+            cost_matrix: T::Array[T::Array[Integer]],
+            depots:
+              T::Array[
+                Nextbillionai::Optimization::V2SubmitParams::Depot::OrHash
+              ],
+            description: String,
+            distance_matrix: T::Array[T::Array[Integer]],
+            duration_matrix: T::Array[T::Array[Integer]],
+            existing_solution_id: String,
+            jobs: T::Array[Nextbillionai::Optimization::Job::OrHash],
+            options:
+              Nextbillionai::Optimization::V2SubmitParams::Options::OrHash,
+            relations:
+              T::Array[
+                Nextbillionai::Optimization::V2SubmitParams::Relation::OrHash
+              ],
+            shipments: T::Array[Nextbillionai::Optimization::Shipment::OrHash],
+            solution:
+              T::Array[
+                Nextbillionai::Optimization::V2SubmitParams::Solution::OrHash
+              ],
+            unassigned:
+              Nextbillionai::Optimization::V2SubmitParams::Unassigned::OrHash,
+            zones:
+              T::Array[
+                Nextbillionai::Optimization::V2SubmitParams::Zone::OrHash
+              ],
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::PostResponse)
+        end
+        def submit(
+          # Query param: A key is a unique identifier that is required to authenticate a
+          # request to the API.
+          key:,
+          # Body param: The locations object is used to define all the locations that will
+          # be used during the optimization process. Read more about this attribute in the
+          # [Location Object](#location-object) section.
+          locations:,
+          # Body param: The vehicles attribute describes the characteristics and constraints
+          # of the vehicles that will be used for fulfilling the tasks. Read more about this
+          # attribute in the [Vehicle Object](#vehicle-object) section.
+          vehicles:,
+          # Body param: An array of arrays to denote the user-defined costs of traveling
+          # between each pair of geographic coordinates mentioned in the location array. The
+          # number of arrays should be equal to the number of coordinate points mentioned in
+          # the location array and each array should contain the same number of elements as
+          # well. Please note that cost_matrix is effective only when
+          # travel_cost=customized. Read more about this attribute in the
+          # [Custom Cost Matrix](#custom-cost-matrix) section.
+          cost_matrix: nil,
+          # Body param: depots object is used to collect the details of a depot. Depots can
+          # be used as a starting point and/or ending point for the routes and vehicles.
+          # They also can be used to fulfil pickup and delivery typejobs . The loads which
+          # are to be delivered at task locations will be picked from depots and loads
+          # picked-up from task locations will be delivered back to the depots. A depot can
+          # be configured using the following fields:
+          depots: nil,
+          # Body param: Define the optimization job using any custom message. This
+          # description is returned as is in the response.
+          description: nil,
+          # Body param: An array of arrays to denote the user-defined distances, in meters,
+          # for travelling between each pair of geographic coordinates mentioned in the
+          # location array. When this input is provided, actual distances between the
+          # locations will be ignored in favor of the values provided in this input for any
+          # distance calculations during the optimization process. The values provided here
+          # will also be used for cost calculations when travel_cost is “distance”.
+          #
+          # The number of arrays in the input should be equal to the number of coordinate
+          # points mentioned in the location array and each array, in turn, should contain
+          # the same number of elements as well.
+          #
+          # **Note:**
+          #
+          # - duration_matrix is mandatory when usingdistance_matrix.
+          # - When using distance_matrix route geometry will not be available in the
+          #   optimized solution.
+          distance_matrix: nil,
+          # Body param: An array of arrays to denote the user-defined durations, in seconds,
+          # for travelling between each pair of geographic coordinates mentioned in the
+          # location array. When this input is provided, actual durations between the
+          # locations will be ignored in favor of the values provided in the matrix for any
+          # ETA calculations during the optimization process. The values provided in the
+          # matrix will also be used for cost calculations when travel_cost is “duration”.
+          #
+          # The number of arrays in the input should be equal to the number of coordinate
+          # points mentioned in the location array and each array, in turn, should contain
+          # the same number of elements as well.
+          #
+          # Please note that, unlike distance_matrix, duration_matrix can be used
+          # independently in following cases:
+          #
+          # - when travel_cost is “duration”
+          # - when travel_cost is “customized” and a cost_matrix is provided
+          #
+          # Also, the route geometry will not be available in the optimized solution when
+          # using duration_matrix.
+          duration_matrix: nil,
+          # Body param: The previous optimization request id used to retrieve solution for
+          # reoptimization
+          existing_solution_id: nil,
+          # Body param: jobs object is used to collect the details of a particular job or
+          # task that needs to be completed as part of the optimization process. Each job
+          # can have either a pickup or delivery step, but not both. Read more about this
+          # attribute in the [Job Object](#job-object) section.
+          #
+          # Please note that either the jobs or the shipments attribute should be specified
+          # to build a valid request.
+          jobs: nil,
+          # Body param: It represents the set of options that can be used to configure
+          # optimization algorithms so that the solver provides a solution that meets the
+          # desired business objectives.
+          options: nil,
+          # Body param: relations attribute is an array of individual relation objects. type
+          # parameter and steps object are mandatory when using this attribute.
+          #
+          # Please note:
+          #
+          # - The soft constraints are **not** effective when using the relations attribute.
+          # - In case a given relation can't be satisfied, the optimizer will flag all the
+          #   tasks involved in that "relation" as unassigned.
+          #
+          # Read more about this attribute in the [Relations Object](#relations-object)
+          # section.
+          relations: nil,
+          # Body param: The shipments object is used to collect the details of shipments
+          # that need to be completed as part of the optimization process.
+          #
+          # Each shipment should have a pickup and the corresponding delivery step.
+          #
+          # Please note that either the jobs or the shipments attribute should be specified
+          # to build a valid request.
+          shipments: nil,
+          # Body param: This attribute is related to the re-optimization feature. It allows
+          # for the previous optimization result to be provided in case new orders are
+          # received and the solution needs to be re-planned. The solution attribute should
+          # contain the same routes as the previous optimization result. solution attribute
+          # is an array of objects with each object corresponding to one route.
+          solution: nil,
+          # Body param: unassigned attribute is related to the re-optimization feature. This
+          # attribute should contain the tasks that were not assigned during an earlier
+          # optimization process. Please note that the unassigned part in request should be
+          # consistent with the unassigned part in the previous optimization result.
+          #
+          # Users can reduce the number of unassigned tasks in the re-optimized solution, by
+          # following strategies such as:
+          #
+          # - Extending the time windows for vehicles or tasks to give more flexibility
+          # - Adding more vehicles to the optimization problem
+          # - Adjusting the priority of different tasks to balance the workload more evenly
+          # - Modifying other constraints or parameters to make the problem more solvable
+          #
+          # Ultimately, the goal is to minimize the number of unassigned tasks while still
+          # meeting all the necessary constraints and objectives.
+          unassigned: nil,
+          # Body param: An array of objects to specify geometry of all the zones involved.
+          # Each object corresponds to a single zone. A valid zone can be a
+          # [geoJSON](https://datatracker.ietf.org/doc/html/rfc7946#page-9) polygon,
+          # multi-polygon or a geofence created using
+          # [NextBillion.ai](http://NextBillion.ai)’s
+          # [Geofence API](https://docs.nextbillion.ai/docs/tracking/api/geofence).
+          #
+          # Please note that
+          #
+          # - Each zone should have a geometry specified either throughgeometry or through
+          #   the geofence_id parameter.
+          # - When zone IDs are not provided for individual tasks (jobs or shipments) then
+          #   the API will automatically allocate zones based on the task’s geolocation and
+          #   the geometries of the zones provided here. Otherwise, if the zone IDs are
+          #   provided while configuring individual tasks, the zone IDs will override the
+          #   geometries provided here.
+          zones: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Nextbillionai::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end