nextbillionai 0.1.0.pre.alpha.4

data/lib/nextbillionai/models/lookup_by_id_params.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Models
+    # @see Nextbillionai::Resources::Lookup#by_id
+    class LookupByIDParams < Nextbillionai::Internal::Type::BaseModel
+      extend Nextbillionai::Internal::Type::RequestParameters::Converter
+      include Nextbillionai::Internal::Type::RequestParameters
+
+      # @!attribute id
+      #   Specify the unique identifier of a specific POI, Street, Geography, Point
+      #   Address or other entities to retrieve its details.
+      #
+      #   @return [String]
+      required :id, String
+
+      # @!attribute key
+      #   A key is a unique identifier that is required to authenticate a request to the
+      #   API.
+      #
+      #   @return [String]
+      required :key, String
+
+      # @!method initialize(id:, key:, request_options: {})
+      #   Some parameter documentations has been truncated, see
+      #   {Nextbillionai::Models::LookupByIDParams} for more details.
+      #
+      #   @param id [String] Specify the unique identifier of a specific POI, Street, Geography, Point Addres
+      #
+      #   @param key [String] A key is a unique identifier that is required to authenticate a request to the A
+      #
+      #   @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}]
+    end
+  end
+end

data/lib/nextbillionai/models/lookup_by_id_response.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Models
+    # @see Nextbillionai::Resources::Lookup#by_id
+    class LookupByIDResponse < Nextbillionai::Internal::Type::BaseModel
+      # @!attribute items
+      #   The results are presented as a JSON list of candidates in ranked order
+      #   (most-likely to least-likely) based on the matched location criteria.
+      #
+      #   @return [Array<Nextbillionai::Models::LookupByIDResponse::Item>, nil]
+      optional :items,
+               -> { Nextbillionai::Internal::Type::ArrayOf[Nextbillionai::Models::LookupByIDResponse::Item] }
+
+      # @!method initialize(items: nil)
+      #   Some parameter documentations has been truncated, see
+      #   {Nextbillionai::Models::LookupByIDResponse} for more details.
+      #
+      #   @param items [Array<Nextbillionai::Models::LookupByIDResponse::Item>] The results are presented as a JSON list of candidates in ranked order (most-lik
+
+      class Item < Nextbillionai::Internal::Type::BaseModel
+        # @!attribute id
+        #   The unique identifier for the result item.
+        #
+        #   @return [String, nil]
+        optional :id, String
+
+        # @!attribute access
+        #   An array returning the location coordinates of all the access points of the
+        #   search result.
+        #
+        #   @return [Nextbillionai::Models::Access, nil]
+        optional :access, -> { Nextbillionai::Access }
+
+        # @!attribute address
+        #   Postal address of the result item.
+        #
+        #   @return [Nextbillionai::Models::Address, nil]
+        optional :address, -> { Nextbillionai::Address }
+
+        # @!attribute categories
+        #   The list of categories assigned to this place.
+        #
+        #   @return [Array<Nextbillionai::Models::Categories>, nil]
+        optional :categories, -> { Nextbillionai::Internal::Type::ArrayOf[Nextbillionai::Categories] }
+
+        # @!attribute contacts
+        #   Contact information like phone, email or website.
+        #
+        #   @return [Array<Nextbillionai::Models::Contacts>, nil]
+        optional :contacts, -> { Nextbillionai::Internal::Type::ArrayOf[Nextbillionai::Contacts] }
+
+        # @!attribute map_view
+        #   The bounding box enclosing the geometric shape (area or line) that an individual
+        #   result covers. place typed results have no mapView.
+        #
+        #   @return [Nextbillionai::Models::MapView, nil]
+        optional :map_view, -> { Nextbillionai::MapView }, api_name: :mapView
+
+        # @!attribute position
+        #   Returns the location coordinates of the result.
+        #
+        #   @return [Nextbillionai::Models::Position, nil]
+        optional :position, -> { Nextbillionai::Position }
+
+        # @!attribute title
+        #   The localized display name of this result item.
+        #
+        #   @return [String, nil]
+        optional :title, String
+
+        # @!method initialize(id: nil, access: nil, address: nil, categories: nil, contacts: nil, map_view: nil, position: nil, title: nil)
+        #   Some parameter documentations has been truncated, see
+        #   {Nextbillionai::Models::LookupByIDResponse::Item} for more details.
+        #
+        #   @param id [String] The unique identifier for the result item.
+        #
+        #   @param access [Nextbillionai::Models::Access] An array returning the location coordinates of all the access points of the sear
+        #
+        #   @param address [Nextbillionai::Models::Address] Postal address of the result item.
+        #
+        #   @param categories [Array<Nextbillionai::Models::Categories>] The list of categories assigned to this place.
+        #
+        #   @param contacts [Array<Nextbillionai::Models::Contacts>] Contact information like phone, email or website.
+        #
+        #   @param map_view [Nextbillionai::Models::MapView] The bounding box enclosing the geometric shape (area or line) that an individual
+        #
+        #   @param position [Nextbillionai::Models::Position] Returns the location coordinates of the result.
+        #
+        #   @param title [String] The localized display name of this result item.
+      end
+    end
+  end
+end

data/lib/nextbillionai/models/map_create_segment_params.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Models
+    # @see Nextbillionai::Resources::Map#create_segment
+    class MapCreateSegmentParams < Nextbillionai::Internal::Type::BaseModel
+      extend Nextbillionai::Internal::Type::RequestParameters::Converter
+      include Nextbillionai::Internal::Type::RequestParameters
+
+      # @!method initialize(request_options: {})
+      #   @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}]
+    end
+  end
+end

data/lib/nextbillionai/models/map_view.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Models
+    class MapView < Nextbillionai::Internal::Type::BaseModel
+      # @!attribute east
+      #   Longitude of the eastern-side of the box.
+      #
+      #   @return [String, nil]
+      optional :east, String
+
+      # @!attribute north
+      #   Longitude of the northern-side of the box.
+      #
+      #   @return [String, nil]
+      optional :north, String
+
+      # @!attribute south
+      #   Longitude of the southern-side of the box.
+      #
+      #   @return [String, nil]
+      optional :south, String
+
+      # @!attribute west
+      #   Longitude of the western-side of the box.
+      #
+      #   @return [String, nil]
+      optional :west, String
+
+      # @!method initialize(east: nil, north: nil, south: nil, west: nil)
+      #   The bounding box enclosing the geometric shape (area or line) that an individual
+      #   result covers. place typed results have no mapView.
+      #
+      #   @param east [String] Longitude of the eastern-side of the box.
+      #
+      #   @param north [String] Longitude of the northern-side of the box.
+      #
+      #   @param south [String] Longitude of the southern-side of the box.
+      #
+      #   @param west [String] Longitude of the western-side of the box.
+    end
+  end
+end

data/lib/nextbillionai/models/mdm_create_distance_matrix_params.rb

@@ -0,0 +1,385 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Models
+    # @see Nextbillionai::Resources::Mdm#create_distance_matrix
+    class MdmCreateDistanceMatrixParams < Nextbillionai::Internal::Type::BaseModel
+      extend Nextbillionai::Internal::Type::RequestParameters::Converter
+      include Nextbillionai::Internal::Type::RequestParameters
+
+      # @!attribute key
+      #   A key is a unique identifier that is required to authenticate a request to the
+      #   API.
+      #
+      #   @return [String]
+      required :key, String
+
+      # @!attribute option
+      #   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.
+      #
+      #   @return [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::Option]
+      required :option, enum: -> { Nextbillionai::MdmCreateDistanceMatrixParams::Option }
+
+      # @!attribute origins
+      #   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|…
+      #
+      #   @return [String]
+      required :origins, String
+
+      # @!attribute spliter
+      #   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._
+      #
+      #   @return [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::Spliter, nil]
+      optional :spliter, enum: -> { Nextbillionai::MdmCreateDistanceMatrixParams::Spliter }
+
+      # @!attribute area
+      #   Provide the country that the coordinates belong to.
+      #
+      #   _the input coordinates area._
+      #
+      #   @return [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::Area, nil]
+      optional :area, enum: -> { Nextbillionai::MdmCreateDistanceMatrixParams::Area }
+
+      # @!attribute avoid
+      #   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\].
+      #
+      #   @return [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::Avoid, nil]
+      optional :avoid, enum: -> { Nextbillionai::MdmCreateDistanceMatrixParams::Avoid }
+
+      # @!attribute cross_border
+      #   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.
+      #
+      #   @return [Boolean, nil]
+      optional :cross_border, Nextbillionai::Internal::Type::Boolean
+
+      # @!attribute departure_time
+      #   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.
+      #
+      #   @return [Integer, nil]
+      optional :departure_time, Integer
+
+      # @!attribute destinations
+      #   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|…
+      #
+      #   @return [String, nil]
+      optional :destinations, String
+
+      # @!attribute destinations_approach
+      #   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.
+      #
+      #   @return [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::DestinationsApproach, nil]
+      optional :destinations_approach,
+               enum: -> { Nextbillionai::MdmCreateDistanceMatrixParams::DestinationsApproach }
+
+      # @!attribute hazmat_type
+      #   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.
+      #
+      #   @return [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::HazmatType, nil]
+      optional :hazmat_type, enum: -> { Nextbillionai::MdmCreateDistanceMatrixParams::HazmatType }
+
+      # @!attribute mode
+      #   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.
+      #
+      #   @return [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::Mode, nil]
+      optional :mode, enum: -> { Nextbillionai::MdmCreateDistanceMatrixParams::Mode }
+
+      # @!attribute origins_approach
+      #   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.
+      #
+      #   @return [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::OriginsApproach, nil]
+      optional :origins_approach, enum: -> { Nextbillionai::MdmCreateDistanceMatrixParams::OriginsApproach }
+
+      # @!attribute route_type
+      #   Set the route type that needs to be returned. Please note that route_type is
+      #   effective only when option=flexible.
+      #
+      #   @return [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::RouteType, nil]
+      optional :route_type, enum: -> { Nextbillionai::MdmCreateDistanceMatrixParams::RouteType }
+
+      # @!attribute truck_axle_load
+      #   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.
+      #
+      #   @return [Float, nil]
+      optional :truck_axle_load, Float
+
+      # @!attribute truck_size
+      #   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
+      #
+      #   @return [String, nil]
+      optional :truck_size, String
+
+      # @!attribute truck_weight
+      #   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.
+      #
+      #   @return [Integer, nil]
+      optional :truck_weight, Integer
+
+      # @!method initialize(key:, option:, origins:, spliter: nil, area: nil, avoid: nil, cross_border: nil, departure_time: nil, destinations: nil, destinations_approach: nil, hazmat_type: nil, mode: nil, origins_approach: nil, route_type: nil, truck_axle_load: nil, truck_size: nil, truck_weight: nil, request_options: {})
+      #   Some parameter documentations has been truncated, see
+      #   {Nextbillionai::Models::MdmCreateDistanceMatrixParams} for more details.
+      #
+      #   @param key [String] A key is a unique identifier that is required to authenticate a request to the A
+      #
+      #   @param option [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::Option] Use this option to switch to truck-specific routing or time based routing or if
+      #
+      #   @param origins [String] origins are the starting point of your route. Ensure that origins are routable l
+      #
+      #   @param spliter [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::Spliter] Specify a spliter to split the matrix by. It accepts 2 values:
+      #
+      #   @param area [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::Area] Provide the country that the coordinates belong to.
+      #
+      #   @param avoid [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::Avoid] Setting this will ensure the route avoids the object(s) specified as input. Mult
+      #
+      #   @param cross_border [Boolean] Specify if crossing an international border is expected for operations near bord
+      #
+      #   @param departure_time [Integer] This is a number in UNIX epoch timestamp in seconds format that can be used to p
+      #
+      #   @param destinations [String] destinations are the ending coordinates of your route. Ensure that destinations
+      #
+      #   @param destinations_approach [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::DestinationsApproach] Specify the side of the road from which to approach destinations points. Please
+      #
+      #   @param hazmat_type [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::HazmatType] Specify the type of hazardous material being carried and the service will avoid
+      #
+      #   @param mode [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::Mode] Set which driving mode the service should use to determine a route.
+      #
+      #   @param origins_approach [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::OriginsApproach] Specify the side of the road from which to approach origins points. Please note
+      #
+      #   @param route_type [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::RouteType] Set the route type that needs to be returned. Please note that route_type is eff
+      #
+      #   @param truck_axle_load [Float] Specify the total load per axle (including the weight of trailers and shipped go
+      #
+      #   @param truck_size [String] This defines the dimensions of a truck in centimeters (cm) in the format of "hei
+      #
+      #   @param truck_weight [Integer] This parameter defines the weight of the truck including trailers and shipped go
+      #
+      #   @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}]
+
+      # 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.
+      module Option
+        extend Nextbillionai::Internal::Type::Enum
+
+        FLEXIBLE = :flexible
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+
+      # 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._
+      module Spliter
+        extend Nextbillionai::Internal::Type::Enum
+
+        OD_NUMBER_SPLITER = :od_number_spliter
+        STRAIGHT_DISTANCE_SPLITER = :straight_distance_spliter
+        LOCATION_SPLITER = :location_spliter
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+
+      # Provide the country that the coordinates belong to.
+      #
+      # _the input coordinates area._
+      module Area
+        extend Nextbillionai::Internal::Type::Enum
+
+        SINGAPORE = :singapore
+        USA = :usa
+        INDIA = :india
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+
+      # 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\].
+      module Avoid
+        extend Nextbillionai::Internal::Type::Enum
+
+        TOLL = :toll
+        FERRY = :ferry
+        HIGHWAY = :highway
+        SHARP_TURN = :sharp_turn
+        SERVICE_ROAD = :service_road
+        BBOX = :bbox
+        LEFT_TURN = :left_turn
+        RIGHT_TURN = :right_turn
+        NONE = :none
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+
+      # 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.
+      module DestinationsApproach
+        extend Nextbillionai::Internal::Type::Enum
+
+        UNRESTRICTED = :unrestricted
+        CURB = :curb
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+
+      # 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.
+      module HazmatType
+        extend Nextbillionai::Internal::Type::Enum
+
+        GENERAL = :general
+        CIRCUMSTANTIAL = :circumstantial
+        EXPLOSIVE = :explosive
+        HARMFUL_TO_WATER = :harmful_to_water
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+
+      # 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.
+      module Mode
+        extend Nextbillionai::Internal::Type::Enum
+
+        CAR = :car
+        TRUCK = :truck
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+
+      # 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.
+      module OriginsApproach
+        extend Nextbillionai::Internal::Type::Enum
+
+        UNRESTRICTED = :unrestricted
+        CURB = :curb
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+
+      # Set the route type that needs to be returned. Please note that route_type is
+      # effective only when option=flexible.
+      module RouteType
+        extend Nextbillionai::Internal::Type::Enum
+
+        FASTEST = :fastest
+        SHORTEST = :shortest
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+    end
+  end
+end

data/lib/nextbillionai/models/mdm_create_distance_matrix_response.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Models
+    # @see Nextbillionai::Resources::Mdm#create_distance_matrix
+    class MdmCreateDistanceMatrixResponse < Nextbillionai::Internal::Type::BaseModel
+      # @!attribute code
+      #   A string indicating the state of the response. On successful responses, the
+      #   value will be Ok. Indicative error messages/codes are returned in case of
+      #   errors. See the [API Error Codes](#api-error-codes) section below for more
+      #   information.
+      #
+      #   @return [String, nil]
+      optional :code, String
+
+      # @!attribute message
+      #   Returns the error message in case a request fails. This field will not be
+      #   present in the response, if a request is successfully submitted.
+      #
+      #   @return [String, nil]
+      optional :message, String
+
+      # @!attribute task_id
+      #   A unique ID which can be used in the Asynchronous Distance Matrix GET method to
+      #   retrieve the final result.
+      #
+      #   @return [String, nil]
+      optional :task_id, String
+
+      # @!attribute warning
+      #   Display the warnings, if any, for the given input parameters and values. In case
+      #   there are no warnings then this field would not be present in the response.
+      #
+      #   @return [Array<String>, nil]
+      optional :warning, Nextbillionai::Internal::Type::ArrayOf[String]
+
+      # @!method initialize(code: nil, message: nil, task_id: nil, warning: nil)
+      #   Some parameter documentations has been truncated, see
+      #   {Nextbillionai::Models::MdmCreateDistanceMatrixResponse} for more details.
+      #
+      #   @param code [String] A string indicating the state of the response. On successful responses, the valu
+      #
+      #   @param message [String] Returns the error message in case a request fails. This field will not be presen
+      #
+      #   @param task_id [String] A unique ID which can be used in the Asynchronous Distance Matrix GET method to
+      #
+      #   @param warning [Array<String>] Display the warnings, if any, for the given input parameters and values. In case
+    end
+  end
+end

data/lib/nextbillionai/models/mdm_get_distance_matrix_status_params.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Models
+    # @see Nextbillionai::Resources::Mdm#get_distance_matrix_status
+    class MdmGetDistanceMatrixStatusParams < Nextbillionai::Internal::Type::BaseModel
+      extend Nextbillionai::Internal::Type::RequestParameters::Converter
+      include Nextbillionai::Internal::Type::RequestParameters
+
+      # @!attribute id
+      #   Provide the unique ID that was returned on successful submission of the
+      #   Asynchronous Distance Matrix POST request.
+      #
+      #   @return [String]
+      required :id, String
+
+      # @!attribute key
+      #   A key is a unique identifier that is required to authenticate a request to the
+      #   API.
+      #
+      #   @return [String]
+      required :key, String
+
+      # @!method initialize(id:, key:, request_options: {})
+      #   Some parameter documentations has been truncated, see
+      #   {Nextbillionai::Models::MdmGetDistanceMatrixStatusParams} for more details.
+      #
+      #   @param id [String] Provide the unique ID that was returned on successful submission of the Asynchro
+      #
+      #   @param key [String] A key is a unique identifier that is required to authenticate a request to the A
+      #
+      #   @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}]
+    end
+  end
+end